def turbofan_thrust(aircraft, Pamb, Tamb, Mach, rating, nei):
"""
Calculation of thrust for pure turbofan airplane
Warning : ALL engine thrust returned
"""
engine = aircraft.turbofan_engine
nacelle = aircraft.turbofan_nacelle
factor = engine.rating_factor # [MTO,MCN,MCL,MCR,FID]
kth = 0.475*Mach**2 + 0.091*(engine.bpr/10)**2 \
- 0.283*Mach*engine.bpr/10 \
- 0.633*Mach - 0.081*engine.bpr/10 + 1.192
(rho, sig) = earth.air_density(Pamb, Tamb)
fn0 = factor[rating] * kth * engine.reference_thrust * sig**0.75
fn_core = fn0 * engine.core_thrust_ratio # Core thrust
fn_fan0 = fn0 * (1 - engine.core_thrust_ratio) # Fan thrust
Vsnd = earth.sound_speed(Tamb)
Vair = Vsnd * Mach
shaft_power0 = fn_fan0 * Vair / nacelle.efficiency_prop # Available total shaft power for one engine
fn = fn0 * (engine.n_engine - nei) # All turbofan thrust
data = (fn_core, fn_fan0, fn0, shaft_power0
) # Data for ONE turbofan engine
return fn, data
def air_path(aircraft, nei, altp, disa, speed_mode, speed, mass, rating):
"""
Retrieves air path in various conditions
"""
g = earth.gravity()
[pamb, tamb, tstd, dtodz] = earth.atmosphere(altp, disa)
mach = get_mach(pamb, speed_mode, speed)
fn, data = propu.thrust(aircraft, pamb, tamb, mach, rating, nei)
cz = lift_from_speed(aircraft, pamb, mach, mass)
[cx, lod] = aero.drag(aircraft, pamb, tamb, mach, cz)
if (nei > 0):
dcx = propu.oei_drag(aircraft, pamb, mach)
cx = cx + dcx * nei
lod = cz / cx
acc_factor = earth.climb_mode(speed_mode, dtodz, tstd, disa, mach)
slope = (fn / (mass * g) - 1 / lod) / acc_factor
vsnd = earth.sound_speed(tamb)
v_z = mach * vsnd * slope
return slope, v_z
def fct_power_bli(y, PwShaft, Pamb, rho, Ttot, Vair, r1, d1, nozzle_area):
(q0, q1, q2, Vinlet, dVbli) = air_flows(rho, Vair, r1, d1, y)
PwInput = nacelle.efficiency_fan * PwShaft
Vjet = numpy.sqrt(2. * PwInput / q1 + Vinlet**2)
TtotJet = Ttot + PwShaft / (
q1 * Cp) # Stagnation temperature increases due to introduced work
Tstat = TtotJet - 0.5 * Vjet**2 / Cp # Static temperature
VsndJet = earth.sound_speed(Tstat) # Sound speed at nozzle exhaust
MachJet = Vjet / VsndJet # Mach number at nozzle output
PtotJet = earth.total_pressure(
Pamb, MachJet
) # total pressure at nozzle exhaust (P = Pamb) supposing adapted nozzle
CQoA1 = corrected_air_flow(
PtotJet, TtotJet,
MachJet) # Corrected air flow per area at nozzle position
q = CQoA1 * nozzle_area
y = q1 - q
return y
def fct_power(q, PwShaft, Pamb, Ttot, Vair, NozzleArea):
Vinlet = Vair
PwInput = nacelle.efficiency_fan * PwShaft
Vjet = numpy.sqrt(2. * PwInput / q +
Vinlet**2) # Supposing isentropic compression
TtotJet = Ttot + PwShaft / (
q * Cp) # Stagnation temperature increases due to introduced work
TstatJet = TtotJet - 0.5 * Vjet**2 / Cp # Static temperature
VsndJet = earth.sound_speed(TstatJet) # Sound speed at nozzle exhaust
MachJet = Vjet / VsndJet # Mach number at nozzle output
PtotJet = earth.total_pressure(
Pamb, MachJet) # total pressure at nozzle exhaust (P = Pamb)
CQoA1 = corrected_air_flow(
PtotJet, TtotJet,
MachJet) # Corrected air flow per area at fan position
q0 = CQoA1 * NozzleArea
y = q0 - q
return y
def specific_air_range(aircraft, altp, mass, mach, disa):
propulsion = aircraft.propulsion
(MTO, MCN, MCL, MCR, FID) = propulsion.rating_code
g = earth.gravity()
pamb, tamb, tstd, dtodz = earth.atmosphere(altp, disa)
vsnd = earth.sound_speed(tamb)
Cz = flight.lift_from_speed(aircraft, pamb, mach, mass)
[Cx, LoD] = airplane_aero.drag(aircraft, pamb, tamb, mach, Cz)
nei = 0.
sfc = propu.sfc(aircraft, pamb, tamb, mach, MCR, nei)
sar = (vsnd * mach * LoD) / (mass * g * sfc)
return sar
sfc_factor = 1. / eff_h # factor on cruise SFC due to rear fuselage electric nacelle with bli
#------------------------------------------------------------------------------------------------------
shaft_power = aircraft.electric_engine.mcr_e_shaft_power
disa = 0.
altp = aircraft.design_driver.ref_cruise_altp
mach = aircraft.design_driver.cruise_mach
(pamb, tamb, tstd, dt_o_dz) = earth.atmosphere(altp, disa)
(e_fan_thrust, q_air,
dv_bli) = jet.fan_thrust_with_bli(aircraft.electric_nacelle, pamb, tamb,
mach, shaft_power)
vair = mach * earth.sound_speed(tamb)
kVbli = dv_bli / vair
# Print some results
#------------------------------------------------------------------------------------------------------
print("-------------------------------------------")
print("Global mass of electric chain = ", "%.0f" % global_e_mass, " kg")
print("Electric fan length = ", "%.2f" % aircraft.electric_nacelle.length,
" m")
print("Electric fan diameter = ",
"%.2f" % aircraft.electric_nacelle.fan_width, " m")
print("Electric nozzle diameter = ",
"%.2f" % aircraft.electric_nacelle.nozzle_width, " m")
print("relative decrease of e-fan inlet velocity in cruise = ",
"%.3f" % kVbli, " no_dim")
def mission(aircraft, dist_range, tow, altp, mach, disa):
"""
Mission computation using breguet equation, fixed L/D and fixed sfc
"""
engine = aircraft.turbofan_engine
propulsion = aircraft.propulsion
battery = aircraft.battery
(MTO, MCN, MCL, MCR, FID) = propulsion.rating_code
g = earth.gravity()
pamb, tamb, tstd, dtodz = earth.atmosphere(altp, disa)
vsnd = earth.sound_speed(tamb)
tas = vsnd * mach
lod_max, cz_lod_max = airplane_aero.lod_max(aircraft, pamb, tamb, mach)
lod_cruise = 0.95 * lod_max
nei = 0.
sfc = propu.sfc(aircraft, pamb, tamb, mach, MCR, nei)
if (propulsion.architecture == 2):
fn, sec, data = propu.hybrid_thrust(aircraft, pamb, tamb, mach, MCR,
nei)
if (propulsion.architecture == 3):
fn, sec, data = propu.hybrid_thrust(aircraft, pamb, tamb, mach, MCR,
nei)
# Departure ground phases
#-----------------------------------------------------------------------------------------------------------
fuel_taxi_out = (34 + 2.3e-4 * engine.reference_thrust) * engine.n_engine
time_taxi_out = 540
fuel_take_off = 1e-4 * (2.8 + 2.3 / engine.bpr) * tow
time_take_off = 220 * tow / (engine.reference_thrust * engine.n_engine)
# Mission leg
#-----------------------------------------------------------------------------------------------------------
if (propulsion.architecture == 1):
fuel_mission = tow * (1 - numpy.exp(-(sfc * g * dist_range) /
(tas * lod_cruise)))
elif (propulsion.architecture == 2):
fuel_mission = tow*(1-numpy.exp(-(sfc*g*dist_range)/(tas*lod_cruise))) \
- (sfc/sec)*battery.energy_cruise
elif (propulsion.architecture == 3):
fuel_mission = tow*(1-numpy.exp(-(sfc*g*dist_range)/(tas*lod_cruise))) \
- (sfc/sec)*battery.energy_cruise
elif (propulsion.architecture == 4):
fuel_mission = tow * (1 - numpy.exp(-(sfc * g * dist_range) /
(tas * lod_cruise)))
else:
raise Exception("propulsion.architecture index is out of range")
time_mission = 1.09 * (dist_range / tas)
l_w = tow - fuel_mission
# Arrival ground phases
#-----------------------------------------------------------------------------------------------------------
fuel_landing = 1e-4 * (0.5 + 2.3 / engine.bpr) * l_w
time_landing = 180
fuel_taxi_in = (26 + 1.8e-4 * engine.reference_thrust) * engine.n_engine
time_taxi_in = 420
# Block fuel and time
#-----------------------------------------------------------------------------------------------------------
block_fuel = fuel_taxi_out + fuel_take_off + fuel_mission + fuel_landing + fuel_taxi_in
time_block = time_taxi_out + time_take_off + time_mission + time_landing + time_taxi_in
# Diversion and holding reserve fuel
#-----------------------------------------------------------------------------------------------------------
fuel_diversion = l_w * (1 -
numpy.exp(-(sfc * g * regul.diversion_range()) /
(tas * lod_cruise)))
fuel_holding = sfc * (l_w * g / lod_max) * regul.holding_time()
# Total
#-----------------------------------------------------------------------------------------------------------
design_range = aircraft.design_driver.design_range
fuel_total = fuel_mission * (1 + regul.reserve_fuel_ratio(design_range)
) + fuel_diversion + fuel_holding
#-----------------------------------------------------------------------------------------------------------
return block_fuel, time_block, fuel_total
def hybrid_thrust(aircraft, Pamb, Tamb, Mach, rating, nei):
propulsion = aircraft.propulsion
engine = aircraft.turbofan_engine
nacelle = aircraft.turbofan_nacelle
battery = aircraft.battery
power_elec = aircraft.power_elec_chain
e_engine = aircraft.electric_engine
e_nacelle = aircraft.electric_nacelle
power_ratio = numpy.array([
e_engine.mto_e_power_ratio, e_engine.mcn_e_power_ratio,
e_engine.mcl_e_power_ratio, e_engine.mcr_e_power_ratio,
e_engine.fid_e_power_ratio
])
# Battery power feed is used in temporary phases only
battery_power_feed = numpy.array([1, 0, 1, 0, 0]) * battery.power_feed
fn, data = turbofan_thrust(aircraft, Pamb, Tamb, Mach, rating, nei)
(fn_core, fn_fan0, fn0, shaft_power0) = data
Vsnd = earth.sound_speed(Tamb)
Vair = Vsnd * Mach
shaft_power1 = (1 - power_ratio[rating]
) * shaft_power0 # Shaft power dedicated to the fan
fn_fan1 = nacelle.efficiency_prop * shaft_power1 / Vair # Effective fan thrust
shaft_power2 = power_ratio[rating] * shaft_power0 * (
engine.n_engine - nei) # Shaft power dedicated to electric generator
# Effective eFan shaft power
pw_shaft2 = shaft_power2*power_elec.overall_efficiency \
+ e_nacelle.motor_efficiency*e_nacelle.controller_efficiency*battery_power_feed[rating]
if (pw_shaft2 > 0.):
if (propulsion.bli_effect > 0):
(fn_fan2, q1,
dVbli) = jet.fan_thrust_with_bli(e_nacelle, Pamb, Tamb, Mach,
pw_shaft2)
dVbli_o_V = dVbli / Vair
else:
(fn_fan2, q0) = jet.fan_thrust(e_nacelle, Pamb, Tamb, Mach,
pw_shaft2)
dVbli_o_V = 0.
sec = (pw_shaft2 / e_nacelle.motor_efficiency) / fn_fan2
else:
dVbli_o_V = 0.
fn_fan2 = 0.
sec = 0
fn = (fn_core + fn_fan1) * (engine.n_engine - nei) + fn_fan2
data = (fn_core, fn_fan1, fn_fan2, dVbli_o_V, shaft_power2, fn0,
shaft_power0)
return (fn, sec, data)
def eval_bli_nacelle_design(this_nacelle,Pamb,Tamb,Mach,shaft_power,hub_width,body_length,body_width):
"""
BLI nacelle design
"""
gam = earth.heat_ratio()
r = earth.gaz_constant()
Cp = earth.heat_constant(gam,r)
(rho,sig) = earth.air_density(Pamb,Tamb)
Vsnd = earth.sound_speed(Tamb)
Re = earth.reynolds_number(Pamb,Tamb,Mach)
Vair = Vsnd*Mach
# Precalculation of the relation between d0 and d1
#-----------------------------------------------------------------------------------------------------------
body_bnd_layer = resize_boundary_layer(body_width,hub_width)
# Electrical nacelle geometry : e-nacelle diameter is size by cruise conditions
#-----------------------------------------------------------------------------------------------------------
r0 = 0.5*body_width # Radius of the fuselage, supposed constant
d0 = jet.boundary_layer(Re,body_length) # theoritical thickness of the boundary layer without taking account of fuselage tapering
r1 = 0.5*hub_width # Radius of the hub of the efan nacelle
d1 = lin_interp_1d(d0,body_bnd_layer[:,0],body_bnd_layer[:,1]) # Thickness of the BL around the hub
deltaV = 2.*Vair*(this_nacelle.efficiency_fan/this_nacelle.efficiency_prop - 1.) # speed variation produced by the fan
PwInput = this_nacelle.efficiency_fan*shaft_power # kinetic energy produced by the fan
#===========================================================================================================
def fct_power_1(y,PwInput,deltaV,rho,Vair,r1,d1):
(q0,q1,q2,v1,dVbli) = jet.air_flows(rho,Vair,r1,d1,y)
Vinlet = Vair - dVbli
Vjet = Vinlet + deltaV
Pw = 0.5*q1*(Vjet**2 - Vinlet**2)
y = PwInput - Pw
return y
#-----------------------------------------------------------------------------------------------------------
fct_arg = (PwInput,deltaV,rho,Vair,r1,d1)
# Computation of y1 : thickness of the vein swallowed by the inlet
output_dict = fsolve(fct_power_1, x0=d1, args=fct_arg, full_output=True)
y1 = output_dict[0][0]
(q0,q1,q2,v1,dVbli) = jet.air_flows(rho,Vair,r1,d1,y1)
MachInlet = v1/Vsnd # Mean Mach number at inlet position
Ptot = earth.total_pressure(Pamb,MachInlet) # Stagnation pressure at inlet position
Ttot = earth.total_temperature(Tamb,MachInlet) # Stagnation temperature at inlet position
MachFan = 0.5 # required Mach number at fan position
CQoA1 = jet.corrected_air_flow(Ptot,Ttot,MachFan) # Corrected air flow per area at fan position
eFanArea = q1/CQoA1 # Fan area around the hub
fan_width = numpy.sqrt(hub_width**2 + 4*eFanArea/numpy.pi) # Fan diameter
Vjet = v1 + deltaV # Jet velocity
TtotJet = Ttot + shaft_power/(q1*Cp) # Stagnation pressure increases due to introduced work
Tstat = TtotJet - 0.5*Vjet**2/Cp # static temperature
VsndJet = numpy.sqrt(gam*r*Tstat) # Sound velocity at nozzle exhaust
MachJet = Vjet/VsndJet # Mach number at nozzle output
PtotJet = earth.total_pressure(Pamb,MachJet) # total pressure at nozzle exhaust (P = Pamb)
CQoA2 = jet.corrected_air_flow(PtotJet,TtotJet,MachJet) # Corrected air flow per area at nozzle output
nozzle_area = q1/CQoA2 # Fan area around the hub
nozzle_width = numpy.sqrt(4*nozzle_area/numpy.pi) # Nozzle diameter
this_nacelle.hub_width = hub_width
this_nacelle.fan_width = fan_width
this_nacelle.nozzle_width = nozzle_width
this_nacelle.nozzle_area = nozzle_area
this_nacelle.width = 1.20*fan_width # Surrounding structure
this_nacelle.length = 1.50*this_nacelle.width
this_nacelle.net_wetted_area = numpy.pi*this_nacelle.width*this_nacelle.length # Nacelle wetted area
this_nacelle.bnd_layer = body_bnd_layer
this_nacelle.body_length = body_length
return
def eval_hybrid_engine_design(aircraft):
"""
Thermal propulsive architecture design
"""
design_driver = aircraft.design_driver
fuselage = aircraft.fuselage
propulsion = aircraft.propulsion
engine = aircraft.turbofan_engine
nacelle = aircraft.turbofan_nacelle
battery = aircraft.battery
power_elec = aircraft.power_elec_chain
e_engine = aircraft.electric_engine
e_nacelle = aircraft.electric_nacelle
low_speed = aircraft.low_speed
(MTO,MCN,MCL,MCR,FID) = propulsion.rating_code
# Propulsion architecture design, definition of e-fan power in each fligh t phase
#-----------------------------------------------------------------------------------------------------------
# Initialisation
crm = design_driver.cruise_mach
toc = design_driver.top_of_climb_altp
rca = design_driver.ref_cruise_altp
roa = low_speed.req_oei_altp
# MTO MCN MCL MCR FIR
fd_disa = numpy.array([15. , 0. , 0. , 0. , 0. ])
fd_altp = numpy.array([0. , roa , toc, rca, rca])
fd_mach = numpy.array([0.25, crm/2, crm, crm, crm])
fd_nei = numpy.array([0. , 1. , 0. , 0. , 0. ])
e_engine.flight_data = {"disa":fd_disa, "altp":fd_altp, "mach":fd_mach, "nei":fd_nei}
e_fan_power = numpy.array([power_elec.mto,
power_elec.mcn,
power_elec.mcl,
power_elec.mcr,
power_elec.fid])
# Battery power feed is used in temporary phases only (take off and climb)
battery_power_feed = numpy.array([1,0,1,0,0])*battery.power_feed \
*e_nacelle.controller_efficiency \
*e_nacelle.motor_efficiency
e_power_ratio = numpy.zeros(5)
e_shaft_power = numpy.zeros(5)
for rating in propulsion.rating_code:
(Pamb,Tamb,Tstd,dTodZ) = earth.atmosphere(fd_altp[rating],fd_disa[rating])
(fn,data) = turbofan_thrust(aircraft,Pamb,Tamb,fd_mach[rating],rating,fd_nei[rating])
(fn_core,fn_fan0,fn0,shaft_power0) = data
if e_fan_power[rating]>1: # required eFan shaft power is given, turbofan shaft power ratio is deduced
# Fraction of the turbofan shaft power dedicated to electric generation
e_power_ratio[rating] = ( (e_fan_power[rating] - battery_power_feed[rating] \
)/ power_elec.overall_efficiency \
)/((shaft_power0)*(engine.n_engine-fd_nei[rating]))
# e-fan shaft power
e_shaft_power[rating] = e_fan_power[rating]
else: # required turbofan shaft power ration is given, absolute shaft power is deduced
# Shaft power dedicated to electric generator
shaft_power2 = e_power_ratio[rating]*shaft_power0*(engine.n_engine-fd_nei[rating])
# Fraction of the shaft power dedicated to the electric generation
e_power_ratio[rating] = e_fan_power[rating]
e_shaft_power[rating] = shaft_power2*power_elec.overall_efficiency \
+ battery_power_feed[rating]
# Storing results
e_engine.mto_e_power_ratio = e_power_ratio[MTO]
e_engine.mcn_e_power_ratio = e_power_ratio[MCN]
e_engine.mcl_e_power_ratio = e_power_ratio[MCL]
e_engine.mcr_e_power_ratio = e_power_ratio[MCR]
e_engine.fid_e_power_ratio = e_power_ratio[FID]
e_engine.mto_e_shaft_power = e_shaft_power[MTO]
e_engine.mcn_e_shaft_power = e_shaft_power[MCN]
e_engine.mcl_e_shaft_power = e_shaft_power[MCL]
e_engine.mcr_e_shaft_power = e_shaft_power[MCR]
e_engine.fid_e_shaft_power = e_shaft_power[FID]
# Engine performance update
#-----------------------------------------------------------------------------------------------------------
(Pamb,Tamb,Tstd,dTodZ) = earth.atmosphere(fd_altp[MTO],fd_disa[MTO])
(fn,data) = turbofan_thrust(aircraft,Pamb,Tamb,fd_mach[MTO],MTO,fd_nei[MTO])
(fn_core,fn_fan0,fn0,shaft_power0) = data
shaft_power1 = (1-e_power_ratio[MTO])*shaft_power0 # Shaft power dedicated to the fan at take off
Vsnd = earth.sound_speed(Tamb)
Vair = Vsnd*fd_mach[MTO]
fn_fan1 = nacelle.efficiency_prop*shaft_power1/Vair # Effective fan thrust
engine.kfn_off_take = (fn_core + fn_fan1)/fn0 # Thrust reduction due to power off take for the e-fan
return
def eval_hybrid_nacelle_design(aircraft):
"""
Hybrid propulsive architecture design
"""
design_driver = aircraft.design_driver
fuselage = aircraft.fuselage
wing = aircraft.wing
propulsion = aircraft.propulsion
engine = aircraft.turbofan_engine
nacelle = aircraft.turbofan_nacelle
e_engine = aircraft.electric_engine
e_nacelle = aircraft.electric_nacelle
(MTO,MCN,MCL,MCR,FID) = propulsion.rating_code
# Turbofan nacelles geometry adjustment
#-----------------------------------------------------------------------------------------------------------
nacWidth0 = 0.49*engine.bpr**0.67 + 4.8e-6*engine.reference_thrust # Reference dimensions of the nacelle without power off take
nacLength0 = 0.86*nacWidth0 + engine.bpr**0.37
kSize = numpy.sqrt(engine.kfn_off_take) # Diameter decrease due to max thrust decrease
kSize_eff = (kSize + engine.core_width_ratio * (1-kSize)) # Diameter decrease considering core is unchanged
nacelle.width = nacWidth0*kSize_eff # Real nacelle diameter assuming core section remains unchanged
nacelle.length = nacLength0*kSize_eff # Nacelle length is reduced according to the same factor
knac = numpy.pi*nacelle.width*nacelle.length
nacelle.net_wetted_area = knac*(1.48 - 0.0076*knac)*engine.n_engine
tan_phi0 = 0.25*(wing.c_kink-wing.c_tip)/(wing.y_tip-wing.y_kink) + numpy.tan(wing.sweep)
if (nacelle.attachment == 1) : # Nacelles are attached under the wing
nacelle.y_ext = 0.7 * fuselage.width + 1.4 * nacelle.width # statistical regression
nacelle.x_ext = wing.x_root + (nacelle.y_ext-wing.y_root)*tan_phi0 - 0.7*nacelle.length
nacelle.z_ext = - 0.5 * fuselage.height \
+ (nacelle.y_ext - 0.5 * fuselage.width) * numpy.tan(wing.dihedral) \
- 0.5*nacelle.width
elif (nacelle.attachment == 2) : # Nacelles are attached on rear fuselage
nacelle.y_ext = 0.5 * fuselage.width + 0.6 * nacelle.width # statistical regression
nacelle.x_ext = wing.x_root + (nacelle.y_ext-wing.y_root)*tan_phi0 - 0.7*nacelle.length
nacelle.z_ext = 0.5 * fuselage.height
# Electric nacelle is design by cruise conditions
#-----------------------------------------------------------------------------------------------------------
dISA = 0.
Altp = design_driver.ref_cruise_altp
Mach = design_driver.cruise_mach
(Pamb,Tamb,Tstd,dTodZ) = earth.atmosphere(Altp,dISA)
shaft_power = e_engine.mcr_e_shaft_power
hub_width = 0.5 # Diameter of the e fan hub
body_length = fuselage.length
body_width = fuselage.width
eval_bli_nacelle_design(e_nacelle,Pamb,Tamb,Mach,shaft_power,hub_width,body_length,body_width)
e_nacelle.x_axe = fuselage.length + 0.2*e_nacelle.width
e_nacelle.y_axe = 0
e_nacelle.z_axe = 0.91*fuselage.height - 0.55*fuselage.height
# Engine performance update
#-----------------------------------------------------------------------------------------------------------
fd = e_engine.flight_data
e_fan_thrust = numpy.zeros(5)
for rating in propulsion.rating_code:
altp = fd.get("altp")[rating]
disa = fd.get("disa")[rating]
mach = fd.get("mach")[rating]
nei = fd.get("nei")[rating]
(Pamb,Tamb,Tstd,dTodZ) = earth.atmosphere(altp,disa)
(fn,sec,data) = hybrid_thrust(aircraft,Pamb,Tamb,mach,rating,nei)
(fn_core,fn_fan1,fn_fan2,dVbli_o_V,shaft_power2,fn0,shaft_power0) = data
e_fan_thrust[rating] = fn_fan2
e_engine.mto_e_fan_thrust = e_fan_thrust[MTO]
e_engine.mcn_e_fan_thrust = e_fan_thrust[MCN]
e_engine.mcl_e_fan_thrust = e_fan_thrust[MCL]
e_engine.mcr_e_fan_thrust = e_fan_thrust[MCR]
e_engine.fid_e_fan_thrust = e_fan_thrust[FID]
Vair = Mach*earth.sound_speed(Tamb)
(eFanFnBli,q1,dVbli) = jet.fan_thrust_with_bli(e_nacelle,Pamb,Tamb,Mach,shaft_power)
(eFanFn,q0) = jet.fan_thrust(e_nacelle,Pamb,Tamb,Mach,shaft_power)
propulsion.bli_e_thrust_factor = eFanFnBli / eFanFn # Thrust increase due to BLI at iso shaft power for the e-fan
propulsion.bli_thrust_factor = 1. # Thrust increase due to BLI at iso shaft power for the turbofans (provision)
return
def fan_thrust(nacelle, Pamb, Tamb, Mach, PwShaft):
"""
Compute the thrust of a fan of given geometry swallowing free air stream
"""
gam = earth.heat_ratio()
r = earth.gaz_constant()
Cp = earth.heat_constant(gam, r)
#===========================================================================================================
def fct_power(q, PwShaft, Pamb, Ttot, Vair, NozzleArea):
Vinlet = Vair
PwInput = nacelle.efficiency_fan * PwShaft
Vjet = numpy.sqrt(2. * PwInput / q +
Vinlet**2) # Supposing isentropic compression
TtotJet = Ttot + PwShaft / (
q * Cp) # Stagnation temperature increases due to introduced work
TstatJet = TtotJet - 0.5 * Vjet**2 / Cp # Static temperature
VsndJet = earth.sound_speed(TstatJet) # Sound speed at nozzle exhaust
MachJet = Vjet / VsndJet # Mach number at nozzle output
PtotJet = earth.total_pressure(
Pamb, MachJet) # total pressure at nozzle exhaust (P = Pamb)
CQoA1 = corrected_air_flow(
PtotJet, TtotJet,
MachJet) # Corrected air flow per area at fan position
q0 = CQoA1 * NozzleArea
y = q0 - q
return y
#-----------------------------------------------------------------------------------------------------------
NozzleArea = nacelle.nozzle_area
FanWidth = nacelle.fan_width
Ptot = earth.total_pressure(Pamb, Mach) # Total pressure at inlet position
Ttot = earth.total_temperature(Tamb,
Mach) # Total temperature at inlet position
Vsnd = earth.sound_speed(Tamb)
Vair = Vsnd * Mach
fct_arg = (PwShaft, Pamb, Ttot, Vair, NozzleArea)
CQoA0 = corrected_air_flow(
Ptot, Ttot, Mach) # Corrected air flow per area at fan position
q0init = CQoA0 * (0.25 * numpy.pi * FanWidth**2)
# Computation of the air flow swallowed by the inlet
output_dict = fsolve(fct_power, x0=q0init, args=fct_arg, full_output=True)
q0 = output_dict[0][0]
if (output_dict[2] != 1):
raise Exception("Convergence problem")
Vinlet = Vair
PwInput = nacelle.efficiency_fan * PwShaft
Vjet = numpy.sqrt(2. * PwInput / q0 + Vinlet**2)
eFn = q0 * (Vjet - Vinlet)
return (eFn, q0)
def fan_thrust_with_bli(nacelle, Pamb, Tamb, Mach, PwShaft):
"""
Compute the thrust of a fan of a given geometry swallowing
the boundary layer (BL) of a body of a given geometry
The amount of swallowed BL depends on the given shaft power and flying
conditions.
"""
gam = earth.heat_ratio()
r = earth.gaz_constant()
Cp = earth.heat_constant(gam, r)
#===========================================================================================================
def fct_power_bli(y, PwShaft, Pamb, rho, Ttot, Vair, r1, d1, nozzle_area):
(q0, q1, q2, Vinlet, dVbli) = air_flows(rho, Vair, r1, d1, y)
PwInput = nacelle.efficiency_fan * PwShaft
Vjet = numpy.sqrt(2. * PwInput / q1 + Vinlet**2)
TtotJet = Ttot + PwShaft / (
q1 * Cp) # Stagnation temperature increases due to introduced work
Tstat = TtotJet - 0.5 * Vjet**2 / Cp # Static temperature
VsndJet = earth.sound_speed(Tstat) # Sound speed at nozzle exhaust
MachJet = Vjet / VsndJet # Mach number at nozzle output
PtotJet = earth.total_pressure(
Pamb, MachJet
) # total pressure at nozzle exhaust (P = Pamb) supposing adapted nozzle
CQoA1 = corrected_air_flow(
PtotJet, TtotJet,
MachJet) # Corrected air flow per area at nozzle position
q = CQoA1 * nozzle_area
y = q1 - q
return y
#-----------------------------------------------------------------------------------------------------------
nozzle_area = nacelle.nozzle_area
bnd_layer = nacelle.bnd_layer
Re = earth.reynolds_number(Pamb, Tamb, Mach)
d0 = boundary_layer(
Re, nacelle.body_length
) # theorical thickness of the boundary layer without taking account of fuselage tapering
r1 = 0.5 * nacelle.hub_width # Radius of the hub of the eFan nacelle
d1 = lin_interp_1d(d0, bnd_layer[:, 0],
bnd_layer[:, 1]) # Using the precomputed relation
Ttot = earth.total_temperature(
Tamb, Mach) # Stagnation temperature at inlet position
rho, sig = earth.air_density(Pamb, Tamb)
Vsnd = earth.sound_speed(Tamb)
Vair = Vsnd * Mach
fct_arg = (PwShaft, Pamb, rho, Ttot, Vair, r1, d1, nozzle_area)
# Computation of y1 : thikness of the vein swallowed by the inlet
output_dict = fsolve(fct_power_bli,
x0=0.50,
args=fct_arg,
full_output=True)
y = output_dict[0][0]
if (output_dict[2] != 1):
raise Exception("Convergence problem")
(q0, q1, q2, Vinlet, dVbli) = air_flows(rho, Vair, r1, d1, y)
PwInput = nacelle.efficiency_fan * PwShaft
Vjet = numpy.sqrt(2. * PwInput / q1 + Vinlet**2)
eFn = q1 * (Vjet - Vinlet)
return (eFn, q1, dVbli)