def coefficient_LLT(AC, velocity, AOA):
Au_P = [0.1828, 0.1179, 0.2079, 0.0850, 0.1874]
Al_P = Au_P
deltaz = 0
# Determine children shape coeffcients
AC_u = list(data.values[i, 0:4])
Au_C, Al_C, c_C, spar_thicknesses = calculate_dependent_shape_coefficients(
AC_u, psi_spars, Au_P, Al_P, deltaz, c_P, morphing=morphing_direction)
# Calculate aerodynamics for that airfoil
airfoil = 'optimal'
x = create_x(1., distribution='linear')
y = CST(x, 1., [deltaz / 2., deltaz / 2.], Al=Al_C, Au=Au_C)
# Create file for Xfoil to read coordinates
xf.create_input(x, y['u'], y['l'], airfoil, different_x_upper_lower=False)
Data = xf.find_coefficients(airfoil,
AOA,
Reynolds=Reynolds(10000, velocity, c_C),
iteration=100,
NACA=False)
deviation = 0.001
while Data['CL'] is None:
Data_aft = xf.find_coefficients(airfoil,
AOA * deviation,
Reynolds=Reynolds(
10000, velocity, c_C),
iteration=100,
NACA=False)
Data_fwd = xf.find_coefficients(airfoil,
AOA * (1 - deviation),
Reynolds=Reynolds(
10000, velocity, c_C),
iteration=100,
NACA=False)
try:
for key in Data:
Data[key] = (Data_aft[key] + Data_fwd[key]) / 2.
except:
deviation += deviation
alpha_L_0 = xf.find_alpha_L_0(airfoil,
Reynolds=0,
iteration=100,
NACA=False)
coefficients = LLT_calculator(alpha_L_0,
Data['CD'],
N=100,
b=span,
taper=1.,
chord_root=chord_root,
alpha_root=AOA,
V=velocity)
lift = coefficients['C_L']
drag = coefficients['C_D']
return lift, drag
def analyzeFlapFoil(self, inputAlpha, inputReynolds, inputIteration):
if isinstance(inputReynolds, list) or isinstance(
inputReynolds, np.ndarray):
for re in inputReynolds:
xf.find_coefficients(airfoil=self.flapFoilName,
alpha=inputAlpha,
Reynolds=re,
iteration=inputIteration,
NACA=False,
delete=False,
dir=self.relFlapFoilDir() + '/')
else:
xf.find_coefficients(airfoil=self.flapFoilName,
alpha=inputAlpha,
Reynolds=inputReynolds,
iteration=inputIteration,
NACA=False,
delete=False,
dir=self.relFlapFoilDir())
def find_3D_coefficients(airfoil,
alpha,
Reynolds=0,
iteration=10,
NACA=True,
N=10,
span=10.,
taper=1.,
chord_root=1,
alpha_root=1.,
velocity=1.):
""" Calculate the 3D distribution using the Lifting Line Theory.
:param airfoil: if NACA is false, airfoil is the name of the plain
filewhere the airfoil geometry is stored (variable airfoil).
If NACA is True, airfoil is the naca series of the airfoil
(i.e.: naca2244). By default NACA is False.
:param Reynolds: Reynolds number in case the simulation is for a
viscous flow. In case not informed, the code will assume
inviscid. (Use the aero_module function to calculate reynolds)
:param alpha: list/array/float/int of angles of attack.
:param iteration: changes how many times XFOIL will try to make the
results converge. Specialy important for viscous flows
:param NACA: Boolean variable that defines if the code imports an
airfoil from a file or generates a NACA airfoil.
:param N: number of cross sections on the wing
:param span: span in meters
:param taper: unidimendional taper (This options is still not 100%
operational)
:param chord_root: value of the chord at the the root
:param alpha_root: angle of attack of the chord at the root (degrees)
:param velocity: velocity in m/s
"""
coefficients = xf.find_coefficients(airfoil, alpha, Reynolds, iteration,
NACA)
alpha_L_0_root = xf.find_alpha_L_0(airfoil, Reynolds, iteration, NACA)
return ar.LLT_calculator(alpha_L_0_root, coefficients['CD'], N, span,
taper, chord_root, alpha_root, velocity)
def airfoil_coefficients(x):
naca_number = int((x[1] / x[0]) * 100)
if x[1] <= 0:
return 100
if naca_number <= 4:
return 100
if naca_number / 10 < 1:
naca_number = str(naca_number).zfill(2)
naca_airfoil = 'naca' + '00' + str(naca_number)
print(naca_airfoil)
airfoil_coeff = find_coefficients(airfoil=naca_airfoil,
alpha=0.1,
Reynolds=500000,
NACA=True,
iteration=30.)
# scale c_D based on length of hull
c_d_x = x[0] * airfoil_coeff['CD']
print("the value of c_d is " + str(c_d_x))
return c_d_x
import aeropy.xfoil_module as xf
from aeropy.CST_2D import CST
from aeropy.CST_2D.fitting import fitting_shape_coefficients, shape_parameter_study
airfoli_fn = os.listdir(".")
data_cd = []
data_cl = []
fn_list = []
angles = 0.
for fn in airfoli_fn:
with open(fn, 'r', encoding="utf8", errors='ignore') as f:
try:
coefs = xf.find_coefficients(fn,
angles,
Reynolds=100000,
iteration=100,
NACA=False)
print(fn)
print(coefs['CD'], coefs['CL'])
if coefs['CD'] is not None and coefs['CL'] is not None:
data_cd.append(coefs['CD'])
data_cl.append(coefs['CL'])
fn_list.append(fn)
except:
continue
print('Number of data:', len(data_cd))
# np.savez('../coefs.npz', data_cd, data_cl)
# with open('../file_names.csv', 'w', newline='') as f:
# wr = csv.writer(f, quoting=csv.QUOTE_ALL)
import numpy as np
import matplotlib.pyplot as plt
import aeropy.xfoil_module as xf
from aeropy.CST.module_2D import *
from aeropy.aero_module import Reynolds
from aeropy.geometry.airfoil import CST, create_x
# Au = [0.23993240191629417, 0.34468227138908186, 0.18125405377549103,
# 0.35371349126072665, 0.2440815012119143, 0.25724974995738387]
# Al = [0.18889012559339036, -0.24686758992053115, 0.077569769493868401,
# -0.547827192265256, -0.0047342206759065641, -0.23994805474814629]
Au = [0.172802, 0.167353, 0.130747, 0.172053, 0.112797, 0.168891]
Al = Au
# c_avian = 0.36 #m
# deltaz = 0.0093943568219451313*c_avian
c_avian = 1.
deltaz = 0
airfoil = 'avian'
x = create_x(1., distribution='linear')
y = CST(x, 1., [deltaz / 2., deltaz / 2.], Au=Au, Al=Al)
# Create file for Xfoil to read coordinates
xf.create_input(x, y['u'], y['l'], airfoil, different_x_upper_lower=False)
print('Reynolds: ', Reynolds(10000, 30, c_avian))
Data = xf.find_coefficients(airfoil,
0.,
Reynolds=Reynolds(10000, 30, c_avian),
iteration=100,
NACA=False)
print(Data)
'''Example comparing moment coefficient from xfoil relative to an in-house
code. The in-house code allows for moment calculation around regions of aifoils
(e.g. flap)'''
import matplotlib.pyplot as plt
import numpy as np
import aeropy.aero_module as ar
import aeropy.xfoil_module as xf
# For a single angle of attack
alpha = 0.
data = xf.find_pressure_coefficients('naca0012', alpha)
C_m = ar.calculate_moment_coefficient(data['x'], data['y'], data['Cp'], alpha)
data_CM = xf.find_coefficients('naca0012', alpha, delete=True)
print('calculated:', C_m)
print('objective:', data_CM['CM'])
# FOr multiple angles of attack
Cm_xfoil = []
Cm_aeropy = []
alpha_list = np.linspace(0, 10, 11)
for alpha in alpha_list:
alpha = float(alpha)
data = xf.find_pressure_coefficients('naca0012', alpha, delete=True)
Cm_aeropy.append(ar.calculate_moment_coefficient(data['x'], data['y'],
data['Cp'], alpha))
data_CM = xf.find_coefficients('naca0012', alpha, delete=True)
def calculate_flap_coefficients(x, y, alpha, x_hinge, deflection, Reynolds = 0,):
"""For a given airfoil with coordinates x and y at angle of attack
alpha, calculate the moment coefficient around the joint at x_hinge
and deflection """
def separate_upper_lower(x, y, Cp = None, i_separator=None):
"""Return dictionaries with upper and lower keys with respective
coordiantes. It is assumed the leading edge is frontmost point at
alpha=0"""
#TODO: when using list generated by xfoil, there are two points for
#the leading edge
def separate(variable_list, i_separator):
if type(i_separator) == int:
variable_dictionary = {'upper': variable_list[0:i_separator+1],
'lower': variable_list[i_separator+1:]}
elif type(i_separator) == list:
i_upper = i_separator[0]
i_lower = i_separator[1]
variable_dictionary = {'upper': variable_list[0:i_upper],
'lower': variable_list[i_lower:]}
return variable_dictionary
#If i is not defined, separate upper and lower surface from the
# leading edge
if i_separator == None:
i_separator = x.index(min(x))
if Cp == None:
x = separate(x, i_separator)
y = separate(y, i_separator)
return x, y
else:
x = separate(x, i_separator)
y = separate(y, i_separator)
Cp = separate(Cp, i_separator)
return x, y, Cp
# If x and y are not dictionaries with keys upper and lower, make them
# be so
if type(x) == list:
x, y = separate_upper_lower(x, y)
upper = {'x': x['upper'], 'y': y['upper']}
lower = {'x': x['lower'], 'y': y['lower']}
#Determining hinge
hinge = af.find_hinge(x_hinge, upper, lower)
upper_static, upper_flap = af.find_flap(upper, hinge)
lower_static, lower_flap = af.find_flap(lower, hinge, lower = True)
upper_rotated, lower_rotated = af.rotate(upper_flap, lower_flap, hinge, deflection)
flapped_airfoil, i_separator = af.clean(upper_static, upper_rotated, lower_static,
lower_rotated, hinge, deflection, N = 5,
return_flap_i = True)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Third step: get new values of pressure coefficient
xf.create_input(x = flapped_airfoil['x'], y_u = flapped_airfoil['y'],
filename = 'flapped', different_x_upper_lower = True)
Data = xf.find_coefficients('flapped', alpha, NACA = False,
Reynolds = Reynolds, iteration=500)
return Data
V = 10
altitude = 10000 #feet
Reynolds = ar.Reynolds(altitude, V, 1.0)
deflection_list = list(np.linspace(5,30,4))
alpha_list = list(np.linspace(0,15,20))
# Calculate coefficients for without flap
CL_list = []
CD_list = []
ratio_list = []
CM_list = []
for alpha_i in alpha_list:
Data_0 = xf.find_coefficients('naca0012', alpha_i, Reynolds = Reynolds,
iteration = 200)
CL_list.append(Data_0['CL'])
CD_list.append(Data_0['CD'])
ratio_list.append(Data_0['CL']/Data_0['CD'])
CM_list.append(Data_0['CM'])
All_data = {0:{r'$c_m$': CM_list, r'$c_l$':CL_list,
r'$c_d$': CD_list,
r'$c_l/c_d$': ratio_list}}#:Data_0['CL']/Data_0['CD']}}
# Calculate foeccifient when using flap
for deflection_i in deflection_list:
CL_list = []
CD_list = []
ratio_list = []
CM_list = []
for alpha_i in alpha_list:
for j in range(1145, len(Au_database)):
data['L/D'].append([])
print(j, airfoil_database['names'][j])
Au = Au_database[j, :]
Al = Al_database[j, :]
x = create_x(1., distribution = 'linear')
y = CST(x, chord, deltasz=[du_database[j], dl_database[j]],
Al=Al, Au=Au)
xf.create_input(x, y['u'], y['l'], airfoil, different_x_upper_lower = False)
for i in range(len(AOAs)):
AOA = AOAs[i]
V = velocities[i]
try:
Data = xf.find_coefficients(airfoil, AOA,
Reynolds=Reynolds(10000, V, chord),
iteration=100, NACA=False,
delete=True)
lift_drag_ratio = Data['CL']/Data['CD']
except:
lift_drag_ratio = None
increment = 0.1
conv_counter = 0
while lift_drag_ratio is None and conv_counter <3:
print(increment)
Data_f = xf.find_coefficients(airfoil, AOA*(1+increment),
Reynolds=Reynolds(10000, V*(1+increment), chord),
iteration=100, NACA=False,
delete=True)
Data_b = xf.find_coefficients(airfoil, AOA*(1-increment),
Reynolds=Reynolds(10000, V*(1-increment), chord),
iteration=100, NACA=False,
def aerodynamic_performance(AC, psi_spars, Au_P, Al_P, c_P, deltaz, alpha, H,
V):
morphing_direction = 'forwards'
air_data = air_properties(H, unit='feet')
density = air_data['Density']
dyn_pressure = .5 * density * V**2
# Generate dependent shape coefficients
# try:
Au_C, Al_C, c_C, spar_thicknesses = calculate_dependent_shape_coefficients(
AC, psi_spars, Au_P, Al_P, deltaz, c_P, morphing=morphing_direction)
# print 'Reynolds: ', Reynolds(H, V, c_C)
# Generate aifoil file
airfoil = 'test'
x = create_x(1., distribution='linear', n=300)
y = CST(x, 1., [deltaz / 2., deltaz / 2.], Au=Au_C, Al=Al_C)
# Get strain data
strains, av_strain = calculate_strains(Au_P, Al_P, c_P, Au_C, Al_C, c_C,
deltaz, psi_spars, spar_thicknesses)
intersections = intersect_curves(x, y['l'], x, y['u'])
print(intersections, intersections[0][1:])
if len(intersections[0][1:]) == 0:
# print y
create_input(x, y['u'], y['l'], airfoil, different_x_upper_lower=False)
# Get aerodynamic data
print(airfoil, alpha, Reynolds(H, V, c_C))
Data = find_coefficients(airfoil,
alpha,
Reynolds=Reynolds(H, V, c_C),
iteration=200,
NACA=False,
delete=True,
PANE=True,
GDES=True)
# plot_airfoil(AC, psi_spars, c_P, deltaz, Au_P, Al_P, image = 'save', iteration=counter, dir = airfoil+'_dir')
# filtering data (for now I only care about negative strains
str_output = {
'CL': Data['CL'],
'CD': Data['CD'],
'CM': Data['CM'],
'av_strain': av_strain,
'Au_C': Au_C,
'Al_C': Al_C,
'spars': psi_spars
}
if Data['CM'] == None:
str_output['lift'] = None
str_output['drag'] = None
str_output['moment'] = None
else:
str_output['lift'] = Data['CL'] / dyn_pressure / c_C,
str_output['drag'] = Data['CD'] / dyn_pressure / c_C,
str_output['moment'] = Data['CM'] / dyn_pressure / c_C
for i in range(len(strains)):
str_output['strain_' + str(i)] = strains[i]
# Writing to a text file
# f_worker = open(str(airfoil) + '.txt', 'wb')
# for i in range(len(key_list)):
# if i != len(key_list)-1:
# if key_list[i][:1] == 'Au':
# f_worker.write('%f\t' % str_output[key_list[i][:1]+'_C'][int(key_list[i][-1])])
# else:
# else:
# if key_list[i][:1] == 'Au':
# f_worker.write('%f\n' % str_output[key_list[i][:1]+'_C'][int(key_list[i][-1])])
else:
str_output = {
'CL': 1000,
'CD': None,
'CM': None,
'av_strain': av_strain,
'spars': psi_spars,
'Au_C': Au_C,
'Al_C': Al_C,
'lift': None,
'drag': None,
'moment': None
}
for i in range(len(strains)):
str_output['strain_' + str(i)] = strains[i]
# except:
# str_output = {'CL':None, 'CD':None, 'CM':None, 'av_strain':None,
# 'Au_C':[None]*len(AC), 'Al_C': [None]*len(AC),
# 'lift': None, 'drag': None, 'moment':None,
# 'strains':[None]*(len(AC)-1), 'spars':psi_spars}
return str_output
Eng=True):
if (X_0 != None):
ax.xaxis.set_major_locator(ticker.MultipleLocator(mult_x * X_0))
ax.xaxis.set_minor_locator(ticker.MultipleLocator((mult_x / 5) * X_0))
if (Eng):
ax.xaxis.set_major_formatter(ticker.EngFormatter())
ax.yaxis.set_major_formatter(ticker.EngFormatter())
if (Y_0 != None):
ax.yaxis.set_major_locator(ticker.MultipleLocator(mult_y * Y_0))
ax.yaxis.set_minor_locator(ticker.MultipleLocator(mult_y / 5 * Y_0))
if (grd == True):
ax.grid(b=True, which='major', axis='both')
else:
ax.grid(b=False, which='major', axis='both')
if (minorgrd == True):
ax.grid(b=True, which='minor', axis='both')
else:
ax.grid(b=False, which='minor', axis='both')
if (x_lim != None):
ax.set_xlim(x_lim)
if (y_lim != None):
ax.set_ylim(y_lim)
return ax
"""#########################################################################"""
import aeropy.xfoil_module as xf
print(xf.find_coefficients('naca4415', 5.0, 10e5, 10))
def calcairfoil(self,
stage,
blade: str,
station: str,
plot_airfoil=False,
plot_ploar=False,
plot_cp=False,
plot_sv=False):
"""Calculate Bezier-PARSEC variables and airfoil properties."""
avle, avte, rvle, rvte, v1, v2, radius = ut.get_vars(stage=stage,
blade=blade,
station=station)
cx = v1 * m.cos(r(avle))
u = stage.rpm / 60 * 2 * m.pi * radius
betam = d(m.atan((m.tan(r(avle)) + m.tan(r(avte))) / 2))
self.dh = v2 / v1
self.space = (2 * m.pi * radius) / self.z
# self.chord = stage.span/self.ar
# self.sigma = self.chord/self.space
# self.df = ((1 - m.cos(r(avle))/m.cos(r(avte)))
# + ((m.cos(r(avle))*(m.tan(r(avle)) - m.tan(r(avte))))
# / (2*self.sigma)))
self.sigma = ((m.cos(r(avle)) * (m.tan(r(avle)) - m.tan(r(avte)))) /
(2 * (m.cos(r(avle)) / m.cos(r(avte)) - 1 + self.df)))
self.chord = self.sigma * self.space
# Incidence, deviation, and blade angle calculation
self.deflection = abs(avle - avte)
self.incidence, _n_slope = ut.calcincidence(thickness=2 * self.yt,
solidity=self.sigma,
relative_inlet_angle=rvle)
self.deviation, _m_slope = ut.calcdeviation(thickness=2 * self.yt,
solidity=self.sigma,
relative_inlet_angle=rvle)
self.blade_angle_i = avle - self.incidence
self.blade_angle_e = avte - self.deviation
self.camber = abs(self.blade_angle_i - self.blade_angle_e)
# Compare to:
# self.camber2 = (self.deflection
# - (self.incidence
# - self.deviation))/(1 - m_slope + n_slope)
# self.blade_angle_e2 = self.blade_angle_i + self.camber2
# Assumes double circular arc airfoil to estimate stagger
self.stagger = (self.blade_angle_i * self.xcr + self.blade_angle_e *
(1 - self.xcr))
self.aoa = abs(self.stagger - avle)
# Redefine blade angles to sw blade angles (stagger independent)
self.cle = self.blade_angle_i - self.stagger
self.cte = self.stagger - self.blade_angle_e
# Assume NACA 4 definition of wedge angle and leading edge radius
self.rle = 1.1019 * (2 * self.yt)**2
self.wte = 2 * d(m.atan(1.16925 *
(2 * self.yt))) # TE radius done in sw
# Calculate natural xc,yc from cle and cte using ycr altitutde ratio
self.xc = m.tan(r(
self.cte)) / (m.tan(r(self.cle)) + m.tan(r(self.cte)))
# self.ycr = (self.xc + 1)/2
self.yc = self.ycr * self.xc * abs(m.tan(r(self.cle)))
# Assume NACA 4 curvature
self.kc, self.kt = ut.curvatures(xc=self.xc,
yc=self.yc,
xt=self.xt,
yt=self.yt)
self.bc, self.bt = ut.beziers(xc=self.xc,
yc=self.yc,
kc=self.kc,
xt=self.xt,
yt=self.yt,
kt=self.kt,
cle=self.cle,
cte=self.cte,
rle=self.rle,
blade=blade,
station=station)
airfoil_name = blade + '_' + station
wf.create_coord_file(filename=airfoil_name,
plot=plot_airfoil,
xc=self.xc,
yc=self.yc,
kc=self.kc,
bc=self.bc,
xt=self.xt,
yt=self.yt,
kt=self.kt,
bt=self.bt,
cle=self.cle,
cte=self.cte,
wte=self.wte,
rle=self.rle)
self.Re = self.rho * v1 * self.chord / self.mu
self.polar = xf.find_coefficients(airfoil=airfoil_name,
indir='Input',
outdir='Output',
alpha=self.aoa,
Reynolds=self.Re,
iteration=500,
echo=False,
delete=False,
NACA=False,
PANE=True)
self.cp = xf.find_pressure_coefficients(airfoil=airfoil_name,
alpha=self.aoa,
indir='Input',
outdir='Output',
Reynolds=self.Re,
iteration=500,
echo=False,
NACA=False,
chord=1.,
PANE=True,
delete=False)
self.sv = {'x': list(), 'y': list(), 'v': list()}
for i in range(len(self.cp['Cp'])):
self.sv['x'].append(self.cp['x'][i])
# self.sv['y'].append(self.cp['y'][i])
self.sv['v'].append(m.sqrt(1 - self.cp['Cp'][i]))
if plot_cp:
plt.plot(self.cp['x'], self.cp['Cp'])
plt.show()
if plot_sv:
plt.plot(self.sv['x'], self.sv['v'])
plt.show()
if plot_ploar:
# Gather multiple angles of attack for airfoil and get polars
alphas = list(range(-30, 30))
polars = xf.find_coefficients(airfoil=airfoil_name,
alpha=alphas,
Reynolds=self.Re,
iteration=500,
delete=True,
echo=False,
NACA=False,
PANE=True)
# Plot airfoil
plt.plot(polars['alpha'], polars['CL'])
plt.show()
try:
cl = self.polar['CL']
cd = self.polar['CD']
gamma = m.atan(cd / cl)
self._psi = (((cx / u) / 2) * ut.sec(r(betam)) * self.sigma *
(cl + cd * m.tan(r(betam))))
self.psi_opt = (((cx / u) / m.sqrt(2)) * self.sigma * (cl + cd))
self.dX = ((self.rho * cx**2 * self.chord * cl /
(2 * m.cos(r(betam))**2)) * m.sin(r(betam) - gamma) /
m.cos(gamma))
self.dTau = (
(self.rho * cx**2 * self.chord * cl * self.z * radius /
(2 * m.cos(r(betam))**2)) * m.cos(r(betam) - gamma) /
m.cos(gamma))
self.delta_p = cl * ((self.rho * cx**2 * self.chord /
(2 * self.space * m.cos(r(betam))**2)) *
m.sin(r(betam) - gamma) / m.cos(gamma))
self.delta_T = (cl / 1.005) * (
(u * cx * self.chord / (2 * self.space * m.cos(r(betam))**2)) *
m.cos(r(betam) - gamma) / m.cos(gamma))
self.efficiency = (cx/u)*m.tan(r(betam) - gamma)\
+ cx*m.tan(r(rvte))/(2*u)
except TypeError:
print('Design point did not converge in xfoil.')
# pass
print(f'{station} {blade} Performance')
print(f' DF: {self.df:.2f} (<=0.6)')
print(f' DH: {self.dh:.2f} (>=0.72)')
print(f' i : {self.incidence:.2f} deg')
print(f' d : {self.deviation:.2f} deg')
print('\n')
def aircraft_range_LLT(AC, velocity, AOA):
def to_integrate(weight):
# velocity = 0.514444*108 # m/s (113 KTAS)
span = 10.9728
RPM = 1800
a = 0.3089 # (lb/hr)/BTU
b = 0.008 * RPM + 19.607 # lb/hr
lbhr_to_kgs = 0.000125998
BHP_to_watt = 745.7
eta = 0.85
thrust = weight / lift_to_drag
power_SI = thrust * velocity / eta
power_BHP = power_SI / BHP_to_watt
mass_flow = (a * power_BHP + b)
mass_flow_SI = mass_flow * lbhr_to_kgs
SFC = mass_flow_SI / thrust
dR = velocity / g / SFC * lift_to_drag / weight
return dR * 0.001 #*0.0005399
Au_P = [0.1828, 0.1179, 0.2079, 0.0850, 0.1874]
Al_P = Au_P
deltaz = 0
# Determine children shape coeffcients
AC_u = list(data.values[i, 0:4])
Au_C, Al_C, c_C, spar_thicknesses = calculate_dependent_shape_coefficients(
AC_u, psi_spars, Au_P, Al_P, deltaz, c_P, morphing=morphing_direction)
# Calculate aerodynamics for that airfoil
airfoil = 'optimal'
x = create_x(1., distribution='linear')
y = CST(x, 1., [deltaz / 2., deltaz / 2.], Al=Al_C, Au=Au_C)
# Create file for Xfoil to read coordinates
xf.create_input(x, y['u'], y['l'], airfoil, different_x_upper_lower=False)
Data = xf.find_coefficients(airfoil,
AOA,
Reynolds=Reynolds(10000, velocity, c_C),
iteration=100,
NACA=False)
deviation = 0.001
while Data['CL'] is None:
Data_aft = xf.find_coefficients(airfoil,
AOA * deviation,
Reynolds=Reynolds(
10000, velocity, c_C),
iteration=100,
NACA=False)
Data_fwd = xf.find_coefficients(airfoil,
AOA * (1 - deviation),
Reynolds=Reynolds(
10000, velocity, c_C),
iteration=100,
NACA=False)
try:
for key in Data:
Data[key] = (Data_aft[key] + Data_fwd[key]) / 2.
except:
deviation += deviation
alpha_L_0 = xf.find_alpha_L_0(airfoil,
Reynolds=0,
iteration=100,
NACA=False)
coefficients = LLT_calculator(alpha_L_0,
Data['CD'],
N=100,
b=span,
taper=1.,
chord_root=chord_root,
alpha_root=AOA,
V=velocity)
lift_to_drag = coefficients['C_L'] / coefficients['C_D']
g = 9.81 # kg/ms
fuel = 56 * 6.01 * 0.4535 * g
initial_weight = 1111 * g
final_weight = initial_weight - fuel
return scipy.integrate.quad(to_integrate, final_weight, initial_weight)[0]
