GitHub

Propulsion system

A turbofan model is provided in TASOPT.jl

Turbofan model

TASOPT.engine.tfcalc! — Function
tfcalc(wing, engine, parg, para, pare, ip, ifuel, opt_calc_call, opt_cooling, initializes_engine)

Calls function tfsize or tfoper for one operating point.

🔃 Inputs and Outputs

Input:

  • opt_calc_call: "sizing" call on-design sizing routine tfsize "operfixedTt4" call off-design analysis routine tfoper, specified Tt4 "operfixedFe" call off-design analysis routine tfoper, specified Fe

  • opt_cooling: turbine cooling flag "none" = no cooling mass flow "fixedcoolingflowratio" = use specified cooling flow ratios epsrow(.), calculate Tmrow(.) "fixedTmetal" = use specified metal temperatures Tmrow(.) , calculate epsrow(.)

  • initializes_engine: true initialize variables for iteration in TFOPER false use current variables as initial guesses in TFOPER

source
TASOPT.engine.tfsize! — Function
tfsize!(gee, M0, T0, p0, a0, M2, M25,
  Feng, Phiinl, Kinl, eng_has_BLI_cores,
  BPR, pif, pilc, pihc,
  pid, pib, pifn, pitn,
  Ttf, ifuel, etab,
  epf0, eplc0, ephc0, epht0, eplt0,
  mofft, Pofft,
  Tt9, pt9, Tt4,
  epsl, epsh,
  opt_cooling,
  Mtexit, dTstrk, StA, efilm, tfilm,
  M4a, ruc,
  ncrowx, ncrow,
  epsrow, Tmrow, 
  Δh_PreC, Δh_InterC, Δh_Regen, Δh_TurbC,
  Δp_PreC, Δp_InterC, Δp_Regen)

Turbofan performance and sizing routine.

Calculation procedure follows that of Kerrebrock, but the usual gas property formulas are replaced by function calls, which can therefore implement more general gas models. In addition, a turbine cooling model is added.

The gas routines reside in the following source files: gascalc.f Routines for various processes (compressor, turbine, combustor, etc) gasfun.f Routines for computing cp[T], h[t], sigma[T], R, called by the routines in gascalc.f

🔃 Inputs and Outputs

Inputs:

  • gee: gravity acceleration

  • M0: freestream Mach

  • T0: freestream temperature [K]

  • p0: freestream pressure [Pa]

  • M2: fan-face Mach number

  • M25: HPC-face Mach number

  • Feng: required net thrust (PKinl+PKout-Phi_jet)/u0 = sum( mdot u)

  • Phiinl: inlet ingested dissipation

  • eng_has_BLI_cores: false=core in clear flow, true=core sees Phiinl

  • BPR: bypass ratio = mdotfan/mdotcore

  • pif: fan pressure ratio ( = pt7 /pt2)

  • pilc: LP comp pressure ratio ( = pt25/pt2)

  • pihc: HP comp pressure ratio ( = pt3 /pt25)

  • pid: diffuser pressure ratio ( = pt2 /pt0)

  • pib: burner pressure ratio ( = pt4 /pt3)

  • pifn: fan nozzle pressure ratio ( = pt7/pt2.1)

  • pitn: turbine nozzle pressure ratio ( = pt5/pt4.9)

  • Ttf: fuel temperature entering combustor

  • ifuel: fuel index, see function gasfun (in gasfun.f)

  • hvap: fuel enthalpy of vaporization (J/kg)

  • etab: combustor efficiency (fraction of fuel burned)

  • epf0: fan max polytropic efficiency

  • eplc0: LPC max polytropic efficiency

  • ephc0: HPC max polytropic efficiency

  • epht0: HPT max polytropic efficiency

  • eplt0: LPT max polytropic efficiency

  • mofft: mass flow offtake at LPC discharge station 2.5

  • Pofft: low spool power offtake

  • Tt9: offtake air discharge total temperature

  • pt9: offtake air discharge total pressure

  • epsl: low spool power loss fraction

  • epsh: high spool power loss fraction

  • opt_cooling: turbine cooling flag "none" = no cooling, ignore all cooling parameters below "fixedcoolingflowratio" = usual cooling, using passed-in fcool "fixedTmetal" = usual cooling, but set (and return) fcool from Tmetal

  • Mtexit: turbine blade-row exit Mach, for setting temperature drops

  • dTstrk: hot-streak temperature delta {K}, used only if optcooling="fixedTmetal"

  • StA: area-weighted Stanton number , used only if optcooling="fixedTmetal"

  • M4a: effective Mach at cooling-flow outlet (start of mixing)

  • ruc: cooling-flow outlet velocity ratio, u/ue

  • ncrowx: dimension of epsrow array

  • ncrow: number of blade rows requiring cooling

  • epsrow(.): input specified cooling-flow bypass ratio if optcooling="fixedcoolingflowratio" output resulting cooling-flow bypass ratio if optcooling="fixedTmetal"

  • Tmrow(.): input specified metal temperature [K] if optcooling="fixedTmetal" output resulting metal temperature [K] if optcooling="fixedcoolingflowratio"

    Outputs:

  • epsrow(.): see above

  • Tmrow(.): see above

  • TSFC: thrust specific fuel consumption = mdot_fuel g / F [1/s]

  • Fsp: specific thrust = F / (mdot u0) = F / ((1+BPR) mdot_core u0)

  • hfuel: fuel heating value [J / kg K]

  • ff: fuel mass flow fraction = mdotfuel / mdotcore

  • mcore: core mass flow = mdot_core [kg/s]

  • A2: fan-face area [m^2]

  • A25: HPC-face area [m^2]

  • A5: core nozzle area [m^2]

  • A7: fan nozzle area [m^2]

  • A6: core plume area [m^2]

  • A8: fan plume area [m^2]

  • Tt?: total temperature

  • ht?: total complete enthalpy (includes heat of formation)

  • pt?: total pressure

  • cpt?: specific heat at stagnation temperature (= dh/dT)

  • Rt?: gas constant at stagnation conditions

  • T?: static temperature

  • u?: velocity

  • epf: fan polytropic efficiency

  • eplc: LPC polytropic efficiency

  • ephc: HPC polytropic efficiency

  • epht: HPT polytropic efficiency

  • eplt: LPT polytropic efficiency

  • etaf: fan overall efficiency

  • etalc: LPC overall efficiency

  • etahc: HPC overall efficiency

  • etaht: HPT overall efficiency

  • etalt: LPT overall efficiency

  • Lconv: T if convergence was successful, F otherwise

The "?" symbol denotes the station index: 0 freestream 18 fan face outside of casing BLs 19 fan face over LPC portion 2 fan face over fan portion 21 fan exit 25 LPC exit, HPC inlet 3 compressor exit 4 combustor exit before cooling air addition 41 turbine inlet after cooling air addition 45 HPT exit, LPT inlet 49 LPT exit 5 core nozzle 6 core flow downstream 7 fan nozzle 8 fan flow downstream

source
TASOPT.engine.tfweight — Function
tfweight(ac)

Engine weight estimation function using Giulia Pantalone, Drela, or Fitzgerald model.

🔃 Inputs and Outputs

Input:

  • ac::aircraft: aircraft object

Output:

  • Weng: Total engine weight.
  • Wnac: Nacelle weight.
  • Webare: Bare engine weight.
  • Snace1: Nacelle area.
source

Turbofan Maps

TASOPT.engine.Ncmap — Method
Ncmap(pratio, mb, piD, mbD, NbD, Cmap)

Calculates compressor or fan corrected speed as a function of pressure ratio and corrected mass flow

🔃 Inputs and Outputs

Inputs:

  • pratio: pressure ratio
  • mb: corrected mass flow
  • piD: design pressure ratio
  • mbD: design corrected mass flow
  • NbD: design corrected speed
  • Cmap(.): map constants

Outputs:

  • Nb: wheel speed
  • Nb_?: derivatives
source
TASOPT.engine.ecmap — Method
ecmap(pratio, mb, piD, mbD, Cmap, effo, piK, effK)

Calculates compressor or fan efficiency as a function of pressure ratio and corrected mass flow

🔃 Inputs and Outputs

Inputs:

  • pratio: pressure ratio
  • mb: corrected mass flow
  • piD: design pressure ratio
  • mbD: design corrected mass flow
  • Cmap(.): map constants
  • effo: maximum efficiency
  • piK: pi-dependence offset eff = effo + effK*(pi-piK)
  • effK: pi-dependence slope

Outputs:

  • eff: efficiency
  • eff_?: derivatives
source
TASOPT.engine.Ncmap1 — Method
Ncmap1(pratio, m, piD, mbD, NbD, ABCDm, iabcd, Tr, pr)

Calculates compressor or fan efficiency as a function of pressure ratio and corrected mass flow

🔃 Inputs and Outputs

Inputs:

  • pratio: pressure ratio
  • mb: corrected mass flow
  • piD: design pressure ratio
  • mbD: design corrected mass flow
  • NbD: design corrected speed
  • ABCDm: map constants
  • iabcd: map exponents
  • Tr: T/Tref
  • pr: p/pref

Outputs:

  • N: wheel speed
  • N_?: derivatives
source
TASOPT.engine.ecmap1 — Method
ecmap1(pratio, m, piD, mbD, ABCDm, iabcd, effo, Tr, pr)

Calculates compressor or fan efficiency as a function of pressure ratio and mass flow

🔃 Inputs and Outputs

Inputs:

  • pratio: pressure ratio
  • mb: corrected mass flow
  • piD: design pressure ratio
  • mbD: design corrected mass flow
  • ABCDm: map constants
  • iabcd: map exponents
  • effo: maximum efficiency
  • Tr: T/Tref
  • pr: p/pref

Outputs:

  • eff: efficiency
  • eff_?: derivatives
source
TASOPT.engine.etmap — Method
etmap(dh, mb, Nb, piD, mbD, NbD, ept0, Tmap, Tt, cpt, Rt)

Calculates turbine efficiency as a function of work and corrected mass flow

🔃 Inputs and Outputs

Inputs:

  • dh: enthalpy change
  • mb: corrected mass flow
  • Nb: corrected speed
  • piD: design pressure ratio
  • mbD: design corrected mass flow
  • NbD: design corrected speed
  • ept0: turbine polytropic efficiency estimate
  • Tmap(.): map constants

Outputs:

  • eff: efficiency
  • eff_?: derivatives
source
TASOPT.engine.Pimap — Method
Pimap(mb, Nb, piD, mbD, NbD, Cmap)

Calculates compressor or fan pressure ratio as a function of pressure ratio and corrected mass flow

🔃 Inputs and Outputs

Inputs:

  • mb: corrected mass flow
  • Nb: corrected speed
  • piD: design pressure ratio
  • mbD: design corrected mass flow
  • NbD: design corrected speed
  • Cmap(.): map constants

Outputs:

  • pratio: pressure ratio
  • pi_?: derivatives
source
TASOPT.engine.tfoper! — Function

function tfoper!(gee, M0, T0, p0, a0, Tref, pref, Phiinl, Kinl, enghasBLIcores, pid, pib, pifn, pitn, Gearf, pifD, pilcD, pihcD, pihtD, piltD, mbfD, mblcD, mbhcD, mbhtD, mbltD, NbfD, NblcD, NbhcD, NbhtD, NbltD, A2, A25, A5, A7, optcalccall, Ttf, ifuel, etab, epf0, eplc0, ephc0, epht0, eplt0, mofft, Pofft, Tt9, pt9, epsl, epsh, optcooling, Mtexit, dTstrk, StA, efilm, tfilm, M4a, ruc, ncrowx, ncrow, epsrow, Tmrow, Feng, M2, pif, pilc, pihc, mbf, mblc, mbhc, Tt4, pt5, mcore, M25)

Turbofan operation routine

Calculation procedure follows that of Kerrebrock,
but the usual gas property formulas are replaced
by function calls, which can therefore implement
more general gas models.  
In addition, a turbine cooling model is added.

The gas routines reside in the following source files:
 gascalc.f  Routines for various processes 
            (compressor, turbine, combustor, etc)
 gasfun.f   Routines for computing cp[T], h[t], sigma[T], R,
            called by the routines in gascalc.f
🔃 Inputs and Outputs

Inputs:

  • gee: gravity acceleration

  • M0: freestream Mach

  • T0: freestream temperature [K]

  • p0: freestream pressure [Pa]

  • Tref: reference temperature for corrected mass flow and speed

  • pref: reference pressure for corrected mass flow

  • Phiinl: inlet ingested dissipation Phi_inl

  • eng_has_BLI_cores: false=core in clear flow, true=core sees Phiinl

  • pid: diffuser pressure ratio ( = pt2/pt0)

  • pib: burner pressure ratio ( = pt4/pt3)

  • pifn: fan nozzle pressure ratio ( = pt7/pt6.9)

  • pitn: turbine nozzle pressure ratio ( = pt5/pt4.9)

  • Gearf: fan gear ratio ( = Nl/Nf )

  • pifD: design fan pressure ratio ( = pt21/pt2 )

  • pilcD: design LPC pressure ratio ( = pt25/pt19)

  • pihcD: design HPC pressure ratio ( = pt3 /pt25)

  • pihtD: design HPT pressure ratio ( = pt45/pt41)

  • piltD: design LPT pressure ratio ( = pt49/pt45)

  • mbfD: design corrected fan mass flow ( = mf*sqrt(Tt2 /Tref)/(pt2 /pref) )

  • mblcD: design corrected LPC mass flow ( = mc*sqrt(Tt19/Tref)/(pt19/pref) )

  • mbhcD: design corrected HLC mass flow ( = mc*sqrt(Tt25/Tref)/(pt25/pref) )

  • mbhtD: design corrected HPT mass flow ( = mt*sqrt(Tt41/Tref)/(pt41/pref) )

  • mbltD: design corrected LPT mass flow ( = mt*sqrt(Tt45/Tref)/(pt45/pref) )

  • NbfD: design corrected fan speed ( = Nf/sqrt(Tt2 /Tref) )

  • NblcD: design corrected LPC speed ( = Nl/sqrt(Tt19/Tref) )

  • NbhcD: design corrected HPC speed ( = Nh/sqrt(Tt25/Tref) )

  • NbhtD: design corrected HPT speed ( = Nh/sqrt(Tt41/Tref) )

  • NbltD: design corrected LPT speed ( = Nl/sqrt(Tt45/Tref) )

  • A2: fan-face area [m^2] mf = mcBPR, mt = mc(1+ff)

  • A25: HPC-face area [m^2]

  • A5: core nozzle area [m^2]

  • A7: fan nozzle area [m^2]

  • opt_calc_call: = "operfixedTt4", Tt4 is specified = "operfixedFe", Feng is specified

  • Tt4: turbine-inlet total temperature [K]

  • Ttf: fuel temperature entering combustor

  • ifuel: fuel index, see function gasfun (in gasfun.f)

  • hvap: fuel enthalpy of vaporization (J/kg)

  • etab: combustor efficiency (fraction of fuel burned)

  • epf0: max fan polytropic efficiency

  • eplc0: LPC max polytropic efficiency

  • ephc0: HPC max polytropic efficiency

  • epht0: HPT max polytropic efficiency

  • eplt0: LPT max polytropic efficiency

  • mofft: mass flow offtake at LPC discharge station 2.5

  • Pofft: low spool power offtake

  • Tt9: offtake air discharge total temperature

  • pt9: offtake air discharge total pressure

  • epsl: low spool power loss fraction

  • epsh: high spool power loss fraction

  • opt_cooling: turbine cooling flag "none" = no cooling, ignore all cooling parameters below "fixedcoolingflowratio" = usual cooling, using passed-in fcool "fixedTmetal" = usual cooling, but set (and return) fcool from Tmetal

  • Mtexit: turbine blade-row exit Mach, for setting temperature drops

  • Tmetal: specified metal temperature [K], used only if optcooling="fixedTmetal"

  • dTstrk: hot-streak temperature delta {K}, used only if optcooling="fixedTmetal"

  • StA: area-weighted Stanton number , used only if optcooling="fixedTmetal"

  • M4a: effective Mach at cooling-flow outlet (start of mixing)

  • ruc: cooling-flow outlet velocity ratio, u/ue

  • ncrowx: dimension of epsrow array

  • ncrow: number of blade rows requiring cooling

  • epsrow(.): input specified cooling-flow bypass ratio if optcooling="fixedcoolingflowratio" output resulting cooling-flow bypass ratio if optcooling="fixedTmetal"

  • Tmrow(.): input specified metal temperature [K] if optcooling="fixedTmetal" output resulting metal temperature [K] if optcooling="fixedcoolingflowratio"

    Output:

  • epsrow(.): see above
  • Tmrow(.): see above
  • TSFC: thrust specific fuel consumption = mdot_fuel g / F [1/s]
  • Fsp: specific thrust = F / (mdot u0) = F / ((1+BPR) mdot_core u0)
  • hfuel: fuel heating value [J / kg K]
  • ff: fuel mass flow fraction = mdotfuel / mdotcore
  • Feng: net effective thrust = (PKinl+PKout-Phi_jet)/u0 = sum( mdot u)
  • mcore: core mass flow = mdot_core [kg/s]
  • BPR: bypass ratio = mdotfan/mdotcore
  • Tt?: total temperature
  • ht?: total complete enthalpy (includes heat of formation)
  • pt?: total pressure
  • cpt?: specific heat at stagnation temperature (= dh/dT)
  • Rt?: gas constant at stagnation conditions
  • T?: static temperature
  • u?: velocity
  • etaf: fan overall efficiency
  • etac: compressor overall efficiency
  • etatf: fan-turbine overall efficiency
  • etatc: comp-turbine overall efficiency
  • Lconv: T if convergence was successful, F otherwise

The "?" symbol denotes the station index: 0 freestream 18 fan face outside of casing BLs 19 fan face over LPC portion 2 fan face over fan portion 21 fan exit, precooler inlet 19c precooler outlet, LPC inlet 25 LPC exit, intercooler inlet 25c intercooler exit, HPC inlet 3 compressor exit 4 combustor exit before cooling air addition 41 turbine inlet after cooling air addition 45 HPT exit, LPT inlet 49 LPT exit, regenerative cooler inlet 49c regenerative cooler outlet 5 core nozzle 6 core flow downstream 7 fan nozzle 8 fan flow downstream

source

Turbofan Cooling

TASOPT.engine.mcool — Method
mcool(ncrowx, Tmrow, Tt3, Tt4, dTstreak, Trrat, efilm, tfilm, StA)

Calculates cooling mass flow requirement.

🔃 Inputs and Outputs

Inputs:

  • ncrowx: dimension of Tmrow(.),epsrow(.) arrays (max number of blade rows)
  • Tmrow(.): design metal temperature for each blade row
  • Tt3: cooling flow temperature
  • Tt4: hot gas temperature from burner
  • dTstreak: hot-streak temperature increase over Tt4, for first blade row
  • Trrat: static temperature ratio across each blade row, T4.1 / T4
  • efilm: cooling efficiency = (Tco-Tci)/(Tmetal-Tci)
  • tfilm: film effectiveness = (Tgas-Tfaw)/(Tgas-Tco) Tco = temperature of cooling air exiting blade Tci = temperature of cooling air entering blade Tfaw = film adiabatic wall temperature (for insulated-wall case) StA`: area-weighted external Stanton number = St (Asurf/Aflow) cpgas/cpcool

Output:

  • ncrow: number of blade rows which need cooling
  • epsrow(.): cooling mass flow ratio for each blade row, mcrow/m_air
source
TASOPT.engine.Tmcalc — Method
Tmcalc(ncrowx, ncrow, Tt3, Tt4, dTstreak, Trrat, efilm, tfilm, StA, epsrow)

Calculates metal temperature for blade row

🔃 Inputs and Outputs

Inputs:

  • ncrowx: dimension of Tmrow(.),epsrow(.) arrays (max number of blade rows)
  • ncrow: number of blade rows which are cooled
  • epsrow(.): cooling mass flow ratio for each blade row, mcrow/m_air
  • Tt3: cooling flow temperature
  • Tt4: hot gas temperature from burner
  • dTstreak: hot-streak temperature increase over Tt4, for first blade row
  • Trrat: static temperature ratio across each blade row, T4.1 / T4
  • efilm: cooling efficiency = (Tco-Tci)/(Tmetal-Tci)
  • tfilm: film effectiveness = (Tgas-Tfaw)/(Tgas-Tco) Tco = temperature of cooling air exiting blade Tci = temperature of cooling air entering blade Tfaw = film adiabatic wall temperature (for insulated-wall case)
  • StA: area-weighted external Stanton number = St (Asurf/Aflow) cpgas/cpcoolOutput:
  • Tmrow(.): design metal temperature for each blade row
source

Turbomachinery Components

The compressor off-design performance is determined by interpolation to the compressor maps in pyCycle[1]. The compressor parameters are scaled to the design pressure ratios, speeds, and mass flow rates in the pyCycle maps by using

\[ \tilde{p} = \frac{\pi -1}{\pi_D -1}\]

\[ \tilde{m} = \frac{\bar{m}}{\bar{m}_D}\]

\[ \tilde{N} = \frac{\bar{N}}{\bar{N}_D},\]

where $\pi$ represents the pressure ratio, $\bar{m}$ is the corrected mass flow rate, $\bar{N}$ is the corrected speed, and the subscript $D$ denotes the design values. For a given set of compressor parameters, the normalized parameters $\tilde{p}$, $\tilde{m}$, and $\tilde{N}$ are used to calculate the dimensional values in the pyCycle map space.

The pyCycle maps contain data for pressure ratio, corrected mass flow rate, and isentropic efficiency as a function of corrected speed and R-line parameter. However, the turbofan operation function, tfoper!(), is set up so that the polytropic efficiency and corrected speed is calculated from the pressure ratio and corrected mass flow rate. Therefore, a reverse interpolation problem is required to compute these parameters. For this, the compressor maps are extrapolated and a standard non-linear solver is used in find_NR_inverse_with_derivatives() to calculate the corrected speed and R-line parameter that correspond to given corrected mass flow rate and pressure ratio. The extrapolated pressure ratio and polytropic efficiency maps are shown below. These parameters are then translated to the scaled map by using $\tilde{p}$, $\tilde{m}$, and $\tilde{N}$ in calculate_compressor_speed_and_efficiency(), which also returns the polytropic efficiency and derivatives.

PEMfig PEMfig

TASOPT.engine.calculate_compressor_speed_and_efficiency — Function
calculate_compressor_speed_and_efficiency(map, pratio, mb, piD, mbD, NbD, epol0; Ng=0.5, Rg=2.0)

Calculates corrected speed and polytropic efficiency for a compressor, along with derivatives to pressure ratio and mass flow.

🔃 Inputs and Outputs

Inputs:

  • map::CompressorMap: structure containing the compressor map and interpolations.
  • pratio::Float64: compressor pressure ratio.
  • mb::Float64: current mass flow rate.
  • piD::Float64: design pressure ratio.
  • mbD::Float64: design mass flow rate.
  • NbD::Float64: design rotational speed.
  • epol0::Float64: maximum polytropic efficiency.
  • Ng::Float64: initial guess for normalized speed (optional).
  • Rg::Float64: initial guess for R-line (optional).

Outputs:

  • Nb::Float64: corrected compressor speed.
  • epol::Float64: polytropic efficiency.
  • dNb_dpi::Float64: derivative of corrected speed w.r.t. piD.
  • dNb_dmb::Float64: derivative of corrected speed w.r.t. mb.
  • depol_dpi::Float64: derivative of efficiency w.r.t. piD.
  • depol_dmb::Float64: derivative of efficiency w.r.t. mb.
  • N::Float64: matched normalized speed.
  • R::Float64: matched R-line.
source
TASOPT.engine.find_NR_inverse_with_derivatives — Function
find_NR_inverse_with_derivatives(itp_Wc, itp_PR, Wc_target, PR_target; Ng=0.5, Rg=2.0)

Finds the normalized speed N and R-line R corresponding to a target corrected mass flow Wc_target and pressure ratio PR_target, using a nonlinear solver with Jacobian information from interpolation gradients.

🔃 Inputs and Outputs

Inputs:

  • itp_Wc::GriddedInterpolation: interpolation of corrected mass flow over (N, R).
  • itp_PR::GriddedInterpolation: interpolation of pressure ratio over (N, R).
  • Wc_target::Float64: target corrected mass flow.
  • PR_target::Float64: target pressure ratio.
  • Ng::Float64: initial guess for normalized speed (optional).
  • Rg::Float64: initial guess for R-line (optional).

Outputs:

  • N::Float64: normalized speed at the matched point.
  • R::Float64: R-line value at the matched point.
  • dN_dw::Float64: ∂N/∂Wc
  • dN_dpr::Float64: ∂N/∂PR
  • dR_dw::Float64: ∂R/∂Wc
  • dR_dpr::Float64: ∂R/∂PR
source
  • 1https://github.com/OpenMDAO/pyCycle