def CftoMFunc(N_m):
#INPUT
#OUPUT
#DESCRIPTION
tpft = par.get('tpft')
Fftoh = par.get('Fftoh')
COpspH = None
if COpspH == None:
return 0
return N_m * (COpspH) * tpft * Fftoh
def OptimumCruiseCond(M_dd, W_S, rho, Cd0, A, e):
#inputs: float Mdd: [-] mach drag divergence number
# float W_S: [N/m2] wing loading weight over surface area
# float rho : densitity at cruise altitude [kg/m3]
# float Cd0: zero lift drag coefficients [-]
# float A: aspect ratio [-]
# float e: oswald efficiency factor [-]
#output: float V_opt: optimum cruise speed [m/s]
# float CL_opt: optimum cruise CL [-]
#Description: this program calculates the optimum cruise velocity and mach number, if the
# mach number is higher than M_dd, then this is the optimum cruise mach number
#import parameters from dic
a = par.get('a_cruise')
#find CL_opt & Cd_opt
CL_opt = np.sqrt(Cd0 / 3 * np.pi * A *
e) #formulas are from Flight and Orbital
Cd_opt = 4 / 3 * Cd0
#calculate the optimum speed
V_opt = np.sqrt(W_S * 2 / rho / CL_opt)
M_opt = V_opt / a
#calculate the limiting speed
V_dd = M_dd * a
#check if optimum speed is limited by drag divergence
if V_opt > V_dd:
V_opt = V_dd
print("Mach drag divergence number was the limiting factor")
CL_opt = W_S * 2 / rho / (V_opt**2)
return (V_opt, CL_opt)
def CfinMFunc(CaedM, CapcM, CftoM):
#INPUT
#OUPUT
#DESCRIPTION
FfinM = par.get('FfinM')
return np.sum([CaedM, CapcM, CftoM]) / (1 - FfinM)
def nrcosts(CompMass):
cost = 0
factor = np.array([17731, 52156, 32093, 2499, 8691, 34307,
10763]) #Cost factors in $/lbs
cost = CompMass * par.get(
"lbs2kg") * factor #Multiplies costs factors by weight in lbs
return cost
def CaedMFunc(MTOW, Vmax, Nprogram):
#INPUT
#OUPUT
#DESCRIPTION
Nrdte = par.get('Nrdte') # Number of test ac, is between 2-8
Fdiff = par.get('Fdiff') # Difficulty level of design 1 to 2
rer = par.get('rer') # Engineering manhour rate
rem = rer # Engineering manhour rate
Fcad = par.get('Fcad') # CAD model factor
kg2lbs = 1 / par.get('lbs2kg')
CEFLabor = par.get('CEF8919') # Cost expansion factor
MTOW = kg2lbs * MTOW
Vmax = eas(Vmax)
def MHRaedProg():
return 0.0396 * Wampr(
MTOW)**0.791 * Vmax**1.526 * Nprogram**0.183 * Fdiff * Fcad
def MHRaedr(): #Engineering manhours
return 0.0396 * Wampr(
MTOW)**0.791 * Vmax**1.526 * Nrdte**0.183 * Fdiff * Fcad
#Aerframe engineering and design costs
CMHRaedr = MHRaedr() * rer
CMHRaedProg = MHRaedProg() * rem
return np.sum([CMHRaedr, CMHRaedProg]) * CEFLabor
def eas(Vc):
Vkeas = Vc * np.sqrt(
par.get('rho_cruise') / par.get('rho_SL')) / par.get('kts2ms')
return Vkeas
def cmat(MTOW, Vmax, Nrdte, Fmat):
cost= 37.632*Fmat*Wampr(MTOW)**0.689*Vmax**0.624*Nrdte**0.792\
*par.get('CEF7019')
return cost
def MHRToolProg(MTOW, Wampr, Vmax, Nprogram, Nrm):
cost = 4.0127*Wampr(MTOW)**0.764*Vmax**.899*Nprogram**0.178*Nrm**0.066* \
par.get('Fdiff')
return cost
def MHRManProg(MTOW, Vmax, Nprogram):
MHRman_prog = 28.984 * np.power(Wampr(MTOW), 0.740) *\
np.power(Vmax,0.543) * np.power(Nprogram, 0.524) * par.get("Fdiff")
return MHRman_prog
def crdte(MTOW, Vc, Cer):
#INPUT:Maximum take-off weight, cruise velocity, engine costs
#OUTPUT:RDTE Costs
#Description: Research, Development, Test and Evaluation costs
# CEF=par.get('CEF19') #Inflation between 2018-1985
rer = par.get('rer') * par.get('CEF8919') #Engineering dollar rate
rmr = par.get('rmr') * par.get('CEF8919') #Manufacturing dollar rate
rtr = par.get('rtr') * par.get('CEF8919') #Tooling dollar rate
Nrdte = par.get('Nrdte') #Number of test ac, is between 2-8
Fdiff = par.get('Fdiff') #Difficulty level of design 1-1.5-2
Fcad = par.get('Fcad') #Cad model factor
# CEF=par.get('CEF19')/par.get('CEF89') #Cost expansion factor
Nst = par.get('Nst') #Static test ac nr
Fobs = par.get('Fobs') #Factor for observable characteristics
Fpror = par.get('Fpror') #Profit factor
Ffinr = par.get('Ffinr') #Finance costs
Ftsf = par.get('Ftsf') #Test, simulation, facility costs
Fmat = par.get('Fmat') #Correction factor for type of material
cavionics = par.get('Cavionics') #costs of ac?
cer = Cer #Costs per engine at 2019
ne = par.get('ne') #number of engines
Nrr = par.get('Nrr') #RDTE production rate
Vmax = eas(Vc) #keas
kg2lbs = 1 / par.get('lbs2kg')
# ms2kts = 1/par.get('kts2ms')
MTOW = kg2lbs * MTOW # change from kg to lbs
cear = (cer * ne + cavionics) * (Nrdte - Nst
) #Costs of engine and avionics
cmanr = MHRmanr(MTOW, Vmax, Nrdte, Fdiff) * rmr #Labour costs
cmatr = cmat(MTOW, Vmax, Nrdte, Fmat) #Material costs
ctoolr = MHRtoolr(MTOW, Vmax, Nrdte, Nrr, Fdiff) * rtr #Tooling costs
cqcr = 0.13 * cmanr #Quality control costs
#Engineering manhours
mhraedr = 0.0396 * Wampr(
MTOW)**0.791 * Vmax**1.526 * Nrdte**0.183 * Fdiff * Fcad
#Aerframe engineering and design costs
caedr = mhraedr * rer
#Development, support and testing costs
cdstr=0.008325*Wampr(MTOW)**0.873*Vmax**1.89*Nrdte**0.346*Fdiff\
*par.get('CEF7019')
#Flight test airplane costs
cftar = cear + cmanr + cmatr + ctoolr + cqcr
# print (np.array([cear,cmanr,cmatr,ctoolr,cqcr,cftar])*10**(-6))
#Flight test operation costs
cftor=0.001244*Wampr(MTOW)**1.160*Vmax**1.371*(Nrdte-Nst)**1.281*Fdiff\
*Fobs*par.get('CEF7019')
#Research, development, test and evaluation costs
crdte = (caedr + cdstr + cftar + cftor) / (1 - Ftsf - Fpror - Ffinr)
return np.array([caedr, cdstr, cftar, cftor, crdte])
def Sens_analysis(Wto, Wpl, Wcrew, Mres, Mff, Mtfo, R):
#inputs: float Wto = takeoff weight can be in [N] or [kg], it doesn't matter
# float Wpl = Payload weight can be in [N] or [kg], it doesn't matter
# float Wcrew = weight of the crew, can be in [N] or [kg], it doesn't matter
#BUT BE CONSISTENT
# float Mres = reserve fuel fraction [-]
# float Mff = fuel fraction [-]
# float Mtfo = trapped fuel fraction [-]
#
# float R = total range [m]
#outputs:
# float sens_pl = sensitivy of take off weight, with respect to payload weight.
# eg. if sens_pl = 5.71, than for each extra kg in payload weight, the take off weight increases by 5.71 kg
#
#Description: this program uses formulas from Roskamp chapter 2, to analyse the sensitivity
#All formulas are retrieved from Roskamp pages 68-83
#convert weights into pounds and kilometers into nautical miles
Wto = Wto * 2.20462262 #[lbs]
Wpl = Wpl * 2.20462262 #[lbs]
Wcrew = Wcrew * 2.20462262 #[lbs]
R = R * 0.539956803 #[nm]
#parameters from dictionairy
V = par.get('V_cruise') #[m/s]
c_j = par.get('c_j') #[s^-1]
L_D = par.get('L_D') #[-]
A = par.get('A') #[-]
B = par.get('B') #[-]
#convert dictionairy into imperial units
V = V * 1.94384449 #[kts]
c_j = c_j * 3600 #[hr^-1]
#get parameters roskam coefficients
C = 1 - (1 + Mres) * (
1 - Mff) - Mtfo #[-] #From roskam 2.7
D = Wpl + Wcrew #[lbs]
F = -B * Wto**2 * ((C * Wto * (1 - B) - D)**-1) * (1 + Mres) * Mff #[lbs]
# =============================================================================
# #test parameters
# C = 0.791
# D = 31775
# F = 369211
# L_D = 16
# c_j = 0.5
# V = 473
# =============================================================================
#get sensitivities
sens_pl = B * Wto * (
(D - C * (1 - B) * Wto)**-1) #sens wrt payload weight [-]
We = 10**((np.log10(Wto) - A) / B) #empty weight [lbs]
sens_we = B * 10**(B * np.log10(We) + A) / We #sens wrt empty weight [-]
sens_R = F * c_j * (V * L_D)**-1 #sens wrt range [lbs/nm]
sens_cj = F * R * (V *
L_D)**-1 #sens wrt specific fuel consumption [lbshr]
sens_L_D = -F * R * c_j * (
V * L_D**2)**-1 #sens wrt lift over drag ratio [lbs]
#go back to metric units
sens_R = sens_R / 2.20462262 / 0.539956803 #[kg/km]
sens_cj = sens_cj / 2.20462262 #[kghr]
sens_L_D = sens_L_D / 2.20462262 #[kg]
return (sens_pl, sens_we, sens_R, sens_cj, sens_L_D)
from All_dic_Parameters import Parameters as par
#Description: Calculate the distance for the take-off phase from V=0 to V=Vlof (excluding airborne phase); any hard-coded parameters are subject to change and is only a first estimate
#Input: Wing Surface Area, Weight, CD0, Aspect Ratio, Oswald efficiency factor, Thrust-to-Weight, Lift-to-Drag
#Ouput: flight profile graphs
dt = 1 #[s] time increment
CD0 = 0.012 #at take-off (ground run) <subject to change>
A = 13 #aspect ratio <subject to change>
ef = 0.85 #Oswald's efficiency factor <subject to change>
k = 1/(pi*A*ef)
#atmospheric properties during take-off
g = par.get('g_0') #[m/s2] #gravitational acceleration at sea-level
rho = 1.225 #[kg/m3] #density at sea level
S = 90 #par.get('S') #[m2] #wing surface area <subject to change>
W_in = 60000 #par.get('MTOW')
W = 60000 #par.get('MTOW') #par.get('TOW') #[kg] #subject to change based on OEW Class I estimation method + payload weight
V = 0 #[m/s] #velocity at start of take-off
#mf_to = 0.2 #[kg/s] #mass fuel flow during take-off #need to be determine
SFC = 16*10e-6 #[kg/N/s] #specific fuel consumption <subject to change>
#SFC = 0.667
T = 200000 #[N] #maximum thrust at take-off <subject to change>
mf_to = SFC*T
CD_to = 0.2 #par.get('CD_to') #[-] #drag coefficient during 1st phase of take-off <subject to change>
def CapcMFunc(MTOW, Vmax, Nprogram, CostEngine, N_Engine, N_m):
#INPUT: TO-weight [kg], Vcruise [m/s]; #a/c produced in total; Engine cost
# Engine per a/c; #a/c produced to production standard
#OUTPUT: Returns the total aircraft production cost
#Description: Computes the total aircraft production cost which consists of
# the cost of avionics and engines c(e+a)r, Manufacturing labor
# cost (Cman_m), manufacturing material cost (Cmat_m), tooling
# cost (Ctool_m), and lastly quality control cost Cqc_m.
# Each term is first computed in year 1989 USD and afterwards
# converted to year 2019 USD.
# !!! NOTE: Engine and avionics are already adjusted to 2019 USD
# !!! N_m: airplanes built to produciotn standard
Nrdte = par.get('Nrdte') # Number of test ac, is between 2-8
Fdiff = par.get('Fdiff') # Difficulty level of design 1 to 2
rmr = par.get('rmr') #
Fmat = par.get('Fmat') #Correction factor type of material
Rtr = par.get('rtr') # Tooling labor rate in $/manhr
Nrr = par.get('Nrr') # RDTE production rate
Nrm = par.get('Nrm') # Airplane manu. rate to prod. std
Rtm = Rtr # Tooling labor rate for manufact.
kg2lbs = 1 / par.get('lbs2kg')
ms2kts = 1 / par.get('kts2ms')
CEFLabor = par.get('CEF8919') # Cost expansion factor
CEFTools = par.get('CEF7019')
MTOW = kg2lbs * MTOW
# change to EAS and kts
Vmax = Vmax * np.sqrt(par.get('rho_cruise') / par.get('rho_SL')) * ms2kts
# # convert engine cost (2019) to year 1989 USD
# CostEngine = CostEngine / CEFTools
def CmanMFunc():
CMHRManProg = MHRManProg(MTOW, Vmax, Nprogram) * rmr # rmm == rmr
CMHRManr = MHRmanr(MTOW, Vmax, Nrdte, Fdiff) * rmr
return np.sum([CMHRManProg, CMHRManr]) * CEFLabor
def CmatMFunc():
Cmatprogr = 37.632*Fmat*np.power(Wampr(MTOW), 0.689)*\
np.power(Vmax, 0.624)*np.power(Nprogram, 0.792)
Cmatr = cmat(MTOW, Vmax, Nrdte, Fmat)
return (Cmatprogr - Cmatr) * CEFTools
def CtoolM():
CMHRtoolr = MHRtoolr(MTOW, Vmax, Nrdte, Nrr, Fdiff)
CMHRToolProg = MHRToolProg(MTOW, Wampr, Vmax, Nprogram, Nrm)
return (CMHRtoolr * Rtm + CMHRToolProg * Rtr) * CEFLabor
def CqcM():
return 0.13 * CmanMFunc()
def Ca(TotalProdCost):
return np.average([5, 15]) / 100 * TotalProdCost
def CeaMFunc(C_avionics):
return (CostEngine * N_Engine + C_avionics) * N_m
SumCost_excl_av = CmanMFunc() + CmatMFunc() + CtoolM() + CqcM() + \
CeaMFunc(0)
C_Avionics = Ca(SumCost_excl_av) # in 2019 USD
# print(C_Avionics/Nprogram)
# Perc. for profit of production
# Profit = 0.10
return np.sum(C_Avionics + SumCost_excl_av)