Skip to content

Fix TurbineCooling rotor work order and row exit pressures - #123

Open
anushka-tahiliani wants to merge 2 commits into
OpenMDAO:masterfrom
anushka-tahiliani:cooling-row-bookkeeping
Open

anushka-tahiliani wants to merge 2 commits into
OpenMDAO:masterfrom
anushka-tahiliani:cooling-row-bookkeeping

Conversation

@anushka-tahiliani

Copy link
Copy Markdown

Summary

Fixes two problems in CoolingCalcs, the per-row model behind TurbineCooling. The cooling-flow correlation itself (0.022 constant, 4/3 leakage factor, 0.30/0.13 pattern factors, 0.92 relative temperature, 150 R safety margin) is unchanged.

This PR is needed for the physics-based initial guess method in

A. Tahiliani, H. Hajdik, A. Lamkin, M. Folk, and A. Uranga, "Robust Approach to Engine Cycle Modeling to Enable Multidisciplinary Optimization of Advanced Aircraft," AIAA AVIATION 2026 Forum, 2026. doi:10.2514/6.2026-4499

to work with pyCycle's turbine cooling. The method splits HPT coolant into a chargeable part (vane coolant, which mixes in before the rotor and does work) and a non-chargeable part (rotor coolant, which does no work in its own row). That split only holds if TurbineCooling charges rotor coolant correctly, which is the first fix below.

The method is implemented as a standalone package that provides initial guesses to pyCycle, robust-pycycle-engines. It is also used in an Aviary-compatible package for aircraft optimization, FINCH (ideas-um/FINCH#281; private for now, a public release is planned). robust-pycycle-engines carries this fix as a subclass of CoolingCalcs (cycles/cooling.py), which it can drop once this is merged.

1. Rotor coolant is charged for work it doesn't do

The correlation in CoolingCalcs comes from the COOLIT subroutine in

J. W. Gauntner, "Algorithm for Calculating Turbine Cooling Flow and the Resulting Decrease in Turbine Efficiency," NASA TM-81453, 1980. NTRS 19800011581

COOLIT's listing (p. 14) subtracts each rotor's work from the primary flow and then mixes in that row's coolant:

      IF (KVANE.GT.0) GO TO 70        ! stator: no work
      ...
      HG=HG-DH/WG                     ! rotor: extract work from the primary flow
 70   HG=(WG*HG+W(I)*HC)/(WG+W(I))    ! then mix in this row's coolant
      WG=WG+W(I)

The report gives the reason (p. 9): coolant "ejected into the gas stream downstream of the rotor is directly chargeable to the engine cycle since work cannot be extracted from it."

pyCycle does the two steps in the opposite order:

ht_out = (W_p*ht_p + W_c*ht_c)/(W_p + W_c) - dh/W_p        # dh = turb_pwr/n_stages

The specific work dh/W_p is per unit of primary flow but is subtracted from the mixed stream. So each rotor removes dh*(W_p + W_c)/W_p instead of dh, and in the 2-stage test case the rows remove 2.4% more power than turb_pwr. This PR uses COOLIT's order:

ht_out = (W_p*ht_p - dh + W_c*ht_c)/(W_p + W_c)

The rows now remove exactly turb_pwr. Stators are unchanged (dh = 0). The gas leaving each rotor is hotter, because rotor coolant no longer dilutes the flow before the work is taken out. In a cycle with fixed turbine polytropic efficiency, less flow does the work, so the turbine needs a larger pressure ratio for the same power and its overall adiabatic efficiency comes out lower.

2. Row exit pressures are inverted

# integer math to so you get 1,1,2,2 for the rows of 2 stage machine
self.i_stage = (((i_row)//2) + 1)//n_stages
...
Pt_stage = Pt_out + (Pt_in - Pt_out)*i_stage

The last // makes i_stage 0 or 1 instead of a fraction. With the Pt_stage formula, rows 0–1 of a 2-stage turbine sit at the turbine exit pressure and rows 2–3 at the inlet pressure. i_stage is now the fraction of the pressure drop still to come. Each stator sits at its stage inlet pressure and each rotor at its stage exit pressure: 1, ½, ½, 0 for a 2-stage turbine. The pressure only enters through the mixed-flow thermo, so the effect on temperature is small. COOLIT doesn't compute row pressures, so this is a fix to pyCycle's own addition.

Effect on the test case (test_cooling.test_turbine_cooling, x_factor = 0.9)

row Tt out, before [R] Tt out, after [R] W_cool before W_cool after Pt before [psi] Pt after [psi]
0 (vane 1) 3298.13 3299.00 4.4461 4.4461 149.11 616.74
1 (rotor 1) 2846.18 2859.96 2.2981 2.3009 149.11 382.92
2 (vane 2) 2821.43 2834.11 1.7080 1.7555 616.74 382.92
3 (rotor 2) 2412.20 2430.26 0.9180 0.9550 616.74 149.11
power removed / turb_pwr 1.0238 1.0000

The reference values in this test came from a hand-calculation table that mixes the same way the old code did, so rows 1–3 no longer match it. I kept the table in the docstring with a note. The NPSS output in the same docstring has an HPT exit temperature (FS_45) of 2430.94 R. The new last-row value is 2430.26 R (0.03%); the old one was 2412.20 R (0.8%).

Effect on the N+3 example (example_cycles/N+3ref)

The N+3 reference engine uses TurbineCooling for its HPT, so its benchmarks move. Across the TOC, RTO, SLS and CRZ points of all five benchmarks:

quantity change
TSFC +0.03% to +0.07% at every point
core nozzle Fg −0.67% to +0.43%
burner FAR −0.36% to +0.18%
burner Wfuel −0.17% to +0.09%
HPC exit Pt, OPR 0 to +0.11%
spool speeds, fan/bypass flow and thrust < 0.05%

I regenerated the asserted values in benchmark_N3ref.py, benchmark_N3_SPD.py, benchmark_N3_MDP.py, benchmark_N3_MDP_verif.py and benchmark_N3_MDP_Opt.py. Only values whose relative change exceeded 1e-6 were rewritten, with their original number of decimals; nothing else in those files changed. All five benchmarks pass.

Changes

  • pycycle/elements/cooling.py: COOLIT's work-then-mix order for ht_out and its partials, and the corrected i_stage.
  • pycycle/elements/test/test_cooling.py:
    • updated reference values;
    • new checks that the rows remove exactly turb_pwr and that row pressures are 1, ½, ½, 0 of the drop;
    • the partials check now covers all four rows with complex step at atol=rtol=1e-8 (before: finite difference on two rows at rtol=1e2).
  • example_cycles/N+3ref/benchmark_N3*.py: regenerated reference values.

No other test or benchmark uses TurbineCooling. The full test suite passes, and so does ruff check . --select NPY201.

CoolingCalcs subtracted the rotor's specific work dh/W_primary from the
mixed primary and cooling flow, so each rotor removed dh*W_out/W_primary
and the rows together extracted more than turb_pwr. A rotor now extracts
its work from the primary flow before its coolant mixes in, as in the
COOLIT subroutine of NASA TM-81453 (Gauntner, 1980) that the cooling
correlation comes from. The rows remove exactly turb_pwr and rotor
coolant does no work in its own row.

The integer division in i_stage made the stage fraction 0 or 1, which
put the first stage rows at the turbine exit pressure and the second
stage rows at the inlet pressure. Stators now sit at their stage inlet
pressure and rotors at their stage exit pressure.

Update the test reference values, check energy conservation and row
pressures, and check partials of all rows with complex step at 1e-8.
Regenerate the N+3 benchmark values, which use TurbineCooling for the
HPT; TSFC rises 0.03-0.07% at every point.
Reference the COOLIT subroutine (Gauntner, NASA TM-81453) as the source
of the cooling flow correlation and of the order of rotor work
extraction and coolant mixing, note that the row exit pressures are not
part of COOLIT, and reword a formula comment in compute_partials that
read like commented-out code.
@anushka-tahiliani
anushka-tahiliani marked this pull request as ready for review November 17, 2026 15:53

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant