def eval_geometry(self):
fuselage_length = self.aircraft.airframe.fuselage.length
fuselage_height = self.aircraft.airframe.fuselage.height
tail_cone_length = self.aircraft.airframe.fuselage.tail_cone_length
wing_sweep25 = self.aircraft.airframe.wing.sweep25
self.height = np.sqrt(self.aspect_ratio*self.area)
self.c_root = 2*self.area/(self.height*(1+self.taper_ratio))
self.c_tip = self.taper_ratio*self.c_root
self.sweep25 = max(unit.rad_deg(25.), wing_sweep25 + unit.rad_deg(10.)) # Empirical law
self.x_anchor = 0.85 # Locate self versus end fuselage length
x_root = fuselage_length*(1-tail_cone_length/fuselage_length*(1-self.x_anchor)) - self.c_root
x_tip = x_root + 0.25*(self.c_root-self.c_tip) + self.height*np.tan(self.sweep25)
y_root = 0.
y_tip = 0.
z_root = fuselage_height
z_tip = z_root + self.height
self.mac = self.height*(self.c_root**2+self.c_tip**2+self.c_root*self.c_tip)/(3*self.area)
x_mac = x_root+(x_tip-x_root)*self.height*(2*self.c_tip+self.c_root)/(6*self.area)
y_mac = 0.
z_mac = z_tip**2*(2*self.c_tip+self.c_root)/(6*self.area)
self.lever_arm = (x_mac + 0.25*self.mac) - (x_mac + 0.25*self.mac)
self.loc_root = np.array([x_root, y_root, z_root])
self.loc_tip = np.array([x_tip, y_tip, z_tip])
self.loc_mac = np.array([x_mac, y_mac, z_mac])
self.frame_origin = [x_root, 0., z_root]
self.frame_angles = [0., 0., 0.]
self.gross_wet_area = 2.01*self.area
self.net_wet_area = self.gross_wet_area
self.aero_length = self.mac
self.form_factor = 1.40
def eval_geometry(self):
htp_loc_tip = self.aircraft.airframe.horizontal_stab.loc_tip
wing_sweep25 = self.aircraft.airframe.wing.sweep25
self.height = np.sqrt(self.aspect_ratio*(0.5*self.area))
self.c_root = 2*(0.5*self.area)/(self.height*(1+self.taper_ratio))
self.c_tip = self.taper_ratio*self.c_root
self.sweep25 = max(unit.rad_deg(25.), wing_sweep25 + unit.rad_deg(10.)) # Empirical law
x_root = htp_loc_tip[0]
x_tip = x_root + 0.25*(self.c_root-self.c_tip) + self.height*np.tan(self.sweep25)
y_root = htp_loc_tip[1]
y_tip = htp_loc_tip[1]
z_root = htp_loc_tip[2]
z_tip = z_root + self.height
self.mac = self.height*(self.c_root**2+self.c_tip**2+self.c_root*self.c_tip)/(3*(0.5*self.area))
x_mac = x_root+(x_tip-x_root)*self.height*(2*self.c_tip+self.c_root)/(6*(0.5*self.area))
y_mac = y_tip
z_mac = z_tip**2*(2*self.c_tip+self.c_root)/(6*self.area)
self.lever_arm = (x_mac + 0.25*self.mac) - (x_mac + 0.25*self.mac)
self.loc_root = np.array([x_root, y_root, z_root])
self.loc_tip = np.array([x_tip, y_tip, z_tip])
self.loc_mac = np.array([x_mac, y_mac, z_mac])
self.frame_origin = [x_root, y_root, z_root]
self.frame_angles = [0., 0., 0.]
self.gross_wet_area = 2.01*self.area
self.net_wet_area = self.gross_wet_area
self.aero_length = self.mac
self.form_factor = 1.40
def eval_geometry(self):
fuselage_length = self.aircraft.airframe.fuselage.length
fuselage_height = self.aircraft.airframe.fuselage.height
fuselage_cone_length = self.aircraft.airframe.fuselage.tail_cone_length
wing_sweep25 = self.aircraft.airframe.wing.sweep25
wing_loc_mac = self.aircraft.airframe.wing.loc_mac
wing_mac = self.aircraft.airframe.wing.mac
self.span = np.sqrt(self.aspect_ratio*self.area)
y_axe = 0.
y_tip = 0.5*self.span
htp_z_wise_anchor = 0.80 # Locate HTP versus end fuselage height
z_axe = htp_z_wise_anchor*fuselage_height
z_tip = z_axe + y_tip*np.tan(self.dihedral)
self.c_axe = 2.*self.area/(self.span*(1+self.taper_ratio))
self.c_tip = self.taper_ratio*self.c_axe
self.sweep25 = wing_sweep25 + unit.rad_deg(5) # Design rule
self.mac = self.span*(self.c_axe**2+self.c_tip**2+self.c_axe*self.c_tip)/(3.*self.area)
y_mac = y_tip**2*(2*self.c_tip+self.c_axe)/(3*self.area)
z_mac = z_tip**2*(2*self.c_tip+self.c_axe)/(3*self.area)
x_tip_local = 0.25*(self.c_axe-self.c_tip) + y_tip*np.tan(self.sweep25)
x_mac_local = y_tip*x_tip_local*(self.c_tip*2.+self.c_axe)/(3.*self.area)
htp_x_wise_anchor = 0.85
x_axe = fuselage_length*(1-fuselage_cone_length/fuselage_length*(1-htp_x_wise_anchor)) - self.c_axe
x_tip = x_axe + x_tip_local
x_mac = x_axe + x_mac_local
self.lever_arm = (x_mac + 0.25*self.mac) - (wing_loc_mac[0] + 0.25*wing_mac)
self.loc_axe = np.array([x_axe, y_axe, z_axe])
self.loc_tip = np.array([x_tip, y_tip, z_tip])
self.loc_mac = np.array([x_mac, y_mac, z_mac])
self.frame_origin = self.loc_axe
self.frame_angles = [0., 0., 0.]
self.gross_wet_area = 1.63*self.area
self.net_wet_area = self.gross_wet_area
self.aero_length = self.mac
self.form_factor = 1.40
def __init__(self, aircraft):
super(HTP_H, self).__init__(aircraft)
wing_area = aircraft.airframe.wing.area
self.area = 0.33*wing_area # Coupling variable
self.span = None
self.aspect_ratio = 5.0 # Design rule
self.taper_ratio = 0.45 # Design rule
self.toc = 0.10 # Design rule
self.sweep25 = None
self.dihedral = unit.rad_deg(5) # HTP dihedral
self.volume = 0.94 # Design rule
self.lever_arm = None
self.loc_root = np.full(3,None) # Position of root chord leading edge
self.c_root = None # root chord length
self.loc_tip = np.full(3,None) # Position of tip chord leading edge
self.c_tip = None # tip chord length
self.loc_mac = np.full(3,None) # Position of MAC chord leading edge
self.mac = None
def eval_geometry(self):
wing_attachment = self.aircraft.arrangement.wing_attachment
cruise_mach = self.aircraft.requirement.cruise_mach
fuselage_width = self.aircraft.airframe.fuselage.width
fuselage_length = self.aircraft.airframe.fuselage.length
fuselage_height = self.aircraft.airframe.fuselage.height
self.toc_tip = 0.10
self.toc_kink = self.toc_tip + 0.01
self.toc_root = self.toc_kink + 0.03
self.sweep25 = 1.6*max(0.,(cruise_mach - 0.5)) # Empirical law
self.dihedral = unit.rad_deg(5.)
if(self.morphing=="aspect_ratio_driven"): # Aspect ratio is driving parameter
self.span = np.sqrt(self.aspect_ratio*self.area)
elif(self.morphing=="span_driven"): # Span is driving parameter
self.aspect_ratio = self.span**2/self.area
else:
print("geometry_predesign_, wing_morphing index is unkown")
y_root = 0.5*fuselage_width
y_kink = self.loc_kink[0]
y_tip = 0.5*self.span
if(15<unit.deg_rad(self.sweep25)): # With kink
Phi100intTE = max( 0. , 2.*(self.sweep25-unit.rad_deg(32.)) )
tan_phi100 = np.tan(Phi100intTE)
A = ((1-0.25*self.taper_ratio)*y_kink+0.25*self.taper_ratio*y_root-y_tip) / (0.75*y_kink+0.25*y_root-y_tip)
B = (np.tan(self.sweep25)-tan_phi100) * ((y_tip-y_kink)*(y_kink-y_root)) / (0.25*y_root+0.75*y_kink-y_tip)
self.c_root = (self.area-B*(y_tip-y_root)) / (y_root+y_kink+A*(y_tip-y_root)+self.taper_ratio*(y_tip-y_kink))
self.c_kink = A*self.c_root + B
self.c_tip = self.taper_ratio*self.c_root
else: # Without kink
self.c_root = 2.*self.area / (2.*y_root*(1.-self.taper_ratio) + (1.+self.taper_ratio)*np.sqrt(self.aspect_ratio*self.area))
self.c_tip = self.taper_ratio*self.c_root
self.c_kink = ((y_tip-y_kink)*self.c_root + (y_kink-y_root)*self.c_tip) / (y_tip-y_root)
tan_phi0 = 0.25*(self.c_kink-self.c_tip)/(y_tip-y_kink) + np.tan(self.sweep25)
self.mac = 2.*( 3.*y_root*self.c_root**2 \
+(y_kink-y_root)*(self.c_root**2+self.c_kink**2+self.c_root*self.c_kink) \
+(y_tip-y_kink)*(self.c_kink**2+self.c_tip**2+self.c_kink*self.c_tip) \
)/(3*self.area)
y_mac = ( 3.*self.c_root*y_root**2 \
+(y_kink-y_root)*(self.c_kink*(y_root+y_kink*2.)+self.c_root*(y_kink+y_root*2.)) \
+(y_tip-y_kink)*(self.c_tip*(y_kink+y_tip*2.)+self.c_kink*(y_tip+y_kink*2.)) \
)/(3.*self.area)
x_mac_local = ( (y_kink-y_root)*tan_phi0*((y_kink-y_root)*(self.c_kink*2.+self.c_root) \
+(y_tip-y_kink)*(self.c_kink*2.+self.c_tip))+(y_tip-y_root)*tan_phi0*(y_tip-y_kink)*(self.c_tip*2.+self.c_kink) \
)/(3*self.area)
x_root = 0.33*fuselage_length**1.1 - (x_mac_local + 0.25*self.mac)
x_kink = x_root + (y_kink-y_root)*tan_phi0
x_tip = x_root + (y_tip-y_root)*tan_phi0
x_mac = x_root+( (x_kink-x_root)*((y_kink-y_root)*(self.c_kink*2.+self.c_root) \
+(y_tip-y_kink)*(self.c_kink*2.+self.c_tip))+(x_tip-x_root)*(y_tip-y_kink)*(self.c_tip*2.+self.c_kink) \
)/(self.area*3.)
if (wing_attachment=="low"):
z_root = 0.
else:
z_root = fuselage_height - 0.5*self.toc_root*self.c_root
z_kink = z_root+(y_kink-y_root)*np.tan(self.dihedral)
z_tip = z_root+(y_tip-y_root)*np.tan(self.dihedral)
self.loc_root = np.array([x_root, y_root, z_root])
self.loc_kink = np.array([x_kink, y_kink, z_kink])
self.loc_tip = np.array([x_tip, y_tip, z_tip])
self.loc_mac = np.array([x_mac, y_mac, None])
self.frame_origin = [x_root, 0., z_root]
self.frame_angles = [0., 0., 0.]
self.gross_wet_area = 2.00*(self.area - self.c_root*fuselage_width)
self.net_wet_area = self.gross_wet_area
self.aero_length = self.mac
self.form_factor = 1.40
# Wing setting
#-----------------------------------------------------------------------------------------------------------
g = earth.gravity()
r,gam,Cp,Cv = earth.gas_data()
disa = 0.
rca = self.aircraft.requirement.cruise_altp
mach = self.aircraft.requirement.cruise_mach
mass = 0.95*self.aircraft.weight_cg.mtow
pamb,tamb,tstd,dtodz = earth.atmosphere(rca,disa)
cza_wing = self.cza(mach, fuselage_width, self.aspect_ratio, self.span, self.sweep25)
# AoA = 2.5° at cruise start
self.setting = (0.97*mass*g)/(0.5*gam*pamb*mach**2*self.area*cza_wing) - unit.rad_deg(2.5)