class CG(object):
# Locations in here are referencd to the nose in x and the crankshaft of the
# engine in z, unless stated otherwise, For Z downward == positive, for x
# is to the tail positive
CG_wing_mac = 0.462 # CG location of wing as percentage of MAC
XLEMAC = Q_("1.1 m") # LEMAC position
CG_wing = CG_wing_mac * Wing.MAC + XLEMAC # Wing CG position relative to nose
X_wing = XLEMAC + 0.25 * Wing.MAC
ZCG_wing = Q_("0.0 m")
YCG_wing = Q_("0 m")
CG_htail_mac = 0.5618
CG_htail = H_tail.X_h + H_tail.MAC * CG_htail_mac # H-tail cg relative to nose
X_htail = H_tail.X_h + H_tail.MAC * 0.25 # 0.25c location of H_tail
ZCG_htail = Q_("-0.094 m")
YCG_vtail = Q_("0 m")
CG_vtail_mac = 0.58799
CG_vtail = V_tail.X_v + V_tail.MAC * CG_vtail_mac # V-tail cg relative to nose
ZCG_vtail = Q_("0.31m") - V_tail.b * 0.5
YCG_vtail = Q_("0 m")
CG_fus = Q_("3 m") # CG fuselage relative to nose !!!update!!!
Z_fusorig = Q_("0.487 m") # Origin of fuselage in Z (lowest point)
ZCG_fus = Q_(
"-0.0617m"
) #Inertia.ZCG_f # Complete fuselage Z-cg location
YCG_fus = Q_("0 m")
CG_lgear = Landing_gear.X_mainlg # CG LG relative to nose !!!update!!!
ZCG_lgear = Landing_gear.Z_mainlg / 2
CG_engine = Engine.xcg # CG of the engine relative to nose
CG_prop = Q_(
"-20 cm"
) # DUMMY VALUE, NOT KNOWN YET, negative because in front of datum
ZCG_prop = Q_("0 m")
ZCG_engine = Engine.zcg
CG_fuelsys = Q_("1.3 m") # CG fuel system !!!update!!!
ZCG_fuelsys = Q_("0 m")
CG_flightcon = Q_("2.435 m") # CG flight controls !!!update!!!
ZCG_flightcon = Q_("0.21 m")
CG_avionics = Q_("2.035 m") # CG Avionics !!!update!!!
ZCG_avionics = Q_("0 m")
CG_elecsys = Q_("2.535 m") # CG electronic system !!!update!!!
ZCG_elecsys = Q_("0 m")
CG_lehld = XLEMAC # CG leading edge HLD's
ZCG_lehld = Q_("0 m")
CG_flaperons = XLEMAC + Wing.MAC # CG Flaperons
ZCG_flaperons = Q_("0 m")
CG_pilot = Q_("2.235 m") # CG Pilot relative to nose
ZCG_pilot = Q_("-0.22 m")
CG_fuel = Q_("1.3 m") # CG fuel
ZCG_fuel = Q_("0 m")
CG_OEW = (Masses.W_wing * CG_wing + Masses.W_htail * CG_htail + Masses.W_vtail\
* CG_vtail + Masses.W_fus * CG_fus + Masses.W_gear * CG_lgear\
+ Masses.W_engine * CG_engine + Masses.W_prop * CG_prop\
+ Masses.W_fuelsys * CG_fuelsys\
+ Masses.W_elecsys * CG_elecsys + Masses.W_flightcontrol *\
CG_flightcon + Masses.W_avionics * CG_avionics + Masses.W_lehld *\
CG_lehld + Masses.W_flaperons * CG_flaperons)/Masses.W_OEW
CG_wpilot = (CG_OEW * Masses.W_OEW + Masses.W_pilot * CG_pilot)/\
(Masses.W_OEW+ Masses.W_pilot)
CG_mtow = (CG_wpilot*(Masses.W_OEW+ Masses.W_pilot)+CG_fuel * Masses.W_fuel)\
/(Masses.W_MTOW)
ZCG_OEW = (Masses.W_wing * ZCG_wing + Masses.W_htail * ZCG_htail + Masses.W_vtail\
* ZCG_vtail + Masses.W_fus * ZCG_fus + Masses.W_gear * ZCG_lgear\
+ Masses.W_engine * ZCG_engine + Masses.W_prop * ZCG_prop\
+ Masses.W_fuelsys * ZCG_fuelsys \
+ Masses.W_elecsys * ZCG_elecsys + Masses.W_flightcontrol *\
ZCG_flightcon + Masses.W_avionics * ZCG_avionics + Masses.W_lehld *\
ZCG_lehld + Masses.W_flaperons * ZCG_flaperons)/Masses.W_OEW
ZCG_wpilot = (ZCG_OEW * Masses.W_OEW + Masses.W_pilot * ZCG_pilot)/\
(Masses.W_OEW+ Masses.W_pilot)
ZCG_mtow = (ZCG_wpilot*(Masses.W_OEW+ Masses.W_pilot)+ZCG_fuel * Masses.W_fuel)\
/(Masses.W_MTOW)
def initialise_stick_defl_e(inp):
global d_e
d_e = inp
def initialise_stick_defl_r(inp):
global d_r
d_r = inp
# End defining global variables
# Start assigning values to variables
# Total stick length
l_s_t = Q_("81 cm") # As defined by Gijs
# Stick length from hinge point to pilot's hand
l_s = Q_("60 cm") # DUMMY
# Stick length below hinge point
l_s_b = l_s_t - l_s # DUMMY
# Pedal travel
d_p = Q_("20 cm") # DUMMY
# Stick deflection in handle (pitch)
d_e = Q_("0.1868 m")
# Stick deflection in handle (roll)
d_r = Q_("0.393 m")
def computeloads(z):
Sectioncenters = np.array([])
dLlist = np.array([])
dDlist = np.array([])
L = 0
D = 0
M = 0
L_moment = 0
D_moment = 0
Llist = np.array([])
Dlist = np.array([])
Lmomentlist = np.array([])
Dmomentlist = np.array([])
L_momentlist = np.array([])
zs = b - (sectionlength / 2)
dL = Q_("0 N")
dD = Q_("0 N")
dM = Q_("0 N*m")
while zs > z: #zs is measured is m from
Areaofsection = sectionlength * Wing.length_chord(zs)
Sectioncenters = np.append(Sectioncenters, zs)
'''Lift drag and moment for the section'''
dL = (cl * 0.5 * rho * (V**2) *
Areaofsection).magnitude #lift of the section
dD = (cd * 0.5 * rho * (V**2) *
Areaofsection).magnitude #drag of the section
dM = (cm * 0.5 * rho * (V**2) * Areaofsection *
Wing.length_chord(zs)).magnitude #moment of the section
dL *= Q_('kg * m / s**2')
dD *= Q_('kg * m / s**2')
dM *= Q_('kg * m**2 / s**2')
if zs < Geometry.Fuselage.b_f * 0:
dL = 0
dD = 0
dM = 0
dLlist = np.append(dLlist, dL)
dDlist = np.append(dDlist, dD)
'''Total lift, drag and moment for the wing'''
L = L + dL # Total lift for one wing
D = D + dD # Total drag for one wing
M = M + dM # Total moment for one wing
Llist = np.append(Llist,
L) # put the values in a list so we can plot them
Dlist = np.append(Dlist, D)
zs = zs - sectionlength # Select other section for the next loop
for i in range(0, len(Sectioncenters)):
arm = (Sectioncenters[i] - z.magnitude)
dLmoment = (arm * dLlist[i])
dDmoment = (arm * dDlist[i])
L_moment = L_moment + dLmoment
D_moment = D_moment + dDmoment
Lmomentlist = np.append(Lmomentlist, L_moment)
Dmomentlist = np.append(Dmomentlist, D_moment)
'''For the 20G manoeuver'''
MTOW = Geometry.Masses.W_MTOW
Max_20G_N = MTOW * 9.81 * 20
Tot_L = 2 * totallift
if Tot_L.magnitude > 0.:
fac_20G = Max_20G_N / Tot_L
fac_20G = fac_20G.magnitude
else:
fac_20G = 0
L_moment = L_moment * fac_20G
D_moment = D_moment * fac_20G
L = L * fac_20G
D = D * fac_20G
M = M * fac_20G
return L, D, M, L_moment, D_moment, dL, dD, dM
from Performance import Performance
import numpy as np
import scipy.interpolate as interpolate
import scipy.optimize as optimize
import matplotlib.pyplot as plt
import pandas as pd
import math as m
import time
sys.stdout = stdout_old
t0 = time.time()
np.seterr(all='raise')
# Variables
l_a = Q_("0.405 m") # Set aileron length
cr_c = Q_("0.45 ")
ce_c = Q_("0.5 ")
n_of_disc_w = 30 # number of parts wing is discretized
n_of_disc_h = 10 # number of parts HT is discretized
n_of_disc_v = 10 # number of parts VT is discretized
da = Q_("0 deg") # aileron deflection
dr = Q_("0 deg") # rudder deflection
de = Q_("0 deg") # elevator deflection
alpha_nose = Q_("0.0181 rad") # angle of attack of nose
beta_nose = Q_("0. rad") # angle of sideslip of nose
V_inf = Q_("27 m/s") # V infinity
t_current = Q_("0.0 s") # Start time of sim
dt = Q_("0.01 s") # Time step of sim
t_end = Q_("30. s") # End time of sim
p = Q_("0. 1/s") # initial roll rate [rad/s]
from Inertia import Inertia
from Performance import Performance
import numpy as np
import scipy.interpolate as interpolate
import matplotlib.pyplot as plt
import pandas as pd
import math as m
import time
sys.stdout = stdout_old
t0 = time.time()
np.seterr(all='raise')
# Variables
l_a = Q_("0.3015 m") # Set aileron length
l_e = Q_("0.2 m") # Set elevator length
cr_c = Q_("0.2 ")
n_of_disc_w = 30 # number of parts wing is discretized
n_of_disc_h = 10 # number of parts HT is discretized
n_of_disc_v = 10 # number of parts VT is discretized
da = Q_("0.0 deg") # aileron deflection
dr = Q_("0 deg") # rudder deflection
de = Q_("0 deg") # elevator deflection
alpha_nose = Q_("0. rad") # angle of attack of nose
beta_nose = Q_("0. rad") # angle of sideslip of nose
V_inf = Q_("118 m/s") # V infinity
t_current = Q_("0.0 s") # Start time of sim
dt = Q_("0.01 s") # Time step of sim
t_end = Q_("1.0 s") # End time of sim
l_h = Q_("3.6444 m") # Tail arm ac-ac horizontal
import sys
sys.path.append('../') # This makes sure the parent directory gets added to the system path
import numpy as np
from Misc import ureg, Q_ # Imports the unit registry fron the Misc folder
from Geometry import Geometry as GM
from Misc import Init_parm as IP
from Performance import Performance as PF
import Stab_dev_eigenmotions as stab
import math as m
import matplotlib.pyplot as plt
rho = Q_("1.225 kg/m**3") # Density at sea level
V_stall = PF.V_stall_clean
V_a = PF.V_a_clean
d_delta_a = GM.Wing.delta_a *2 #rad delta aileron form minus to plus
d_delta_a.ito(Q_("rad"))
d_s_a = Q_("0.41 m") #stick deflection
Sa = GM.Wing.S_a #m2 aileron surface area
ca = GM.Wing.c_a #m aileron cord
C_h_alpha = IP.C_h_alpha #hinge moment
C_l_delta_a = 0.433 #IP.C_l_delta_a
C_l_p = stab.Clp
C_h_delta = IP.C_h_delta
b = GM.Wing.b
maxdefl_aileron = GM.Wing.delta_a
maxdefl_aileron.ito(Q_("rad"))
Fa= Q_("1000 N") #Newton stick force
def Calc_base_shear_flow(boom_areas, n):
"""
:param boom_areas: Return variable from Boom_area function
:param n: Number of sections that divides the perimiter
:return: Arrays with s's and qs's, seperated for L and D
"""
strs_x_coords, strs_y_coords, _ = Wing.x_y_angle_coords
strs_x_coords.ito(ureg("m"))
strs_y_coords.ito(ureg("m"))
strs_x_coords = np.append(strs_x_coords, np.flip(strs_x_coords, 0))
strs_x_coords *= ureg('m')
strs_y_coords = np.append(strs_y_coords, np.flip(-1 * strs_y_coords, 0))
strs_y_coords *= ureg('m')
S_x = WingStress.D
S_y = WingStress.L
Ixx = Inertia.Ixx_wb
Iyy = Inertia.Iyy_wb
## section 1 2
ds = Wing.HSpar1 / (2 * n)
qs12L = np.array([])
qs12D = np.array([])
qs12L = np.append(qs12L, 0)
qs12D = np.append(qs12D, 0)
s1 = np.array([])
s1 = np.append(s1, 0)
s = Q_("0 m")
q_loc_L = 0
q_loc_D = 0
x = (Wing.ChSpar1 - Wing.centroid
) * Wing.Chordlength # x_coordinate of Spar 1 w.r.t. the centroid
for _ in range(n - 1):
s += ds
y = s
s1 = np.append(s1, s)
# Lift
q_loc_L += -(S_y / Ixx) * Wing.ThSpar1 * y * ds
qs12L = np.append(qs12L, q_loc_L.to(ureg("N/m")))
# Drag
q_loc_D += -(S_x / Iyy) * Wing.ThSpar1 * x * ds
qs12D = np.append(qs12D, q_loc_D.to(ureg("N/m")))
s += ds
y = s
s1 = np.append(s1, s)
# Lift
q_loc_L += -(S_y / Ixx) * (Wing.ThSpar1 * y * ds +
boom_areas[0] * Wing.HSpar1 / 2)
qs12L = np.append(qs12L, q_loc_L.to(ureg("N/m")))
# Drag
q_loc_D += -(S_x / Iyy) * (Wing.ThSpar1 * x * ds + boom_areas[0] * x)
qs12D = np.append(qs12D, q_loc_D.to(ureg("N/m")))
## section 2 3
ds = (Wing.skin_length) / n
s = Q_("0 m")
qs23L = np.array([])
qs23L = np.append(qs23L, qs12L[-1])
qs23D = np.array([])
qs23D = np.append(qs23D, qs12D[-1])
s2 = np.array([])
s2 = np.append(s2, s)
str_counter = 0
for _ in range(n):
s = np.add(ds, s)
s2 = np.append(s2, s)
x_coor, y_coor = Wing.get_xy_from_perim(s / Wing.Chordlength,
Wing.ChSpar1) # RELATIVE!!
# Lift
q_loc_L += -(S_y / Ixx) * (Wing.ThSkin * y_coor * Wing.Chordlength *
ds)
# Drag
q_loc_D += -(S_x / Iyy) * (Wing.ThSkin * (x_coor - Wing.centroid) *
Wing.Chordlength * ds)
if (np.sqrt(
(x_coor * Wing.Chordlength - strs_x_coords[str_counter])**2 +
(y_coor * Wing.Chordlength - strs_y_coords[str_counter])**2) <
Q_("1 cm")):
print("s2:", strs_x_coords[str_counter])
q_loc_L += -(S_y /
Ixx) * Wing.A_stringer * strs_y_coords[str_counter]
q_loc_D += -(S_x / Iyy) * Wing.A_stringer * (
strs_x_coords[str_counter] / Wing.Chordlength -
Wing.centroid) * Wing.Chordlength
str_counter += 1
qs23L = np.append(qs23L, q_loc_L.to(ureg("N/m")))
qs23D = np.append(qs23D, q_loc_D.to(ureg("N/m")))
## Section 3 5
ds = Wing.HSpar2 / n
qs35L = np.array([])
qs35D = np.array([])
qs35L = np.append(qs35L, qs23L[-1])
qs35D = np.append(qs35D, qs23D[-1])
s3 = np.array([])
s3 = np.append(s3, 0)
s = Q_("0 m")
x = (Wing.ChSpar2 - Wing.centroid
) * Wing.Chordlength # x_coordinate of Spar 1 w.r.t. the centroid
for _ in range(n):
s += ds
y = Wing.HSpar2 / 2 - s
s3 = np.append(s3, s)
# Lift
q_loc_L += -(S_y / Ixx) * Wing.ThSpar2 * y * ds
qs35L = np.append(qs35L, q_loc_L.to(ureg("N/m")))
# Drag
q_loc_D += -(S_x / Iyy) * Wing.ThSpar2 * x * ds
qs35D = np.append(qs35D, q_loc_D.to(ureg("N/m")))
## section 5 6
ds = (Wing.skin_length) / n
s = Q_("0 m")
qs56L = np.array([])
qs56L = np.append(qs56L, qs35L[-1])
qs56D = np.array([])
qs56D = np.append(qs56D, qs35D[-1])
s4 = np.array([])
s4 = np.append(s4, s)
for _ in range(n):
s = np.add(ds, s)
s4 = np.append(s4, s)
x_coor, y_coor = Wing.get_xy_from_perim(s / Wing.Chordlength,
Wing.ChSpar2,
reverse=True) # RELATIVE!!
# Lift
q_loc_L += -(S_y / Ixx) * (Wing.ThSkin * y_coor * Wing.Chordlength *
ds)
# Drag
q_loc_D += -(S_x / Iyy) * (Wing.ThSkin * (x_coor - Wing.centroid) *
Wing.Chordlength * ds)
if (str_counter < Wing.N_stringers):
if (abs(x_coor * Wing.Chordlength - strs_x_coords[str_counter]) <
Q_("1 cm")):
q_loc_L += -(
S_y / Ixx) * Wing.A_stringer * strs_y_coords[str_counter]
print(strs_x_coords[str_counter])
q_loc_D += -(S_x / Iyy) * Wing.A_stringer * (
strs_x_coords[str_counter] / Wing.Chordlength -
Wing.centroid) * Wing.Chordlength
str_counter += 1
qs56L = np.append(qs56L, q_loc_L.to(ureg("N/m")))
qs56D = np.append(qs56D, q_loc_D.to(ureg("N/m")))
## section 6 1
ds = Wing.HSpar1 / (2 * n)
qs61L = np.array([])
qs61D = np.array([])
qs61L = np.append(qs61L, qs56L[-1])
qs61D = np.append(qs61D, qs56D[-1])
s5 = np.array([])
s5 = np.append(s5, 0)
s = Q_("0 m")
x = (Wing.ChSpar1 - Wing.centroid
) * Wing.Chordlength # x_coordinate of Spar 1 w.r.t. the centroid
y = -Wing.HSpar1 / 2
# Lift
s5 = np.append(s5, 0)
q_loc_L += -(S_y / Ixx) * (Wing.ThSpar1 * y * ds + boom_areas[-1] * y)
qs61L = np.append(qs61L, q_loc_L.to(ureg("N/m")))
# Drag
q_loc_D += -(S_x / Iyy) * (Wing.ThSpar1 * x * ds + boom_areas[-1] * x)
qs61D = np.append(qs61D, q_loc_D.to(ureg("N/m")))
for _ in range(n - 1):
s += ds
y = -Wing.HSpar1 / 2 + s # x_coordinate of Spar 1 w.r.t. the centroid
s5 = np.append(s5, s)
# Lift
q_loc_L += -(S_y / Ixx) * Wing.ThSpar1 * y * ds
qs61L = np.append(qs61L, q_loc_L.to(ureg("N/m")))
# Drag
q_loc_D += -(S_x / Iyy) * Wing.ThSpar1 * x * ds
qs61D = np.append(qs61D, q_loc_D.to(ureg("N/m")))
s1 *= ureg("m")
s2 *= ureg("m")
s3 *= ureg("m")
s4 *= ureg("m")
s5 *= ureg("m")
qs12L *= ureg("N/m")
qs12D *= ureg("N/m")
qs23L *= ureg("N/m")
qs23D *= ureg("N/m")
qs35L *= ureg("N/m")
qs35D *= ureg("N/m")
qs56L *= ureg("N/m")
qs56D *= ureg("N/m")
qs61L *= ureg("N/m")
qs61D *= ureg("N/m")
return s1, s2, s3, s4, s5, qs12L, qs23L, qs35L, qs56L, qs61L, qs12D, qs23D, qs35D, qs56D, qs61D
) # This makes sure the parent directory gets added to the system path
import numpy as np
import scipy.interpolate as interpolate
import time
from Misc import ureg, Q_
from Geometry import Geometry
from Aerodynamics import Wing as Awing
from Inertia import Inertia
from Misc import Init_parm as IP
import matplotlib.pyplot as plt
import math
import pandas as pd
t0 = time.time()
np.set_printoptions(linewidth=160)
# Variables
l_a = Q_("0.2015 m") # Set aileron length
n_of_disc_w = 30 # number of parts wing is discretized
n_of_disc_h = 10 # number of parts HT is discretized
n_of_disc_v = 10 # number of parts VT is discretized
da = Q_("30 deg") # aileron deflection
alpha_nose = Q_("0 deg") # angle of attack of nose
beta_nose = Q_("0 deg") # angle of sideslip of nose
p = 0. / ureg.s # initial roll rate
# Definitions
def local_chord(z, c_r, c_t, half_b):
# Calculates the chord at location z(distance from center)
return c_r - (c_r - c_t) / half_b * z
print("L =", L) # print the result
## EXAMPLE 3: GETTING THE MAGNITUDE OF A VALUE
## For compatibility reasons with other software
## You might only want the maginutude of a value
## without the unit, this example shows you how:
L_mag = L.magnitude # Get the magnitude of L
print("\nMagnnitude of L=", L_mag) # Print the result
## EXAMPLE 4: ASSIGING A UNIT USING A STRING EXPRESSION
## You can also assign a value and unit by typing them as a string
## Use Q_(<USER STRING>) function
I_XX = Q_(
"2457 mm**4"
) # To have for instance the 4th power, use the python expression **4
I_YY = Q_("0.002 m**4")
print("\n I_XX=", I_XX)
print("I_yy=", I_YY)
## EXAMPLE 5: CONVERTING UNITS USING STRING EXPRESSION
## FOR COMPOUND UNITS A STRING EXPRESSION IS OFTEN USEFUL
## FOR THE CONVERSION:
I_ZZ = Q_("84.4 lbf*inch*s**2")
print("\n Before conversion: Izz=", I_ZZ)
I_ZZ.ito(ureg("kg*m**2"))
print("After conversion: Izz=", I_ZZ)
from scipy import optimize
from scipy import interpolate
from Geometry import Geometry
from Propulsion_and_systems import Engine_mounts
from Aerodynamics import Wing as AWing
from Performance import Performance
import matplotlib
import matplotlib.cm as cmx
from mpl_toolkits.mplot3d import Axes3D
from Misc import ureg, Q_ # Imports the unit registry from the Misc folder
b_f = Geometry.Fuselage.b_f #diameter of fuselage at the fire wall
b_f80 = b_f*0.8 #design radius
print('b_f80', b_f80)
t = Q_('0.0025 m') #thickness of fuselage skin
t_ribs = Q_('0.002 m') #thickness of the ribs
h_ribs = Q_('0.05 m') #the height of the ribs
s_ribs = Q_('0.5 m') #rib spacing
moter_w = Q_('180 kg') #Resultant weight of the motor
g = Q_('9.81 m / s**2') #The gravity acceleration
l_fus = Geometry.Fuselage.l_f #length of the fuselage in m
print('l_fus', l_fus)
l_sec1 = Q_('1.5 m') #length of section 1 (normal)
l_sec2 = Q_('1.0 m') #length of section 2 (cut out)
l_sec3 = l_fus - l_sec1 - l_sec2 #length of section 3 (taper)
print('l_sec3', l_sec3)
rho = Performance.rho_c.magnitude * ureg("kg/(m**3)") #rho at cruise altitude
V = Performance.V_cruise.magnitude * ureg("m/s") #cruise speed
S_VT = Geometry.V_tail.S #area of vertical tail
S_HT = Geometry.H_tail.S #are of horizontal tail
def fuselage_calc(x, y, z):
#Boom areas section 1 (normal)
B_sec1 = t * (b_f80 / 2) / 2 + t * (b_f80 / 2) / 2 #area for all booms
#Boom areas section 2 (cut out)
B_sec2 = t * (b_f80 / 2) / 2 + t * (b_f80 / 2) / 2
#Boom areas section 3 (cone/taper)
def B_calc(x):
if Q_('0 m') <= x <= l_sec1 + l_sec2:
b_f_taper = b_f80
B_sec3 = B_sec1
if l_sec1 + l_sec2 < x <= l_fus:
b_f_taper = b_f80 - ((b_f80 / (l_sec3 + l_sec2)) * (x - l_sec2 - l_sec1))
B_sec3 = t * (b_f_taper / 2) / 2 + t * (b_f_taper / 2) / 2
return B_sec3, b_f_taper
# y = B_calc(x)[1]
# z = B_calc(x)[1] #the dreadful z
B_sec3, b_f_taper = B_calc(x)
'''------------------Inertia calculation-----------------------'''
#Inertia section 1 (normal)
Iyy_sec1 = (b_f80/2)**2 * B_sec1 * 4
Izz_sec1 = Iyy_sec1
#Inertia section 2
Iyy_sec2 = (b_f80/2)**2 * B_sec2 * 4
Izz_sec2 = Iyy_sec2
#Inertia section 3
Iyy_sec3 = (b_f_taper/2)**2 * B_sec3 * 4
Izz_sec3 = Iyy_sec3
print(x, b_f80, b_f_taper)
'''------------Loading force/moment calculation------------'''
#Tail force calculation
cl_vt, cd_vt, cm_vt = AWing.computeloadsvt()
cl_ht, cd_ht, cm_ht = AWing.computeloadsht()
L_VT = 0.5 * cl_vt * rho * (V ** 2) * S_VT #Tangent forces of the control surfaces at full deflection
L_HT = 0.5 * cl_ht * rho * (V ** 2) * S_HT
D_VT = 0.5 * cd_vt * rho * (V ** 2) * S_VT #Normal forces of the control surfaces at full deflection
D_HT = 0.5 * cd_ht * rho * (V ** 2) * S_HT
M_VT = 0.5 * cm_vt * rho * (V ** 2) * S_VT * MAC_VT
M_HT = 0.5 * cm_vt * rho * (V ** 2) * S_HT * MAC_HT
#Bending Loading section 1
My_sec1 = Engine_mounts.m_y #calculation of the resultant moment in y as variable of z
Mx_sec1 = Engine_mounts.m_x #calculation of the resultant moment in y as variable of z
Mz_sec1 = x * Engine_mounts.f_z + Engine_mounts.m_z #calculation of the resultant moment in y as variable of z
#Bending Loading section 2
My_sec2 = (l_fus - x) * L_VT
My_sec2.ito(ureg('N * m'))
Mx_sec2 = (b_VT * 0.33) * L_VT
Mx_sec2.ito(ureg('N * m'))
Mz_sec2 = -(l_fus - x) * L_HT - (b_VT * 0.33) * D_VT
Mz_sec2.ito(ureg('N * m'))
#Bending Loading section 3
My_sec3 = My_sec2
Mx_sec3 = Mx_sec2
Mz_sec3 = Mz_sec2
#Axial Loading of section 1, 2 & 3
ax_sec1 = Engine_mounts.f_x
ax_sec2 = D_VT + D_HT
ax_sec3 = ax_sec2
'''----------Bending stress calculations----------------'''
def normal_shear_stress(x):
if Q_('0 m') <= x <= l_sec1:
'''section 1'''
#Bending section 1
sigma_x = My_sec1 / Iyy_sec1 * z + Mz_sec1 / Izz_sec1 * y + (ax_sec1 / (B_sec1 * 4)) #bending stress
#Torsion section 1
q_x_sec1 = Mx_sec1 / (2 * b_f80 * b_f80) #shear flow
shear_x = q_x_sec1
if l_sec1 < x < l_sec1 + l_sec2:
'''section 2'''
#Bending section 2
sigma_x = My_sec2 / Iyy_sec2 * z + Mz_sec2 / Izz_sec2 * y + (ax_sec2 / (B_sec2 * 4))
#Torsion section 2
q_x_sec2 = Mx_sec2 / (2 * b_f80 * b_f80)
shear_x = q_x_sec2
if l_sec1 + l_sec2 <= x <= l_fus:
'''section 3'''
#Bending section 3
sigma_x = My_sec3 / Iyy_sec3 * z + Mz_sec3 / Izz_sec3 * y + (ax_sec3 / (B_sec3 * 4))
#Torsion section 3
q_x_sec3 = Mx_sec3 / (2 * b_f_taper * b_f_taper)
shear_x = q_x_sec3
return sigma_x, shear_x
sigma_x, shear_x = normal_shear_stress(x)
'''------------Cut out correction calculation---------------'''
q_12 = normal_shear_stress(x)[1]
q_34_cor = (b_f80 * q_12) / b_f80
q_23_cor = (b_f80 * q_34_cor) / b_f80
q_14_cor = (b_f80 * q_23_cor) / b_f80
print(q_34_cor, q_23_cor, q_14_cor)
q_34 = q_12 + -q_34_cor
q_23 = q_12 + q_23_cor
q_14 = q_12 + q_14_cor
q_12 = q_12 + -q_12
P = ((q_14_cor + q_23_cor) * l_sec2) / 2
P_stress = P / B_sec3
if y > Q_('0 m') and z > Q_('0 m'):
P_stress = -P_stress
if y < Q_('0 m') and z < Q_('0 m'):
P_stress = -P_stress
if l_sec1 < x < l_sec1 + l_sec2:
sigma_x = sigma_x + P_stress
print('P_stress', P_stress)
shear_x = q_34
if z >= b_f_taper - Q_('0.01 m') or z <= -b_f_taper + Q_('0.01 m'):
shear_x = q_23
'''-------------Cut Out correction for non cut out parts (sec 1 and sec 3---------------'''
if x <= l_sec1:
a = np.array([[b_f_taper.magnitude, 0, -b_f_taper.magnitude, 0],
[0, b_f_taper.magnitude, 0, -b_f_taper.magnitude],
[0, 0, l_sec1.magnitude, l_sec1.magnitude],
[b_f_taper.magnitude, -b_f_taper.magnitude, 0, 0]])
b = np.array([0, 0, P.magnitude, 0])
M = np.linalg.solve(a, b)
q_34 = shear_x + -M[2] * Q_('N/m')
q_23 = shear_x + M[1] * Q_('N/m')
q_14 = shear_x + M[3] * Q_('N/m')
q_12 = shear_x + -M[0] * Q_('N/m')
shear_x = q_12
if z >= b_f_taper - Q_('0.01 m') or z <= -b_f_taper + Q_('0.01 m'):
shear_x = q_23
if x >= l_sec1 + l_sec2:
a = np.array([[b_f_taper.magnitude, 0, -b_f_taper.magnitude, 0],
[0, b_f_taper.magnitude, 0, -b_f_taper.magnitude],
[0, 0, l_sec3.magnitude, l_sec3.magnitude],
[b_f_taper.magnitude, -b_f_taper.magnitude, 0, 0]])
b = np.array([0, 0, P.magnitude, 0])
M = np.linalg.solve(a, b)
q_34 = shear_x + -M[2] * Q_('N/m')
q_23 = shear_x + M[1] * Q_('N/m')
q_14 = shear_x + M[3] * Q_('N/m')
q_12 = shear_x + -M[0] * Q_('N/m')
shear_x = q_12
if z >= b_f_taper - Q_('0.01 m') or z <= -b_f_taper + Q_('0.01 m'):
shear_x = q_23
'''Area calculation'''
Area = B_calc(x)[0]*4
shear_x = shear_x / t
'''Fuselage Ribs'''
Area_ribs = b_f_taper * b_f_taper * h_ribs
return sigma_x, shear_x, Area, Area_ribs
"""
#imports
import sys
sys.path.append(
'../'
) # This makes sure the parent directory gets added to the system path
from Misc import ureg, Q_
import numpy as np
import math as m
from Geometry import Geometry
#Manual inputs
#chordlength = .05 #determine part of chord used for slats
slatwidth = Geometry.Wing.b - 2 * Geometry.Wing.horn #width of the slats
h = Q_('100 m') #altitude of flight
Velocity = Q_(' 30 m/s') #aircraft velocity at which slats are deployed
GMAC = Geometry.Wing.c_avg
mass_sys = Q_('20 kg') #mass of slat system
#%% Slat sizing for optimal max lift increase
# optimization arrays:
deflection = np.linspace(15, 25, 20) #deflection in degrees
deflection_rad = np.radians(deflection)
slatchordratio = np.linspace(0, 0.15, 20) #dimensionless
verticaldeflection = np.linspace(0.05, 0.0825, 20) #in meter
#DATCOM graph interpolation
maxLeffect_datapoints = np.array([(0,0),(.05,.84),(.1,1.2),(.15,1.44),(.2,1.6),\
(.25,1.75),(.3,1.825)])
maxL_x = maxLeffect_datapoints[:, 0]
class Prop(object):
Diameter = Q_('1.9 m')
mass = Q_("30 kg") # Based on MT-propeller (4-bladed)
class Wing(object):
S = Q_('11.74 m**2') # [m^2] Wing Surface
A = 5.5 # Aspect Ratio
b = np.sqrt(S * A) # [m] Wing Span
taper = 0.45 # Taper ratio
horn = Q_('0.0 m ')
c_r = Q_("2.015 m") # Root chord
c_t = c_r * taper # Tip chord
c_avg = (c_r + c_t) / 2 #Average chord
Sweep_25 = 0 # [deg] Quarter chord sweep
Sweep_25 *= Q_('deg')
Sweep_50 = m.degrees(
m.atan(
m.tan(m.radians(Sweep_25)) - (4 / A) *
((0.5 - 0.25) * (1 - taper) /
(1 + taper)))) # [deg] Half chord sweep
Sweep_50 *= Q_('deg')
Sweep_75 = m.degrees(
m.atan(
m.tan(m.radians(Sweep_25)) - (4 / A) *
((0.75 - 0.25) * (1 - taper) /
(1 + taper)))) # [deg] 3/4 chord sweep
Sweep_75 *= Q_('deg')
Sweep_LE = m.degrees(
m.atan(
m.tan(m.radians(Sweep_25)) - (4 / A) *
((0.0 - 0.25) * (1 - taper) /
(1 + taper)))) # [deg] LE chord sweep
Sweep_LE *= Q_('deg')
Dihedral = Q_('0.0 deg') # [deg] Dihedral angle
MAC = c_r * (2 / 3) * (
(1 + taper + taper**2) / (1 + taper)) # [m] Mean aerodynamic chord
T_Cmax = 0.1513 #Max thickness over chord
S_wet = 2 * S # Wetted wing area
S_a = Q_('2.677 m**2') # Aileron area
c_a = Q_('0.405 m') # Aileron chord
delta_a = Q_("30 deg") # max aileron deflection
delta_CL_max_a = 0.8267 # Max lift coeff difference due to aileron deflection
def J_calculator(twistoftotalwing):
T = Q_("1 N*m")
G = WingStress.shear_modulus
J = T / (G * twistoftotalwing)
return J
return Final
#Returns propeller efficiency, Thrust, Pitchangle, induced velocity, and Induced AOA for max power.
# For Alphai: w cos(Alphai+phi) is in airflow direction. w sin(Alphai + phi) is naar buiten.
D = Geometry.Prop.Diameter.magnitude #Diameter of the propeller
R = D / 2 #Radius of the propeller
Rhub = 0.20 #Radius of the huboptimal at 0.31
Elements = 1000
P = 235000
rho = 1.225
Tstatic = 0.85 * P**(2 / 3) * (2 * rho * R**2 * np.pi)**(1 / 3) * (
1 - Rhub**2 / (R**2)) # Maximum static thrust.
Tstatic *= Q_("N")
# Coordinate system:
# Origin is in propeller attachment to engine
# X axis: parallel to the crankshaft centerline, pointing towards tail
# Y axis: up
# Z axis: left
# Start defining global variables for easy editing from elsewhere
# For explanations of the variables defined here, see below, where they are given values
def initialise_mass(inp):
global mass
mass = inp
from Misc import ureg, Q_ # Imports the unit registry fron the Misc folder
from matplotlib import pyplot as plt
import math as m
import numpy as np
from Geometry import Geometry
from Aerodynamics import Aeroprops
from Performance import Performance
from Inertia import Inertia
# First check CG position for tipping:
Z_mainlg = Geometry.Landing_gear.Z_mainlg
X_mainlg = Geometry.Landing_gear.X_mainlg
X_taillg = Geometry.Landing_gear.X_taillg
cgangle_fw = Q_("15 deg")
cgangle_rear = Q_("25 deg")
X_maxfront = X_mainlg + Z_mainlg * np.tan(cgangle_fw)
X_maxback = X_mainlg + Z_mainlg * np.tan(cgangle_rear)
X_cgmtow = Geometry.CG.CG_mtow
X_cgoew = Geometry.CG.CG_OEW
V_taxi = Q_("5 kts")
V_taxi.ito(Q_("m/s"))
rho0 = Q_("1.225 kg/m**3")
g0 = Performance.g0.magnitude
g0 = g0 * Q_("m/s**2")
m_mtow = Geometry.Masses.W_MTOW
W_mtow = m_mtow * g0
V_taxi = Q_("5 kts")
V_taxi.ito(Q_("m/s"))
rho0 = Q_("1.225 kg/m**3")
# This file will calculate the ranges for l_h,
# Xlemac, S_h and S_v in which StefX will have level 1 flying qualities
# Input parameters
A = Geometry.Wing.A
test = []
Z_cg = Geometry.CG.ZCG_mtow
CL_alpha = Aero_wing.CL_alpha
MTOW = Geometry.Masses.W_MTOW
S_wing = Geometry.Wing.S
taper = Geometry.Wing.taper
b = Geometry.Wing.b
V_a = (Performance.V_a_clean).magnitude
V_a *= Q_("1 m/s")
rho_a = Performance.rho_a.magnitude
rho_a *= Q_("1 kg/m**3")
g0 = Performance.g0.magnitude
g0 *= Q_("1 m/s**2 ")
Oswald_e = Aero_wing.Oswald_e
CNH_alpha = Aero_HT.C_Nh_alpha
dE_dalpha = Aero_wing.de_da
Vh_V = Aero_HT.Vh_v
Cbar = Geometry.Wing.MAC
I_yy = Inertia.I_yy
K_yy = I_yy / (MTOW * Cbar**2)
CNW_alpha = Aero_wing.C_Nw_alpha
mu_c = MTOW / (rho_a * Cbar * S_wing)
mu_b = MTOW / (rho_a * b * S_wing)
CY_v_alpha = Aero_VT.C_Yv_alpha
import math as m
from Geometry import Geometry
from Structures import Inertia_HT as Inertia
from Structures import Wing_HT as Wing
from Structures import WingStress_VT as WingStress
from Structures import Shear_HT as Shear
from matplotlib import pyplot as plt
n = 10 #number of the devided sections
b = Wing.s #Wing span
b = b.magnitude * ureg.meter
Normalstress = np.array([])
Vol_mat_spar1 = Q_('0 m**3')
Vol_mat_spar2 = Q_('0 m**3')
Vol_mat_skin = Q_('0 m**3')
Vol_mat_string = Q_('0 m**3')
Vol_mat_clamp = Q_('0 m**3')
Vol_mat_wing = Q_('0 m**3')
Old_N_stringers = Wing.N_stringers
Lmomentlist = np.array([])
Ixxlist = np.array([])
Iyylist = np.array([])
zarray = np.array([])
Farray = np.array([])
z = 0
# -*- coding: utf-8 -*-
"""
Name: Aerodynamic Props
Department: Aero
Last updated: 11/06/2018 11.21 by Emma
"""
import sys
sys.path.append(
'../'
) # This makes sure the parent directory gets added to the system path
from Misc import ureg, Q_ # Imports the unit registry fron the Misc folder
import math as m
import numpy as np
q_qinf_ratio = 0.8558 #ratio dynamic pressure ht over infinity dyn pressure
CL_alpha_wing = Q_("4.65 1/rad") #slope wing lift co
CL_alpha_ht = Q_("3.23 1 / rad") #slope ht lift co, downwash not included
de_da = 0.806 #downwash angle change over angle of attack change
CD0_wing = Q_("0.007593419890783278")
CD0_ht = Q_("0.0012936674003027845")
CD0_vt = Q_("0.0010167110920327306")
CD_canopy = Q_("0.005600000000000001 dimensionless")
CD_lg = Q_("0.01695335319 dimensionless")
CD0_tot = Q_("0.03842707439520723 dimensionless")
def initialise_ycg(inp):
global ycg
ycg = inp
def initialise_zcg(inp):
global zcg
zcg = inp
# End defining global variables
# Start assigning values to variables
# Engine dry mass as provided by Lycoming
drymass = Q_("446 lbs")
drymass.ito(ureg.kg)
# Assume additional 10% to include fluids and hoses
mass = 1.1 * drymass
# Engine mass moments of inertia about engine cg, as provided by Lycoming
ixg = Q_("84.4 inch*lbf*s**2")
iyg = Q_("93.5 inch*lbf*s**2")
izg = Q_("145.8 inch*lbf*s**2")
# Transfer to SI units
ixg.ito(ureg("kg*m**2"))
iyg.ito(ureg("kg*m**2"))
izg.ito(ureg("kg*m**2"))
# Engine dimensions
length = Q_("39.34 in")
StefX Flight performance parameters
"""
import sys
import math as m
import numpy as np
sys.path.append('../')
from Geometry import Geometry
from Misc import Q_, ureg
from Control import Calc_ISA_100km as ISA
from Aerodynamics import Wing as Aero_wing
mtow = Geometry.Masses.W_MTOW # [kg] Max. Take-off weight
cl_max_hld = Aero_wing.CL_max_hld # [-] CL max with HLD's deployed
cl_max_clean = Aero_wing.CL_max # [-] CL max in clean config
to_distance = Q_("400 m") # [m] Take-off distance
top = 130 # [-] Take-Off parameter
s_land = Q_("550 m") # [m] Landing distance
V_cruise = Q_("94.1 m/s") # [m/s] Cruise speed
h_c = Q_("3000 m") # [m] Cruise altitude !!!please check!!!
rho_c = ISA.isacal(h_c.magnitude)[2] # Cruise density
rho_c *= Q_("kg/(m**3)")
rho_0 = Q_("1.225 kg/m**3")
Temp_c = ISA.isacal(h_c.magnitude)[1] # Cruise temp
Temp_c *= ureg("K")
gamma_isa = 1.41 # Specific heat ratio
m_c = (V_cruise/np.sqrt(gamma_isa*Temp_c*rho_c)).magnitude # [-] Cruise Mach number
roc = Q_("16 m/s") # [m/s] Rate of Climb
Climb_angle = Q_("45 deg") # [deg] Climb angle
V_sust = Q_("67.135 m/s") # [m/s] Sustained turn velocity
n_sust = 4.16 # [-] Sustained turn load factor
# Origin is in propeller attachment to engine
# X axis: parallel to the crankshaft centreline, pointing towards tail
# Y axis: up
# Z axis: left
# Start defining global variables for easy editing from elsewhere
# For explanations of the variables defined here, see below, where they are given values
def initialise_rpm(inp):
global rpm
rpm = inp
# Start assigning values
rpm = Q_("2700 rpm")
rpm.ito(ureg("rad/min"))
# Make function which calculates gyro accelerations (prop only!) from moment and rate inputs
def input_moment(yaw_moment, pitch_moment, yaw_rate, pitch_rate):
# Make compatible for inputs with and without units
if yaw_moment.__class__ == int or yaw_moment.__class__ == float:
yaw_moment *= ureg("newton*meter")
if pitch_moment.__class__ == int or pitch_moment.__class__ == float:
pitch_moment *= ureg("newton*meter")
if yaw_rate.__class__ == int or yaw_rate.__class__ == float:
yaw_rate *= ureg("rad/s")
if pitch_rate.__class__ == int or pitch_rate.__class__ == float:
pitch_rate *= ureg("rad/s")
from Inertia import Inertia
from Performance import Performance
import numpy as np
import scipy.interpolate as interpolate
import scipy.optimize as optimize
import matplotlib.pyplot as plt
import pandas as pd
import math as m
import time
sys.stdout = stdout_old
t0 = time.time()
np.seterr(all='raise')
# Variables
l_a = Q_("0.405 m") # Set aileron length
cr_c = Q_("0.45 ")
ce_c = Q_("0.5 ")
n_of_disc_w = 50 # number of parts wing is discretized
n_of_disc_h = 15 # number of parts HT is discretized
n_of_disc_v = 10 # number of parts VT is discretized
da = Q_("0 deg") # aileron deflection
dr = Q_("0 deg") # rudder deflection
de = Q_("0 deg") # elevator deflection
alpha_nose = Q_("0.0181 rad") # angle of attack of nose
beta_nose = Q_("0. rad") # angle of sideslip of nose
V_inf = Q_("96 m/s") # V infinity
t_current = Q_("0.0 s") # Start time of sim
dt = Q_("0.01 s") # Time step of sim
t_end = Q_("30. s") # End time of sim
p = Q_("0. 1/s") # initial roll rate [rad/s]
## VERTICAL TAIL
A = Geometry.V_tail.A #Estimate aspect ratio
t = Geometry.V_tail.taper #Estimate taper
s = Geometry.V_tail.b / 2 - Geometry.Wing.horn #Estimate span (m)
Lambda5 = 0 #Quarter chord sweep
CtoT = 0.15 #Max Chord to thickness ratio
Spar2R = (1 - Geometry.V_tail.cr_c
) #Chordwise location of second spar at the root
Spar2T = (1 - Geometry.V_tail.cr_c
) #Chordwise location of second spar at the tip
Spar1R = 0.18 #Chordwise location of first spar at the root
Spar1T = 0.18 #Chordwise location of first spar at the tip
ChordR = Geometry.V_tail.c_r #Length of root (m)
ThSpar1 = Q_('0.0015 m') #Thickness of Spar 1
ThSpar2 = Q_('0.0015 m') #Thickness of Spar 2
ThSkin = Q_('0.0010 m') #Thickness of the skin
N_stringers = 6 #Number of stringers
ClampH = Q_('0.015 m') #height of the clamps at the top of the spars
ClampW = Q_('0.015 m') #width of the clamps at the top of the spars
##Stringers # C stringer dimentions
h_str = Q_('0.015 m') # height of the stringer
w_str = Q_('0.015 m') #width of the stringer
t_str = Q_('0.0015 m') #thickness of the stringer
z = 0 #spanwise posotion in meters
z *= Q_('meter')
c = 0
"""
import sys
import unittest
sys.path.append(
'../'
) # This makes sure the parent directory gets added to the system path
from Misc import ureg, Q_ # Imports the unit registry fron the Misc folder
import numpy as np
from scipy import integrate
from Structures import Wing
from scipy.interpolate import interp1d
from matplotlib import pyplot as plt
# print(Wing.h_str)
Iyy_aircraft = Q_("1492.8 kg/m/m")
Ixx_aircraft = Q_("1016.9 kg/m/m")
Izz_aircraft = Q_("2447.2 kg/m/m")
#Ixy Wing box
Ixy_wb = Q_('0 m**4')
def calc_stringer_inertia(h_str, w_str, t_str):
b_1 = w_str / 2 - 0.5 * t_str
h_1 = t_str
b_2 = t_str
h_2 = h_str
from scipy import interpolate
import math as m
from Geometry import Geometry
# from Geometry import Wing as GWing
import Wing
from Structures import Inertia_VT as Inertia
from Structures import Wing_VT as Wing
from Aerodynamics import Wing as AWing
from Performance import Performance
import matplotlib.pyplot as plt
import time
#Material properties of the chosen material.
#Current chosen material:
#Epoxy/Carbon fiber, UD prepreg, QI lay-up
youngs_modulus = Q_("60.1 GPa") #E
yield_strength = Q_("738 MPa") #tensile
compr_strength = Q_("657 MPa") #compression
shear_modulus = Q_("23 GPa") #G
poisson = 0.31 # maximum 0.33
tau_max = Q_("60 MPa")
density = Q_("1560 kg/m**3")
cl, cd, cm = AWing.computeloadsvt() #Load aerodynamic properties
n = 10 #number of the devided sections
b = Wing.s #Wing span
b = b.magnitude * ureg.meter
z = Wing.z
ChordR = Geometry.Wing.c_r.magnitude * ureg.meter #root chord in m
rho = Performance.rho_c.magnitude * ureg("kg/(m**3)") #cruise density
tau12 = tau_y
#print("tauy", tau_y)
tau23 = 0
tau13 = tau_x
F = F11 * sigma1**2 #+F22*(sigma2**2+sigma3**2)+sigma2*sigma3*(2*F22-F44)
F = F + F1 * sigma1 #+ 2*F12*sigma1*(sigma3+sigma2) + F2*sigma3
F = F + F66 * (tau13**2 + tau12**2) #F44*tau23**2
if F < 1:
print("No failure occurs")
else:
print("Failure occurs")
return F
F = Tsia_Wu(WingStress.NS, tauxat2, tauyat2)
print("F =", F)
#plt.plot(s3, qs3)
#plt.show()
######### For Sam
Unitrateoftwist = Rate_of_twist(Q_("1 N*m"))
def J_calculator(twistoftotalwing):
T = Q_("1 N*m")
G = WingStress.shear_modulus
J = T / (G * twistoftotalwing)
return J
) # This makes sure the parent directory gets added to the system path
import numpy as np
from Misc import ureg, Q_
from Geometry import Geometry as GM
from Aerodynamics import Aeroprops as Aeroprops
from Aerodynamics import Wing as AWing
from Performance import Performance as PF
from Propulsion_and_systems import Propeller as Prop
from Propulsion_and_systems import Propdata as Propdata
from Misc import Init_parm as IP
import matplotlib.pyplot as plt
import math as m
# Get parameters
P_to = PF.P_to.magnitude
P_to = P_to * Q_("kg*m**2/s**3")
C_d_0 = Aeroprops.CD0_tot
mass = GM.Masses.W_MTOW
W = mass * Q_("9.81 m/s**2")
S = GM.Wing.S
rho = Q_("1.225 kg/(m**3)")
C_L_alpha = AWing.CL_alpha
C_L_alpha *= Q_("1/rad")
C_l_max = AWing.CL_max
A = GM.Wing.A
e = AWing.Oswald_e
eta_prop = PF.eta_prop
dp = PF.dp
V_stall = PF.V_stall_clean.magnitude
V_stall *= Q_("m/s")
alpha_max = AWing.alpha_stall
class Masses(object): # !!!Structures should watch this!!!
W_wing = Q_("88 kg") #StrucVal.Weightwing * 2 # Weight of the wing
W_htail = Q_("3.79 kg") * 2 * 5 # [kg] Mass of H_tail
W_vtail = Q_("2.82 kg") * 4 # [kg] Mass of V_tail
W_fus = Q_("40 kg") # [kg] Mass of Fuselage
W_gear = Q_("35 kg") # [kg] Mass of landing gear
W_engine = Engine.mass # [kg] Mass of engine
W_prop = Prop.mass # [kg] Mass of propellor
W_fuelsys = Q_("10 kg") # [kg] Mass of fuel system
W_flightcontrol = Q_("20 kg") # [kg] Mass of flight control
W_avionics = Q_("17 kg") # [kg] Mass of Avionics
W_elecsys = Q_("15 kg") # [kg] Mass of electronic systems
W_lehld = Q_("16 kg") # [kg] Mass of LE HLD's
W_flaperons = Q_("14 kg") # [kg] Mass of flaperons
W_OEW = W_wing + W_htail + W_vtail + W_fus + W_gear + W_engine +\
W_prop + W_fuelsys + W_flightcontrol +\
W_avionics + W_elecsys + W_lehld + W_flaperons
W_pilot = Q_("100 kg") # [kg] Mass of pilot
W_fuel = Q_("57 kg") # [kg] Mass of fuel
W_MTOW = W_OEW + W_pilot + W_fuel