def Get_boom_area(A_spar_caps):
"""
This function calculates the boom area's needed for the structural idealization
It assumes the wingbox is loaded in bending.
:param A_spar_caps: Spar cap area's [Expected With Unit]
:return: Boom area array with dimension.
"""
x_coords = Wing.x_y_angle_coords[0]
y_coords = Wing.x_y_angle_coords[1]
n_str = len(x_coords)
t_sk = Wing.ThSkin
h_sp_1 = Wing.HSpar1
h_sp_2 = Wing.HSpar2
B_area = np.array([])
B_1 = A_spar_caps #+ (Wing.ThSpar1*h_sp_1/6)*(2 + (-1)) + (t_sk*Wing.perim_spacing/6)*(2 + y_coords[1]/y_coords[0])
B_area = np.append(B_area, B_1.to(ureg("m**2")))
B_2 = Wing.A_stringer #+ (t_sk*Wing.perim_spacing/6)*(2 + h_sp_1/2/ y_coords[0]) + (t_sk*Wing.perim_spacing/6)*(2 + y_coords[1]/ y_coords[0])
B_area = np.append(B_area, B_2.to(ureg("m**2")))
for i in range(1, n_str - 1):
B_i = Wing.A_stringer #+ (t_sk*Wing.perim_spacing/6)*(2 + y_coords[i-1]/ y_coords[i]) + (t_sk*Wing.perim_spacing/6)*(2 + y_coords[i+1]/ y_coords[i])
B_area = np.append(B_area, B_i.to(ureg("m**2")))
B_n_min_1 = Wing.A_stringer #+ (t_sk*Wing.perim_spacing/6)*(2 + h_sp_2/2 / y_coords[-1]) + (t_sk*Wing.perim_spacing/6)*(2 + y_coords[-2]/ y_coords[-1])
B_area = np.append(B_area, B_n_min_1.to(ureg("m**2")))
#B_n = (t_sk*Wing.perim_spacing/6)*(2 + y_coords[-2]/ y_coords[-1]) + (Wing.ThSpar2*h_sp_2/6)*(2 + (-1))
#B_area = np.append(B_area, B_n.to(ureg("m**2")))
B_area = np.append(B_area, np.flip(B_area, 0))
return B_area * ureg("m**2")
def Correcting_shearflow_array(n, qs0L, qs0D):
qs0_L = np.array([])
qs0_D = np.array([])
for _ in range(n + 1):
qs0_L = np.append(qs0_L, qs0L)
qs0_D = np.append(qs0_D, qs0D)
return qs0_L * ureg("N/m"), qs0_D * ureg("N/m")
def GetShearX(c, bottom_side=False, inter1=tau23Xinterp, inter2=tau56Xinterp):
if c > Wing.ChSpar2 - (1e-2):
print("⚠ c is out of range!! ⚠")
c = Wing.ChSpar2 - (1e-2)
x_coor = c * Wing.Chordlength
if bottom_side == False:
return_val = inter1(x_coor)
return_val *= ureg("Pa")
return return_val
else:
return_val = inter2(x_coor)
return_val *= ureg("Pa")
return return_val
def data_reader(velocity, needed_value):
if velocity.__class__ != int and velocity.__class__ != float:
velocity.ito(ureg("m/s"))
velocity = velocity.magnitude
if velocity < 15:
print(
"ERROR: please supply a value for velocity between 15 and 160 m/s")
return
index = int(velocity) - 15
if needed_value == "Propeller efficiency":
col = 0
unit = "none"
elif needed_value == "Total thrust":
col = 1
unit = "newton"
elif needed_value == "Pitch angle":
col = 2
unit = "degree"
elif needed_value == "Power needed":
col = 3
unit = "W"
elif needed_value == "Torque":
col = 4
unit = "newton * meter"
else:
print("ERROR: please supply a valid column header as needed_value")
return
return Q_("{} {}".format(data[index, col], unit))
def calc_total_stringer_inertia(x_y_angle_coords, stringer_inertias):
x_coords = x_y_angle_coords[0]
x_coords = np.append(x_coords, x_coords)
x_coords *= ureg.meter
# print(x_coords)
y_coords = x_y_angle_coords[1]
y_coords = np.append(y_coords, -y_coords)
y_coords *= ureg.meter
angles = x_y_angle_coords[2]
angles = np.append(angles, angles)
angles *= ureg("rad")
I_xx_stringer = stringer_inertias[0][0]
I_yy_stringer = stringer_inertias[0][1]
I_xy_stringer = stringer_inertias[0][2]
stringer_area = stringer_inertias[2]
I_XX_TOT = Q_("0 m**4")
I_YY_TOT = Q_("0 m**4")
I_XY_TOT = Q_("0 m**4")
Y_CEN = Q_("0 m")
for i in range(len(x_coords)):
loc_I_xx, loc_I_yy, loc_I_xy = axis_transformation(
I_xx_stringer, I_yy_stringer, I_xy_stringer, angles[i])
I_XX_TOT += loc_I_xx + stringer_area * (y_coords[i])**2
I_YY_TOT += loc_I_yy + stringer_area * (
x_coords[i] - Wing.centroid * Wing.Chordlength)**2
I_XY_TOT += loc_I_xy + stringer_area * (
x_coords[i] - Wing.centroid * Wing.Chordlength) * (y_coords[i] -
Y_CEN)
return I_XX_TOT, I_YY_TOT, I_XY_TOT
def deformation_y(zs):
deformation_temp = Llist[-1] / 24 * (
zs)**4 #-Geometry.Fuselage.D_fus_max/2
deformation_temp += -((Llist[-1] - Llist[0]) / (GWing.b / 2)) / 120 * (
zs -
Geometry.Fuselage.D_fus_max / 2)**5 #-Geometry.Fuselage.D_fus_max/2
deformation_y = -deformation_temp / (youngs_modulus * Inertia.Iyy_wb)
#deformation_y += L_moment/2*Geometry.Fuselage.D_fus_max**2/(youngs_modulus*Inertia.Iyy_wb)
return deformation_y.to(ureg("meter"))
def transform_to_xy(s2, s4, tau23X, tau56X, tau23Y, tau56Y):
start_x_perim = Wing.get_perim_from_x(Wing.ChSpar1)
xs2 = np.array([])
ys2 = np.array([])
for s in s2:
#print("s=", s)
x_coor, y_coor = Wing.lookup_xy_from_perim(
Wing.perim_interpolant_x,
Wing.perim_interpolant_y,
Wing.perim_interpolant_inv_x,
Wing.perim_interpolant_inv_y,
s / Wing.Chordlength,
start_x_perim=start_x_perim)
x_coor *= Wing.Chordlength.to(ureg("m"))
y_coor *= Wing.Chordlength.to(ureg("m"))
xs2 = np.append(xs2, x_coor)
ys2 = np.append(ys2, y_coor)
start_x_perim = Wing.get_perim_from_x(Wing.ChSpar2, inverse=True)
xs2 *= ureg("m")
ys2 *= ureg("m")
xs4 = np.array([])
ys4 = np.array([])
for s in s4:
#print("s=",s)
x_coor, y_coor = Wing.lookup_xy_from_perim(
Wing.perim_interpolant_x,
Wing.perim_interpolant_y,
Wing.perim_interpolant_inv_x,
Wing.perim_interpolant_inv_y,
s / Wing.Chordlength,
start_x_perim=start_x_perim,
inverse=True)
x_coor *= Wing.Chordlength.to(ureg("m"))
y_coor *= Wing.Chordlength.to(ureg("m"))
xs4 = np.append(xs4, x_coor)
ys4 = np.append(ys4, y_coor)
xs4 *= ureg("m")
ys4 *= ureg("m")
tau23Xinterp = interpolate.interp1d(xs2, tau23X)
tau23Yinterp = interpolate.interp1d(xs2, tau23Y)
tau56Xinterp = interpolate.interp1d(xs4, tau56X)
tau56Yinterp = interpolate.interp1d(xs4, tau56Y)
return tau23Xinterp, tau23Yinterp, tau56Xinterp, tau56Yinterp
def Tsai_Wu(sigma_x, shear_x):
F11=1/(yield_strength*compr_strength)
F22 = F11
F12 = -1/2*np.sqrt(F11*F22)
F1 = 1/(yield_strength)-1/(compr_strength)
F2 = 1/(yield_strength)-1/(compr_strength)
F44 = 1/tau_max**2
F66 = 1/tau_max**2
sigma1 = sigma_x
sigma2 = Q_("0 MPa")
sigma3 = Q_("0 MPa")
tau12 = shear_x
tau23 = Q_("0 MPa")
tau13 = Q_("0 MPa")
F = F11 *sigma1**2+F22*(sigma2**2+sigma3**2)+sigma2*sigma3*(2*F22-F44)
F += 2*F12*sigma1*(sigma3+sigma2)+F1*(sigma1+sigma2) + F2*sigma3
F += F44*tau23**2 + F66*(tau13**2+tau12**2)
F.ito(ureg('dimensionless'))
if F.magnitude < 1:
print("No failure occurs")
if F.magnitude >= 1:
print("Failure occurs")
return F
def input_acceleration(yaw_acceleration, pitch_acceleration, yaw_rate,
pitch_rate):
# Make compatible for inputs with and without units
if yaw_acceleration.__class__ == int or yaw_acceleration.__class__ == float:
yaw_acceleration *= ureg("rad/s**2")
if pitch_acceleration.__class__ == int or pitch_acceleration.__class__ == float:
pitch_acceleration *= ureg("rad/s**2")
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")
m_y = Propeller.izg * yaw_acceleration + (Propeller.ixg -
Propeller.izg) * pitch_rate * rpm
m_z = Propeller.izg * pitch_acceleration + (Propeller.izg -
Propeller.ixg) * yaw_rate * rpm
m_y.ito(ureg("newton * meter"))
m_z.ito(ureg("newton * meter"))
print("Yaw moment: {}".format(m_y))
print("Pitch moment: {}".format(m_z))
return [m_y, m_z]
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")
omega_y_dot = (
yaw_moment -
(Propeller.ixg - Propeller.izg) * pitch_rate * rpm) / Propeller.izg
omega_z_dot = (
pitch_moment -
(Propeller.izg - Propeller.ixg) * yaw_rate * rpm) / Propeller.izg
omega_y_dot.ito(ureg("rad/s**2"))
omega_z_dot.ito(ureg("rad/s**2"))
print("Yaw acceleration: {}".format(omega_y_dot))
print("Pitch acceleration: {}".format(omega_z_dot))
return [omega_y_dot, omega_z_dot]
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
def Get_xy_components(s1, s2, s3, s4, s5, qs12, qs23, qs35, qs56, qs61):
t_ys12 = np.array([])
x_coor_AC = 0.25 * Wing.Chordlength
# Moments from section 1 -> 2
for i in range(0, len(qs12) - 1):
t_y = qs12[i] / Wing.ThSpar1
t_ys12 = np.append(t_ys12, t_y.to(ureg("N/(m**2)")))
t_y = qs12L[-1] / Wing.ThSpar1
t_ys12 = np.append(t_ys12, t_y.to(ureg("N/(m**2)")))
# Moments from section 2 -> 3
t_xs23 = np.array([])
t_ys23 = np.array([])
for i in range(0, len(qs23) - 1):
x_loc_1, y_loc_1 = Wing.get_xy_from_perim(s2[i] / Wing.Chordlength,
Wing.ChSpar1)
x_loc_2, y_loc_2 = Wing.get_xy_from_perim(s2[i + 1] / Wing.Chordlength,
Wing.ChSpar1)
x_loc_1 *= Wing.Chordlength
x_loc_2 *= Wing.Chordlength
y_loc_1 *= Wing.Chordlength
y_loc_2 *= Wing.Chordlength
Force_angle = np.arctan2(y_loc_2 - y_loc_1, x_loc_2 - x_loc_1)
t_x = qs23[i] / Wing.ThSkin * np.cos(Force_angle)
t_y = qs23[i] / Wing.ThSkin * np.sin(Force_angle)
t_xs23 = np.append(t_xs23, t_x.to(ureg("N/(m**2)")))
t_ys23 = np.append(t_ys23, t_y.to(ureg("N/(m**2)")))
t_x = qs23[-1] / Wing.ThSkin * np.cos(Force_angle)
t_y = qs23[-1] / Wing.ThSkin * np.sin(Force_angle)
t_xs23 = np.append(t_xs23, t_x.to(ureg("N/(m**2)")))
t_ys23 = np.append(t_ys23, t_y.to(ureg("N/(m**2)")))
# Moments from section 3->5
t_ys35 = np.array([])
for i in range(0, len(qs35) - 1):
t_y = qs35[i] / Wing.ThSpar2
t_ys35 = np.append(t_ys35, t_y.to(ureg("N/(m**2)")))
t_y = qs35[-1] / Wing.ThSpar2
t_ys35 = np.append(t_ys35, t_y.to(ureg("N/(m**2)")))
# Moments from section 5 -> 6
t_xs56 = np.array([])
t_ys56 = np.array([])
for i in range(0, len(qs56) - 1):
x_loc_1, y_loc_1 = Wing.get_xy_from_perim(s4[i] / Wing.Chordlength,
Wing.ChSpar2,
reverse=True)
x_loc_2, y_loc_2 = Wing.get_xy_from_perim(s4[i + 1] / Wing.Chordlength,
Wing.ChSpar2,
reverse=True)
x_loc_1 *= Wing.Chordlength
x_loc_1 -= x_coor_AC
x_loc_2 *= Wing.Chordlength
x_loc_2 -= x_coor_AC
y_loc_1 *= Wing.Chordlength
y_loc_2 *= Wing.Chordlength
Force_angle = np.arctan2(y_loc_2 - y_loc_1, x_loc_2 - x_loc_1)
t_x = qs56[i] / Wing.ThSkin * np.cos(Force_angle)
t_y = qs56[i] / Wing.ThSkin * np.sin(Force_angle)
t_xs56 = np.append(t_xs56, t_x.to(ureg("N/(m**2)")))
t_ys56 = np.append(t_ys56, t_y.to(ureg("N/(m**2)")))
t_x = qs56[-1] / Wing.ThSkin * np.cos(Force_angle)
t_y = qs56[-1] / Wing.ThSkin * np.sin(Force_angle)
t_xs56 = np.append(t_xs56, t_x.to(ureg("N/(m**2)")))
t_ys56 = np.append(t_ys56, t_y.to(ureg("N/(m**2)")))
# Moment 6 -> 1
t_ys61 = np.array([])
for i in range(0, len(qs61) - 1):
t_y = qs61[i] / Wing.ThSpar1
t_ys61 = np.append(t_ys61, t_y.to(ureg("N/(m**2)")))
t_y = qs61[-1] / Wing.ThSpar1
t_ys61 = np.append(t_ys61, t_y.to(ureg("N/(m**2)")))
t_xs23 *= ureg("N/(m**2)")
t_xs56 *= ureg("N/(m**2)")
t_ys12 *= ureg("N/(m**2)")
t_ys23 *= ureg("N/(m**2)")
t_ys35 *= ureg("N/(m**2)")
t_ys56 *= ureg("N/(m**2)")
t_ys61 *= ureg("N/(m**2)")
return t_xs23, t_xs56, t_ys12, t_ys23, t_ys35, t_ys56, t_ys61
def Moment_shearflow(n):
qmoment = WingStress.M / (2 * Wing.Area_cell())
q_moment = np.array([])
for _ in range(n + 1):
q_moment = np.append(q_moment, qmoment)
return q_moment * ureg("N/m")
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
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)
# # Get power needed from prop file
# P = Propeller.Powercalc(V_cruise.magnitude, D.magnitude)[3]
# P = P*Q_("W")
# P.ito(ureg.hp)
# print("Power needed: {}".format(P))
# Use "economic cruise" engine power
P = Q_("192 hp")
V_cruise = Q_("86.5 m/s")
T1 = Q_("0 newton")
# T2 = []
T2 = Q_("1000 newton")
vlst = []
P.ito(ureg("watt"))
# print(P)
# for i in range(0, 25, 1):
# V_cruise = 71+i
# T = Propeller.Thrustcalc(V_cruise)[1]
# T2.append(T)
# vlst.append(V_cruise)
# print(V_cruise, T)
#
# plt.plot(vlst, T2)
# plt.show()
while abs(T1 - T2) > Q_("10 newton"):
if T1 < T2:
V_cruise += Q_("0.1 m/s") # abs(T1.magnitude-T2.magnitude)*Q_("m/s")
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
n_max = 10
h_a = Q_("600 m") # [m] Manouevring height
rho_a = ISA.isacal(h_a.magnitude)[2] # [kg/m^3] Manouevring density
rho_a *= Q_(" 1 kg/m**3")
S_wing = Geometry.Wing.S # Wing span for next calc.
g0 = Q_("9.80665 m/s**2")
V_stall_hld = np.sqrt((2*g0*mtow)/(cl_max_hld*rho_a*S_wing)) # Man. Veloc. at with HLD
V_a_hld = V_stall_hld * m.sqrt(n_max)
V_stall_clean = np.sqrt((2*g0*mtow)/(cl_max_clean*rho_a*S_wing)) # Man. Veloc. clean
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.computeloads() #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
V = Performance.V_cruise.magnitude * ureg("m/s") #cruise speed
dL_moment = Q_('0 kg * m ** 2 / s**2')
dD_moment = Q_('0 kg * m**2/s**2')
L_moment = Q_('0 kg * m ** 2 / s**2')
D_moment = Q_('0 kg * m ** 2 / s**2')
L = Q_('0 kg * m / s**2')
D = Q_('0 kg * m / s**2')
M = Q_('0 kg * m ** 2 / s**2')
Lmomentlist = np.array([])
Dmomentlist = np.array([])
dLlist = np.array([])
dDlist = np.array([])
# 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")
width = Q_("34.25 in")
height = Q_("26.46 in")
# Transfer to SI units
length.ito(ureg.m)
width.ito(ureg.m)
height.ito(ureg.m)
# Engine cg location
# Assumed cg is on crankshaft & in the middle of the engine length
xcg = length / 2
# 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")
# End assigning values
# Hinge moments calculation
# Calculate Angular stick deflections in deg
stick_angle_e = np.rad2deg(np.arcsin(Stick_pedals.d_e / Stick_pedals.l_s))
stick_angle_r = np.rad2deg(np.arcsin(Stick_pedals.d_r / Stick_pedals.l_s))
# Calculate hinge moment factor between stick hinge and control surface hinge
hinge_fac_e = stick_angle_e / Geometry.H_tail.delta_e
hinge_fac_r = stick_angle_r / Geometry.Wing.delta_a
# Calculate maximum aileron hinge moment
m_r_max = f_r_max * Stick_pedals.l_s * hinge_fac_r
m_r_max.ito(ureg("newton * meter"))
print("Maximum aileron hinge moment: {}".format(m_r_max))
# Calculate maximum elevator hinge moment
m_p_max = f_p_max * Stick_pedals.l_s * hinge_fac_e
m_p_max.ito(ureg("newton * meter"))
print("Maximum elevator hinge moment: {}".format(m_p_max))
# Arm between rudder and cable/pushrod attachment
r_rudder = Stick_pedals.d_p / np.tan(Geometry.V_tail.delta_r)
# Calculate maximum hinge moment in yaw
m_y_max = f_y_max * r_rudder
m_y_max.ito(ureg("newton * meter"))
print("Maximum yaw hinge moment: {}".format(m_y_max))
# Calculate forces in pushrods
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
b_VT = Geometry.V_tail.b #span vertical tail
MAC_VT = Geometry.V_tail.MAC
MAC_HT = Geometry.H_tail.MAC
#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
