import pylab as pyl
if __name__ == "__main__":
Aircraft.Wing.Draw2DAirfoilPolars(fig=1)
Aircraft.HTail.Draw2DAirfoilPolars(fig=2)
Aircraft.PlotPolarsSlopes(fig=3)
Aircraft.PlotCMPolars(
4, (-12 * ARCDEG, -5 * ARCDEG, 0 * ARCDEG, +5 * ARCDEG, +12 * ARCDEG),
XcgOffsets=(+0.02, -0.02))
Aircraft.PlotCLCMComponents(fig=5,
del_es=(-10 * ARCDEG, -5 * ARCDEG, 0 * ARCDEG,
+5 * ARCDEG, +10 * ARCDEG))
Aircraft.Refresh()
print "Xnp : ", AsUnit(Aircraft.Xnp(), 'in')
print "Wing X : ", AsUnit(Aircraft.Wing.X[0], 'in')
print 'HTail Incidence : ', AsUnit(Aircraft.HTail.i, 'deg')
print 'HTail VC : ', Aircraft.HTail.VC
pyl.show()
#
# The green linear slop approximations should agree well with the blue polars.
# The slope is adjusted with the *SlopeAt variables.
#
# The CM vs. alpha curve for the neutral point should be horizontal.
#
def real_main():
TCG = Aircraft.CG()
ACG = Aircraft.Fuselage.AircraftCG()
dCG = TCG - ACG
print 'Aircraft Xnp :', Aircraft.Xnp()
print 'Aircraft Xcg :', Aircraft.Xcg()
print 'Aircraft CM :', Aircraft.CM(15 * ARCDEG, del_e=10 * ARCDEG)
print 'Aircraft dCM_da:', Aircraft.dCM_da()
print
print 'Wing Area :', AsUnit(Aircraft.Wing.S, 'in**2')
print 'Wing MAC :', AsUnit(Aircraft.Wing.MAC(), 'in')
print 'Wing dCl_da :', AsUnit(Aircraft.Wing.dCL_da(), '1/rad')
print 'Wing Xac :', AsUnit(Aircraft.Wing.Xac(), 'in')
print 'Wing Downwash :', Aircraft.WingDownWash(0 * ARCDEG)
print 'Wing Separation: ', Aircraft.Wing.UpperWing.X[
2] - Aircraft.Wing.LowerWing.X[2]
print 'Wing Stagger : ', Aircraft.Wing.UpperWing.X[
0] - Aircraft.Wing.LowerWing.X[0]
print
print 'Horiz Area :', AsUnit(Aircraft.HTail.S, 'in**2')
print 'Horiz Span :', AsUnit(Aircraft.HTail.b, 'in')
print 'Horiz Root :', Aircraft.HTail.Chord(0 * IN)
print 'Horiz Tip :', Aircraft.HTail.Chord(Aircraft.HTail.b / 2)
print 'Horiz Tip Swp :', Aircraft.HTail.LE(
Aircraft.HTail.b / 2) - Aircraft.HTail.LE(0 * IN)
print 'Horiz VC :', Aircraft.HTail.VC
print 'Horiz Dsgn CL :', Aircraft.GetHT_Design_CL()
print 'Horiz Inc :', Aircraft.HTail.i
print 'Horiz dCl_da :', AsUnit(Aircraft.HTail.dCL_da(), '1/rad')
print
print 'Vert Area :', AsUnit(Aircraft.VTail.S, 'in**2')
print 'Vert Span :', AsUnit(Aircraft.VTail.b, 'in')
print 'Vert Root :', Aircraft.VTail.Chord(0 * IN)
print 'Vert Tip :', Aircraft.VTail.Chord(Aircraft.VTail.b)
print 'Vert Tip Swp :', Aircraft.VTail.LE(
Aircraft.VTail.b) - Aircraft.VTail.LE(0 * IN)
print 'Vert VC :', Aircraft.VTail.VC
print
print 'True CG :', TCG[0]
print 'Desired CG :', ACG[0]
print 'CG Loc rel Wing:', ACG[0] - Aircraft.Wing.LowerWing.LE(0 * IN)
print 'NP Loc rel Wing:', AsUnit(
Aircraft.Xnp() - Aircraft.Wing.LowerWing.LE(0 * IN), 'in')
print 'delta CG :', dCG[0]
print 'Empty Weight :', AsUnit(Aircraft.EmptyWeight, 'lbf')
print 'Payload Weight :', AsUnit(Aircraft.PayloadWeight(), 'lbf')
print
print 'Composite Nose'
Nose = Aircraft.Fuselage.Nose
CompWeight = Nose.Weight + Nose.FrontBulk.Weight + Nose.BackBulk.Weight
print ' Composite Nose Weight: ', AsUnit(CompWeight, 'lbf')
print ' Composite Nose Area: ', AsUnit(
((CompWeight / Nose.SkinMat.AreaDensity) / g), 'in**2')
print ' Composite Nose Density: ', AsUnit(Nose.SkinMat.AreaDensity * g,
'lbf/in**2')
print
print 'Wing Weight :', AsUnit(Aircraft.Wing.Weight, 'lbf')
print 'Horiz Weight :', AsUnit(Aircraft.HTail.Weight, 'lbf')
print 'Vert Weight :', AsUnit(Aircraft.VTail.Weight, 'lbf')
print
print 'Propulsion MOI :', AsUnit(Aircraft.Propulsion.MOI(), 'slug*ft**2')
print 'Wing MOI :', AsUnit(Aircraft.Wing.MOI(), 'slug*ft**2')
print 'HTail MOI :', AsUnit(Aircraft.HTail.MOI(), 'slug*ft**2')
print 'VTail MOI :', AsUnit(Aircraft.VTail.MOI(), 'slug*ft**2')
print 'Aircraft MOI :', AsUnit(Aircraft.MOI(), 'slug*ft**2')
print
print 'HTail Length : ', Aircraft.HTail.L
print 'VTail Length : ', Aircraft.VTail.L
print
print 'MainGear Base :', Aircraft.MainGear.WheelBase()
print 'NoseGear Base :', Aircraft.NoseGear.WheelBase()
OTANGLE = Aircraft.OverturnAngle()
print 'Overturn Angle :', OTANGLE
print
print 'Aircraft V_LO :', AsUnit(Aircraft.GetV_LO(), 'ft/s')
print 'Wing V_LO :', AsUnit(Aircraft.Wing.GetV_LO(), 'ft/s')
print 'Ground Roll Distance: ', Aircraft.Groundroll()
print 'LO Rate of Climb : ', AsUnit(
Aircraft.Rate_of_Climb(Aircraft.GetV_LO() * 1.07), 'ft/min')
print
print 'LEHT to LEVT : ', Aircraft.HTail.LE(0 * IN) - Aircraft.VTail.LE(
0 * IN)
print 'TailTaperlength: ', Aircraft.Fuselage.TailTaper.FrontBulk.X[
0] - Aircraft.HTail.LE(0 * IN)
H = max(Aircraft.Wing.Upper(0 * IN), Aircraft.VTail.Tip()[2])
W = Aircraft.Wing.b
L = Aircraft.HTail.MaxTE()
print
print 'Wing Height : ', Aircraft.Wing.Upper(0 * IN)
print 'Vertical Tail H: ', Aircraft.VTail.Tip()[2]
print 'Width : ', W
print 'Length : ', L
print 'Sum of Lengths : ', AsUnit((W + L + H), 'in')
# HTail.Draw2DAirfoilPolars(fig = 10)
# Aircraft.Wing.Draw2DAirfoilPolars(fig = 9)
# Aircraft.PlotCLCMComponents(fig = 8, del_es = (-10*ARCDEG, -5*ARCDEG, 0*ARCDEG, +5*ARCDEG, +10 * ARCDEG))
# Aircraft.PlotTailLoad(fig=7)
# Aircraft.PlotTrimmedPolars(fig=6)
# Aircraft.PlotCMPolars(5, (-10*ARCDEG, -2.5*ARCDEG, -5*ARCDEG, 0*ARCDEG, +5*ARCDEG, +10 * ARCDEG), (+0.5 * IN, -0.5 * IN))
# Aircraft.PlotPolarsSlopes(fig=4)
# Aircraft.WriteAVLAircraft('AVLAircraft.avl')
# Aircraft.PlotDragBuildup(fig=3)
# Aircraft.PlotVNDiagram(fig=2)
Aircraft.Draw()
pyl.show()
MinCumpRate = 100
S = npy.linspace(906, 1500, 5) * IN**2
WT = npy.linspace(27, 50, 1) * LBF
lgnd = ['Design']
arealist = []
# Initialize data arrays
grndroll = npy.zeros((len(WT), len(S)))
clmbrate = npy.zeros((len(WT), len(S)))
#
# Calculate the groundroll and climb rate
#
for ii in range(len(WT)):
print "Calculating total weight = ", AsUnit(WT[ii], 'lbf')
for jj in range(len(S)):
print "Calculating at S = ", AsUnit(S[jj], 'in**2')
Aircraft.Wing.S = S[jj]
Aircraft.TotalWeight = WT[ii]
grndroll[ii][jj] = Aircraft.Groundroll() / (FT)
clmbrate[ii][jj] = Aircraft.Rate_of_Climb(
1.07 * Aircraft.GetV_LO()) / (FT / MIN)
if ii == 0:
arealist.append(Aircraft.Wing.S)
#
# Plot the calculated values
#
for ii in range(len(WT)):
from scalar.units import GRAM, gacc, A, V, mAh, IN, LBF
from scalar.units import AsUnit
from Aerothon.ACMotor import ACBattery
Weight = []
Power = []
#Thunder Power
Turnigy_6Cell_3000_LV = ACBattery()
Turnigy_6Cell_3000_LV.Voltage = 21.2*V
Turnigy_6Cell_3000_LV.Cells = 6
Turnigy_6Cell_3000_LV.Capacity = 3000*mAh
Turnigy_6Cell_3000_LV.C_Rating = 25
Turnigy_6Cell_3000_LV.Weight = .915*LBF
Turnigy_6Cell_3000_LV.LWH = (1.375*IN,1.875*IN,6.0*IN) #inaccurate dimensions
Power.append( Turnigy_6Cell_3000_LV.Power() )
Weight.append( Turnigy_6Cell_3000_LV.Weight )
if __name__ == '__main__':
print AsUnit( Turnigy_6Cell_3000_LV.Imax, 'A' )
# Set Propulsion properties
PropulsionOS = ACPropulsion(Prop, OS)
PropulsionOS.Alt = 0 * FT
PropulsionOS.Vmax = 100 * FT / SEC
PropulsionOS.nV = 20
PropulsionMAG = ACPropulsion(Prop, Magnum)
PropulsionMAG.Alt = 0 * FT
PropulsionMAG.Vmax = 100 * FT / SEC
PropulsionMAG.nV = 20
if __name__ == '__main__':
import pylab as pyl
print "Static Thrust :", AsUnit(PropulsionOS.T(0 * FT / SEC), "lbf")
print "Static Thrust :", AsUnit(PropulsionMAG.T(0 * FT / SEC), "lbf")
Vmax = 100
V = npy.linspace(0, Vmax, 30) * FT / SEC
Vprop = npy.linspace(0, Vmax, 5) * FT / SEC
N = npy.linspace(1000, 20000, 30) * RPM
PropulsionOS.PlotMatched(V, N, Vprop, fig=2)
PropulsionMAG.PlotMatched(V, N, Vprop, fig=2)
#Propulsion.PlotTPvsN(N, Vprop, fig=3)
PropulsionMAG.PlotTestData(fig=3)
PropulsionOS.PlotTestData(fig=4)
#Propulsion.Draw(fig=4)
pyl.show()
from __future__ import division # let 5/2 = 2.5 rather than 2 from scalar.units import ARCDEG from scalar.units import AsUnit import numpy as npy import pylab as pyl from Aircraft_Models.Reg2009Aircraft_RedBearon.MonoWingAircraft.Aircraft import Aircraft print 'Lift of Angle of Attack:', AsUnit(Aircraft.GetAlphaFus_LO(), 'deg') print 'Zero CM at Alpha :', AsUnit(Aircraft.Alpha_Zero_CM, 'deg') print 'Horiz Design CL :', Aircraft.GetHT_Design_CL() print 'Horiz Incidence :', Aircraft.HTail.i Aircraft.PlotTailLoad(fig=4) Aircraft.PlotVTailLoad(fig=5) Aircraft.PlotHTailLoad(fig=6) Aircraft.HTail.Draw3DWingPolars(fig=3) Aircraft.HTail.Draw2DAirfoilPolars(fig=2) Aircraft.Draw(fig=1) pyl.show()
from __future__ import division # let 5/2 = 2.5 rather than 2
import numpy as npy
import pylab as pyl
from scalar.units import ARCDEG, FT, SEC, LBF
from scalar.units import AsUnit
from Aircraft_Models.Reg2009Aircraft_RedBearon.MonoWingAircraft.Aircraft import Aircraft
print 'Aircraft V_LO : ', AsUnit(Aircraft.GetV_LO(), 'ft/s')
print 'Wing V_LO : ', AsUnit(Aircraft.Wing.GetV_LO(), 'ft/s')
print 'Ground Roll Distance: ', AsUnit(Aircraft.Groundroll(), 'ft')
#
# Uncomment the next two lines and comment out the other "PlotPropulsionPerformance"
# call to plot for a range of values
#
WeightRange = npy.linspace(30, 34, 3) * LBF
Aircraft.PlotPropulsionPerformance(1,
Vmax=70 * FT / SEC,
TotalWeights=WeightRange)
ii = 2
for wt in WeightRange:
Aircraft.TotalWeight = wt
Aircraft.PlotLiftVelocityGroundroll(ii)
ii += 1
Aircraft.Draw(ii + 1)
pyl.show()
#
# These are corrected for standard day
#
# RPM, Thrust
#Prop.ThrustData = [(8100 *RPM, 4 *LBF + 8*OZF),
# (9200 *RPM, 5 *LBF + 13*OZF),
# (11200 *RPM, 9 *LBF + 3*OZF)]
# RPM, Torque
#Prop.TorqueData = [(11000 *RPM, 114.768*IN*OZF)]
################################################################################
if __name__ == '__main__':
print "Max " + AsUnit(Prop.MaxRPM(), 'rpm', '%3.0f') + " at " + AsUnit(
Prop.MaxTipSpeed, 'ft/s') + " tip speed ",
Vmax = 100
h = 0 * FT
N = npy.linspace(1000, 13000, 4) * RPM
Alpha = npy.linspace(-25, 25, 31) * ARCDEG
V = npy.linspace(0, Vmax, 11) * FT / SEC
# Prop.CoefPlot(Alpha,fig = 1)
Prop.PTPlot(N, V, h, 'V', fig=2)
N = npy.linspace(0, 13000, 31) * RPM
V = npy.linspace(0, Vmax, 5) * FT / SEC
DWF = npy.linspace(1.3, 1.7, 3)
Xnp = []
Cm = []
iht = []
HTail = Aircraft.HTail
Aircraft.Refresh()
Aircraft.Draw(2)
Aircraft.PlotCMPolars(
3, (-10 * ARCDEG, -5 * ARCDEG, 0 * ARCDEG, +5 * ARCDEG, +10 * ARCDEG),
XcgOffsets=(+0.02, -0.02))
SetDWF = HTail.DWF
print "DWF, iht : ", SetDWF, AsUnit(Aircraft.HTail.i, 'deg')
Controls.RunDir = 'AVLDWF/'
for i in range(len(DWF)):
print "DWF = ", DWF[i]
run = 'Run' + str(i)
HTail.DWF = DWF[i]
Aircraft.Refresh()
Controls.AddRun(run,
'AVLAircraft' + str(i) + '.avl',
WriteAVLInput=Execute)
Controls.Runs[i].AddCommand('a a ' + str(Aircraft.Alpha_Zero_CM / ARCDEG))
Controls.Runs[i].DumpStability('STFile' + str(i) + '.txt')
iht.append(Aircraft.HTail.i)
if Execute:
Battery = ACBattery()
Battery.Cells = 3
Battery.Capacity = 450 * mAh
Battery.C_Rating = 65
Battery.Weight = 41.5 * GRAM * gacc
Motor = ACMotor()
Motor.Battery = Battery
Motor.Ri = 0.35 * OHM
Motor.Io = 0.46 * A
Motor.Kv = 1900 * RPM / V
Motor.xRm = 1
Motor.Pz = 0
Nmax = Motor.Nmax / RPM
print AsUnit(Motor.Pmax(), 'W')
print AsUnit(Motor.I_Effmax(), 'A')
print AsUnit(Motor.N_Effmax(), 'rpm')
print 'Max Eff : ', Motor.Effmax()
N = npy.linspace(0, Nmax, 20) * RPM
Tb = Motor.Tb(0, N)
Pb = Motor.Pb(0, N)
eta = Motor.Efficiency(N=N)
N = N / RPM
Tb = Tb / (IN * OZF)
Pb = Pb / Motor.PowerUnit
pyl.figure(1)
h = 0 * FT
N = npy.linspace(1000, 10000, 5) * RPM
Alpha = npy.linspace(-25, 25, 41) * ARCDEG
V = npy.linspace(0, Vmax, 30) * FT / SEC
Prop.CoefPlot(Alpha, fig=1)
Prop.PTPlot(N, V, h, 'V', fig=2)
#
# N = npy.linspace(0, 13000,31)*RPM
# V = npy.linspace(0,Vmax,5)*FT/SEC
#
# Prop.PTPlot(N,V,h,'N', fig = 3)
Prop.PlotTestData(fig=4)
N = 9600 * RPM
print "Max " + AsUnit(Prop.MaxRPM(), 'rpm', '%3.0f') + " at " + AsUnit(
Prop.MaxTipSpeed, 'ft/s') + " tip speed "
print
print "Static Thrust : ", AsUnit(Prop.T(N, 0 * FT / SEC, h), 'lbf')
print "Measured Thrust : ", AsUnit(max(npy.array(Prop.ThrustData)[:, 1]),
'lbf')
N = 9700 * RPM
print
print "Static Torque : ", AsUnit(
Prop.P(N, 0 * FT / SEC, h) / N, 'in*ozf')
print "Measured Torque : ", AsUnit(max(npy.array(Prop.TorqueData)[:, 1]),
'in*ozf')
pyl.show()
#CL = HTail.CL(alphas)
#pyl.figure(8)
#pyl.plot(alphas / (ARCDEG), CL)
#HTail.Draw2DAirfoilPolars(fig=1)
#HTail.Draw3DWingPolars(fig=2)
#pyl.show()
if __name__ == '__main__':
TCG = Aircraft.CG()
ACG = Aircraft.Fuselage.AircraftCG()
dCG = TCG - ACG
print 'Aircraft Xnp :', AsUnit(Aircraft.Xnp(), 'in')
print 'Aircraft Xcg :', AsUnit(Aircraft.Xcg(), 'in')
print 'Aircraft CM :', Aircraft.CM(15 * ARCDEG, del_e=10 * ARCDEG)
print 'Aircraft dCM_da:', AsUnit(Aircraft.dCM_da(), '1/rad')
print
print 'Wing Area :', AsUnit(Aircraft.Wing.S, 'in**2')
print 'Wing MAC :', AsUnit(Aircraft.Wing.MAC(), 'in')
print 'Wing dCl_da :', AsUnit(Aircraft.Wing.dCL_da(), '1/rad')
print 'Wing Xac :', AsUnit(Aircraft.Wing.Xac(), 'in')
print
print 'Horiz Area :', AsUnit(Aircraft.HTail.S, 'in**2')
print 'Horiz Length :', AsUnit(Aircraft.HTail.L, 'in')
print 'Horiz VC :', Aircraft.HTail.VC
print 'Horiz iht :', AsUnit(Aircraft.HTail.i, 'deg')
print 'Horiz dCl_da :', AsUnit(Aircraft.HTail.dCL_da(), '1/rad')
print
MainGear.Wheel.Weight = 0.1 * LBF
NoseGear = Aircraft.NoseGear
NoseGear.StrutW = 0.1 * IN
NoseGear.StrutH = 0.1 * IN
NoseGear.WheelDiam = 2.5 * IN
NoseGear.Strut.Weight = 0.1 * LBF
NoseGear.Wheel.Weight = 0.1 * LBF
if __name__ == '__main__':
TCG = Aircraft.CG()
ACG = Aircraft.Fuselage.AircraftCG()
dCG = TCG - ACG
print 'Aircraft Xnp :', AsUnit(Aircraft.Xnp(), 'in')
print 'Aircraft Xcg :', AsUnit(Aircraft.Xcg(), 'in')
print 'Aircraft CM :', Aircraft.CM(15 * ARCDEG, del_e=10 * ARCDEG)
print 'Aircraft dCM_da:', AsUnit(Aircraft.dCM_da(), '1/rad')
print
print 'Wing Area :', AsUnit(Aircraft.Wing.S, 'in**2')
print 'Wing MAC :', AsUnit(Aircraft.Wing.MAC(), 'in')
print 'Wing dCl_da :', AsUnit(Aircraft.Wing.dCL_da(), '1/rad')
print 'Wing Xac :', AsUnit(Aircraft.Wing.Xac(), 'in')
print
print 'Horiz Area :', AsUnit(Aircraft.HTail.S, 'in**2')
print 'Horiz Length :', AsUnit(Aircraft.HTail.L, 'in')
print 'Horiz iht :', AsUnit(Aircraft.HTail.i, 'deg')
print 'Horiz dCl_da :', AsUnit(Aircraft.HTail.dCL_da(), '1/rad')
print 'Horiz Design CL:', Aircraft.GetHT_Design_CL()
print
pyl.figure(2)
legend = []
for V in Vs:
Pda = []
for da in das:
Pda.append(Controls.Deriv[0].RollDueToAileron(da, 'Aileron', V=V) /
(ARCDEG / SEC))
# Uncomment following line if plotting for more than 2 flight velocities
#legend.append( AsUnit(V, 'ft/s', '%1.0f') )
pyl.plot(das / ARCDEG, Pda)
# Comment following 2 lines if plotting for more than 2 flight velocities
legend.append('$V_{LO}=$' + AsUnit(Aircraft.GetV_LO(), 'ft/s', '%1.0f'))
legend.append('$V_{max}=$' + AsUnit(Aircraft.Vmax(), 'ft/s', '%1.0f'))
pyl.xlabel('Aileron Deflection (deg)')
pyl.ylabel('Roll Rate (deg/s)')
pyl.legend(legend)
pyl.grid()
Wing = Aircraft.Wing
LLT = Aircraft.Wing.LLT
y = npy.linspace(-Wing.b / 2 / IN, Wing.b / 2 / IN, 61) * IN
#LLT.Alpha3d = 5*ARCDEG
pyl.figure(3)
Fuselage.XcgSecFrac = 0.5
#
# Define the payload shape
#
Fuselage.Payload.Width = 4 * IN
Fuselage.Payload.Length = 10 * IN
Fuselage.Payload.Face = 'Bottom'
Fuselage.Payload.Material = Steel.copy()
Fuselage.Payload.Weight = 1 * LBF
#
# Determine which bulkhead should be set by the horizontal tail
#
Fuselage.TailBulk = Fuselage.Tail.BackBulk
Fuselage.TailBulk.WeightGroup = 'Fuselage'
if __name__ == '__main__':
import pylab as pyl
print 'Nose Weight :', AsUnit(Fuselage.Nose.Weight, 'lbf')
print 'PyldBay Weight :', AsUnit(Fuselage.PyldBay.Weight, 'ozf')
print 'TailTaper Weight :', AsUnit(Fuselage.Tail.Weight, 'lbf')
print 'Fuselage Weight :', AsUnit(Fuselage.Weight, 'lbf')
print 'Fuselage MOI :', AsUnit(Fuselage.MOI(), 'slug*ft**2')
print 'Fuselage CG :', AsUnit(Fuselage.CG(), 'in')
print 'Fuselage Desired CG:', AsUnit(Fuselage.AircraftCG(), 'in')
Fuselage.Draw()
pyl.show()
Built[i] = 1.75 * IN
else:
Built[i] = 1.75 * IN * (1 - yy) + 0.6 * IN * yy
I = BM * H[i] / 2 / Sm
W[i] = I / (2. * (h**3 / 12 + h * (H[i] / 2 - h / 2)**2))
pyl.figure(20)
pyl.ylim([0, 3.0])
pyl.plot(y / IN, H / IN)
pyl.plot(y / IN, Built / IN)
pyl.plot(y / IN, W / IN)
pyl.xlabel('Wing Semi Span (in)')
pyl.ylabel('Spar Height/Width (in)')
pyl.legend(['Spar Height', 'Spar Width', 'Required Width'])
#pyl.ylim([0, 0.8])
Density = 490 * KG / M**3 * gacc
print "Maximum moment : ", AsUnit(Moment[0], 'lbf*in')
print "Required Spar Height : ", AsUnit(H, 'in')
print "Required Spar Width : ", AsUnit(W, 'in')
print "Weight : ", AsUnit(Density * W * H * Aircraft.Wing.b,
'ozf')
#print "Moment : ", AsUnit(3500*LBF*6*FT, 'lbf*ft')
print "Load : ", AsUnit(Moment[0] / (105 * IN / 2), 'lbf')
#print "Load : ", AsUnit( Moment[0]/(2*FT), 'lbf')
pyl.show()
Motor.Imax = 55 * A
Motor.ThrustUnit = LBF
Motor.ThrustUnitName = 'lbf'
Motor.xRm = 100000
Motor.Pz = 0.0
Motor.Weight = 465 * GRAM * gacc
Motor.LenDi = [46.8 * MM, 59.98 * MM]
#
# This data has been corrected for standard day
#
# RPM, Torque Current Voltage
TestData = [(5500 * RPM, 7 * IN * OZF, 9 * A, 6.4 * V)
] #this is actual test data from a test stand
Motor.TestData = TestData
if __name__ == '__main__':
import pylab as pyl
print "V to Motor : ", AsUnit(Motor.Vmotor(Ib=3.75 * A), 'V')
print "Efficiency : ", Motor.Efficiency(Ib=3.75 * A)
print "Max efficiency : ", Motor.Effmax()
print "Max efficiency current : ", AsUnit(Motor.I_Effmax(), 'A')
print "Max efficiency RPM : ", AsUnit(Motor.N_Effmax(), 'rpm')
Motor.PlotTestData()
pyl.show()
STD2 = STDCorrection(30.10 * inHg, (12.7 + 273.15) * K)
Prop.ThrustData = [
(4250 * RPM, 209.2 * OZF * STD), (4250 * RPM, 195.2 * OZF * STD)
] # this point taken after initial points on Hacker A50. Used to verify good data.
Arm = 19.5 * IN * STD
Arm2 = 19.5 * IN * STD2 # Took torque data in closet with known prop to observe difference between temp
Prop.TorqueData = None
#==============================================================================#
# VISUALIZATION & RESULTS
#==============================================================================#
if __name__ == '__main__':
print " D : ", AsUnit(Prop.D, 'in')
print " Pitch : ", AsUnit(Prop.Pitch, 'in')
Vmax = 50
h = 0 * FT
N = npy.linspace(1000, 6800, 5) * RPM
Alpha = npy.linspace(-25, 25, 41) * ARCDEG
V = npy.linspace(0, Vmax, 30) * FT / SEC
Prop.CoefPlot(Alpha, fig=1)
Prop.PTPlot(N, V, h, 'V', fig=2)
# N = npy.linspace(0, 13000,31)*RPM
# V = npy.linspace(0,Vmax,5)*FT/SEC
NoseGear.WheelDiam = 4 * IN
NoseGear.Strut.Weight = .3 * LBF #math.pi*(0.125/2*IN)**2*8*IN*Steel.ForceDensity #1/8 inch diameter steel, l=8in
NoseGear.Strut.WeightGroup = "LandingGear"
NoseGear.Wheel.Weight = .16 * LBF
NoseGear.Wheel.WeightGroup = "LandingGear"
NoseGear.Strut.Weight = 0.2 * LBF #math.pi*(0.125/2*IN)**2*8*IN*Steel.ForceDensity #1/8 inch diameter steel, l=8in
NoseGear.Strut.WeightGroup = "LandingGear"
NoseGear.Wheel.Weight = 0.1 * LBF
NoseGear.Wheel.WeightGroup = "LandingGear"
if __name__ == '__main__':
print
print 'Aircraft V_LO :', AsUnit(Aircraft.GetV_LO(), 'ft/s')
print 'Wing V_LO :', AsUnit(Aircraft.Wing.GetV_LO(), 'ft/s')
print
H = max(Aircraft.Wing.Upper(0 * IN), Aircraft.VTail.Tip()[2])
W = Aircraft.Wing.b
L = Aircraft.TotalLengths - W - H
print 'V max climb : ', AsUnit(Aircraft.V_max_climb(), 'ft/s')
print 'V max : ', AsUnit(Aircraft.Vmax(), 'ft/s')
print 'Ground Roll : ', AsUnit(Aircraft.Groundroll(), 'ft')
print 'Total Weight : ', AsUnit(Aircraft.TotalWeight, 'lbf')
print 'Payload Weight : ', AsUnit(Aircraft.PayloadWeight(), 'lbf')
print 'Wing Height : ', AsUnit(Aircraft.Wing.Upper(0 * IN), 'in')
print 'Vertical Tail H : ', AsUnit(Aircraft.VTail.Tip()[2], 'in')
print 'Width : ', AsUnit(W, 'in')
print 'Length : ', AsUnit(L, 'in')
vtail.TR = 0.7
vtail.Symmetric = True
vtail.Axis = (0, 1)
vtail.L = 51.572 * IN
vtail.SweepFc = 0.6 #Set the sweep to zero about the rudder hinge
vtail.FullWing = True
vtail.X = [10 * IN, 10 * IN, 10 * IN]
vtail.Symmetric = True
rud = vtail.AddControl('rud')
rud.Fb = 1.
rud.Fc = 0.4
rud.Ft = 0.
print AsUnit(htail.S, "m**2")
print 'Htail span: ', htail.b, 'area', AsUnit(
htail.S, "in**2"), 'rChord', htail.Chord(0 * IN)
print 'VTail span: ', vtail.b, 'area', AsUnit(
vtail.S, "in**2"), 'rChord', vtail.Chord(0 * IN)
del_c = 0 * ARCDEG
alpha2dw = 5 * ARCDEG
print 'Horizontal Tail angle', htail.Alpha2DHTail(alpha2dw,
del_c,
iht=0. * ARCDEG)
print 'Horizontal Tail Cl', htail.CL(alpha2dw, del_c)
print 'Horizontal Tail DW', AsUnit(htail.DownWash(alpha2dw, del_c), "deg")
print 'Horizontal Tail Re', htail.Re()
htail.Draw2DAirfoilPolars(2)
#VTail.Rudder.Fc = 0.5
#VTail.Rudder.Weight = 0.05*LBF * 2 # * 2 For symmetric vertical tail
#VTail.Rudder.SgnDup = -1.0
#VTail.Rudder.Servo.Fc = 0.3
#VTail.Rudder.Servo.Fbc = 0.1
#VTail.Rudder.Servo.Weight = 5*GRAM*gacc
#VTail.Rudder.Servo.Weight = 0.58 * OZF
#VTail.Rudder.Servo.Torque = 42*IN*OZM
#Set the sweep about the rudder hinge
#VTail.SweepFc = 1.0 - VTail.Rudder.Fc
if __name__ == '__main__':
# print 'Aircraft V_LO : ', AsUnit( Aircraft.GetV_LO(), 'ft/s')
# print 'Wing V_LO : ', AsUnit( Aircraft.Wing.GetV_LO(), 'ft/s')
# print 'Wing Area : ', AsUnit( Aircraft.Wing.S, 'in**2')
print 'Ground Roll Distance: ', AsUnit(Aircraft.Groundroll(), 'ft')
# print 'HTail Area : ', AsUnit( Aircraft.HTail.S, 'in**2')
# print 'HTail VC : ', AsUnit( Aircraft.HTail.VC)
# print 'HTail Span : ', AsUnit( Aircraft.HTail.b, 'in')
#
Aircraft.WriteAVLAircraft('AVL\AVLAircraft100.avl')
#
Aircraft.Draw()
#
# Aircraft.PlotPolarsSlopes(fig=2)
# Aircraft.PlotCMPolars(3, (-10*ARCDEG, -5*ARCDEG, 0*ARCDEG, +5*ARCDEG, +10 * ARCDEG), XcgOffsets=(+0.02, -0.02))
# HTail.Draw2DAirfoilPolars(fig=4)
# Aircraft.PlotCLCMComponents(fig = 5, del_es = (-10*ARCDEG, -5*ARCDEG, 0*ARCDEG, +5*ARCDEG, +10 * ARCDEG))
#
pyl.show()
Engine.PistonSpeedR = 38.27 * FT / SEC
Engine.BMEPR = 50.038 * LBF / IN**2
Engine.Rnmt = 0.01
Engine.Rtmt = 1.5
Engine.MEPtlmt = 10.1526 * LBF / IN**2
Engine.SFCmt = 1 * PSFC
Engine.Rnsfc = 0.8
Engine.A_F = 16
Engine.PS = 1
Engine.LWH = [3 * IN, 2 * IN, 2 * IN]
Engine.Xat = [1, 0.5, 0.5]
Engine.Weight = 1.5 * LBF
# Set Propulsion properties
Propulsion = ACPropulsion(Prop, Engine)
Propulsion.Alt = 0 * FT
Propulsion.Vmax = 100 * FT / SEC
Propulsion.nV = 20
print 'Propulsion Weight :', AsUnit(Propulsion.Weight, "lbf")
V1 = npy.array([0, 50]) * FT / SEC
V2 = npy.linspace(0, 100, 11) * FT / SEC
N = npy.linspace(1000, 17000, 17) * RPM
Propulsion.PlotTPvsN(N, V1, 1)
#Propulsion.PlotMatched(V2, 2)
Propulsion.PlotFuelFlow(V2, 3)
Propulsion.Draw(fig=4)
pyl.show()
Nm = pp.RPMMatch(V)
Ib = pp.Engine.Ib(Nm)/A
pyl.figure(2)
pyl.subplot(221)
pyl.plot(V/(FT/SEC), Ib)
pyl.xlabel('V (ft/s)'); pyl.ylabel('Current (A)')
pyl.subplot(222)
pyl.plot(V/(FT/SEC), pp.Engine.Duration(N=Nm)/MIN)
pyl.xlabel('V (ft/s)'); pyl.ylabel('Duration (min)')
pyl.subplot(223)
pyl.plot(V/(FT/SEC), pp.Engine.Pin(Nm)/W)
pyl.xlabel('V (ft/s)'); pyl.ylabel('Power In (watt)')
pyl.subplot(224)
pyl.plot(V/(FT/SEC), pp.Engine.Efficiency(Nm))
pyl.xlabel('V (ft/s)'); pyl.ylabel('Efficiency (%)')
print pp.Engine.name, ' : ', AsUnit( pp.Weight, 'lbf' )
pyl.figure(1)
pyl.subplot(223)
pyl.legend(legend, loc='best')
pyl.figure(2)
pyl.subplot(221)
pyl.legend(legend, loc='best')
pyl.title( Propulsion[-1].Engine.name + ', ' + Propulsion[-1].Prop.name )
pyl.show()
def PlotTPvsN(self, N, V, fig=1):
"""
Plots the power of the propeller and engine and the propeller thrust
Inputs:
N - A list of RPMs
V - A list of velocities
fig - Figure number
"""
Engine = self.Engine
h = self.Alt
pyl.figure(fig)
Pb = self.Engine.Pb(h, N)
Pb = Pb / Engine.PowerUnit
Nplt = N / RPM
legend1 = []
legend2 = []
V = self.MakeList(V)
for v in V:
Pp = self.Prop.P(N, v, h)
Tp = self.Prop.T(N, v, h)
Pp = Pp / Engine.PowerUnit
Tp = Tp / Engine.ThrustUnit
Vplt = AsUnit(v, "ft/s", "%3.0f")
pyl.subplot(121)
pyl.plot(Nplt, Pp)
legend1.append('Prop Power Req. ' + Vplt)
pyl.subplot(122)
pyl.plot(Nplt, Tp)
legend2.append(Vplt)
pyl.subplot(121)
pyl.plot(Nplt, Pb, 'b')
legend1.append('Engine Power Provided')
pyl.xlabel('RPM')
pyl.ylabel('Power (' + Engine.PowerUnitName + ')')
pyl.legend(legend1, loc='best')
pyl.subplot(122)
pyl.xlabel('RPM')
pyl.ylabel('Propeller Thrust (' + Engine.ThrustUnitName + ')')
pyl.legend(legend2, loc='best')
pyl.annotate("Power and Propeller Thrust",
xy=(.025, .975),
xycoords='figure fraction',
horizontalalignment='left',
verticalalignment='top',
fontsize=20)
import pylab as pyl
import numpy as npy
#
# Set-up AVL Controls Run
#
Controls = ACControls(Aircraft)
Controls.RunDir = 'AVLControls/'
Controls.AddRun('Stab', 'AVLAircraft.avl', WriteAVLInput = True)
Controls.Stab.DumpStability('AVLDeriv.txt')
Controls.Stab.Exit()
Controls.ExecuteAVL()
Controls.ReadAVLFiles()
Controls.Ixx = 0.314*SLUG*FT**2
Controls.Iyy = 0.414*SLUG*FT**2
Controls.Izz = 0.570*SLUG*FT**2
Controls.Weight = 7.4*LBF
Deriv = Controls.Deriv[0]
Deriv.StabilityTable(fig=1)
print "\n Aircraft MOI: ",Aircraft.MOI()
print 'Steady state roll rate: ', AsUnit( Deriv.RollDueToAileron(20 * ARCDEG, 'Aileron'), 'deg/s' )
Aircraft.Draw(2)
pyl.show()
def PlotMatched(self,
V,
N,
Vprop,
fig=1,
ylimits=[None, None, None, None],
PlotProp=True):
"""
Plots the matched RPM, Power and Thrust for a range of velocities
Inputs:
V - A list of velocities at which to match the RPMs
N - A list of PRM values for the engine/propeller power match
Vprop - A list of velocities for plotting propeller power usage
fig - Figure number
ylimits - Y axis ranges for each plot [ (ymin1, ymax1), (ymin2, ymax2), (ymin3, ymax3)]
thrust_unit - Unit on the thrust
"""
Engine = self.Engine
Nbp = self.RPMMatch(V)
Tbp = self.T(V)
Pbp = self.P(V)
V = V / (FT / SEC)
Nbp = Nbp / RPM
Tbp = Tbp / Engine.ThrustUnit
Pbp = Pbp / Engine.PowerUnit
pyl.figure(fig)
pyl.subplot(222)
pyl.plot(V, Nbp)
pyl.grid(b=True)
pyl.xlabel('Aircraft Velocity (ft/sec)')
pyl.ylabel('Matched RPM')
if ylimits[1] is not None:
pyl.ylim(ylimits[0])
# else:
# pyl.ylim( (0, max(Nbp)*1.1) )
pyl.subplot(223)
pyl.plot(V, Tbp)
pyl.grid(b=True)
pyl.xlabel('Aircraft Velocity (ft/sec)')
pyl.ylabel('Thrust at matched RPM (' + Engine.ThrustUnitName + ')')
if ylimits[2] is not None:
pyl.ylim(ylimits[1])
# else:
# pyl.ylim( (0, max(Tbp)*1.1) )
pyl.subplot(224)
pyl.plot(V, Pbp)
pyl.grid(b=True)
pyl.xlabel('Aircraft Velocity (ft/sec)')
pyl.ylabel('Power at matched RPM (' + Engine.PowerUnitName + ')')
if ylimits[3] is not None:
pyl.ylim(ylimits[2])
# else:
# pyl.ylim( (0, max(Pbp)*1.1) )
legend = ['Engine']
Vprop = self.MakeList(Vprop)
h = self.Alt
Nplt = N / RPM
Pb = self.Engine.Pb(h, N)
Pb = Pb / Engine.PowerUnit
ax = pyl.subplot(221)
ax.xaxis.get_major_formatter().set_powerlimits((-3, 3))
pyl.plot(Nplt, Pb)
pyl.grid(b=True)
pyl.xlabel('RPM')
pyl.ylabel('Power (' + Engine.PowerUnitName + ')')
if ylimits[3] is not None:
ymax = ylimits[2]
else:
ymax = max(max(Pb) * 1.5, pyl.ylim()[1])
if PlotProp:
for v in Vprop:
Pp = self.Prop.P(N, v, h)
Pp = Pp / Engine.PowerUnit
Vplt = AsUnit(v, "ft/s", "%3.0f")
pyl.subplot(221)
pyl.plot(Nplt, Pp)
legend.append('Prop ' + Vplt)
legend_fontsize = pyl.rcParams['legend.fontsize']
pyl.rcParams.update({'legend.fontsize': 10})
if PlotProp:
pyl.legend(legend, loc='upper left')
pyl.ylim(ymin=0, ymax=ymax)
# pyl.annotate("Matched RPM, Thrust and Power", xy=(.025, .975),
# xycoords='figure fraction',
# horizontalalignment='left', verticalalignment='top',
# fontsize=20)
pyl.annotate(self.Engine.name + ", " + self.Prop.name,
xy=(.025, .975),
xycoords='figure fraction',
horizontalalignment='left',
verticalalignment='top',
fontsize=20)
pyl.rcParams.update({'legend.fontsize': legend_fontsize})
Aircraft.PlotTailLoad(fig=1)
Deriv.StabilityTable(fig=2)
Deriv.PlotStability(fig=3)
t = npy.linspace(0, 2) * SEC
#Deriv.PlotPitchResponseDueToElevator(10 * ARCDEG, t, 'Elevator', fig = 4)
Deriv.ControlsTables(fig=5)
Aircraft.Draw(6)
Ma = Deriv.Ma()
Mq = Deriv.Mq()
Madot = Deriv.Madot()
print
print 'AIRCRAFT PROPERTIES'
print 'Lift of AoA : ', AsUnit(Aircraft.GetAlphaFus_LO(), 'deg')
print 'Zero CM AoA : ', AsUnit(Aircraft.Alpha_Zero_CM, 'deg')
print
print 'AIRCRAFT DIMENSIONS'
Length = max(Aircraft.HTail.X[0]+(0.75*Aircraft.HTail.Chord(0*IN)),\
Aircraft.VTail.X[0]+(0.75*Aircraft.VTail.Chord(0*IN)))
Width = Aircraft.Wing.b
Height = Aircraft.VTail.Tip()[2]
print 'Length: ', AsUnit(Length, 'in')
print 'Width : ', AsUnit(Width, 'in')
print 'Height: ', AsUnit(Height, 'in')
print 'TOTAL : ', AsUnit(Length + Height + Width, 'in')
print
print '----- Horiz Tail -----'
print 'HTail VC : ', AsUnit(Aircraft.HTail.VC)
print 'HTail AR : ', Aircraft.HTail.AR
BWRibMat = Balsa.copy()
BWRibMat.Thickness = .25 * IN
Wing.WingWeight.RibMat = BWRibMat
Wing.WingWeight.RibSpace = 6 * IN
#Wing.SetWeightCalc(ACSolidWing)
#Wing.WingWeight.SparMat.LinearForceDensity = 0.0051*LBF/IN
#Wing.WingWeight.SkinMat = Monokote.copy()
#Wing.WingWeight.WingMat = PinkFoam.copy()
#Wing.WingWeight.WingMat.ForceDensity *= 0.5
if __name__ == '__main__':
import pylab as pyl
print "V lift off : ", AsUnit(Wing.GetV_LO(), 'ft/s')
print "V stall : ", AsUnit(Wing.V_Stall, 'ft/s')
print "Wing Area : ", AsUnit(Wing.S, 'in**2')
print "Wing Span : ", AsUnit(Wing.b, 'ft')
print "Wing AR : ", Wing.AR
print "Wing MAC : ", AsUnit(Wing.MAC(), 'in')
print "Wing Xac : ", Wing.Xac()
print "Wing dCM_da : ", Wing.dCM_da()
print "Wing dCL_da : ", Wing.dCL_da()
print "Lift of Load: ", AsUnit(Wing.Lift_LO, 'lbf')
print "Wing Thickness: ", AsUnit(Wing.Thickness(0 * FT), 'in')
print "Wing Chord : ", AsUnit(Wing.Chord(0 * FT), 'in')
print "Wing Area : ", AsUnit(Wing.S, 'in**2')
print "Wing Lift : ", Wing.Lift_LO
print
(4050 * RPM, 48 * OZF * STD), (3570 * RPM, 34 * OZF * STD)]
STD2 = STDCorrection(29.90 * inHg, (24 + 273.15) * K)
Arm = 19.5 * IN * STD2
Prop.TorqueData = [(5910 * RPM, (4.8 * Arm * OZF)),
(5520 * RPM, (4.1 * Arm * OZF)),
(5040 * RPM, (3.25 * Arm * OZF)),
(4470 * RPM, (2.56 * Arm * OZF)),
(3960 * RPM, (1.9 * Arm * OZF)),
(3480 * RPM, (1.5 * Arm * OZF))]
################################################################################
if __name__ == '__main__':
print " D : ", AsUnit(Prop.D, 'in')
print " Pitch : ", AsUnit(Prop.Pitch, 'in')
Vmax = 50
h = 0 * FT
N = npy.linspace(1000, 6800, 5) * RPM
Alpha = npy.linspace(-25, 25, 41) * ARCDEG
V = npy.linspace(0, Vmax, 30) * FT / SEC
Prop.CoefPlot(Alpha, fig=1)
Prop.PTPlot(N, V, h, 'V', fig=2)
#
# N = npy.linspace(0, 13000,31)*RPM
# V = npy.linspace(0,Vmax,5)*FT/SEC
TestData = [(7000 * RPM, 107.35 * IN * OZF, 0.75 * HP),
(8500 * RPM, 104.24 * IN * OZF, 0.88 * HP),
(9500 * RPM, 101.13 * IN * OZF, 0.95 * HP),
(9700 * RPM, 98.02 * IN * OZF, 0.94 * HP),
(10600 * RPM, 102.69 * IN * OZF, 1.08 * HP),
(10800 * RPM, 98.02 * IN * OZF, 1.05 * HP),
(11000 * RPM, 101.13 * IN * OZF, 1.1 * HP),
(11200 * RPM, 99.57 * IN * OZF, 1.11 * HP),
(11600 * RPM, 98.02 * IN * OZF, 1.13 * HP),
(12900 * RPM, 93.35 * IN * OZF, 1.19 * HP),
(13300 * RPM, 91.79 * IN * OZF, 1.21 * HP),
(13600 * RPM, 91.79 * IN * OZF, 1.24 * HP),
(14600 * RPM, 88.68 * IN * OZF, 1.28 * HP),
(15600 * RPM, 79.35 * IN * OZF, 1.23 * HP),
(16300 * RPM, 77.76 * IN * OZF, 1.26 * HP)]
Engine.TestData = TestData
Engine.PlotTestData()
print "Static Thrust :", AsUnit(Propulsion.T(0 * FT / SEC), 'lbf')
V = npy.linspace(0, 100, 30) * FT / SEC
N = npy.linspace(1000, 20000, 30) * RPM
#Propulsion.PlotMatched(V, fig = 2)
V2 = npy.linspace(0, 100, 5) * FT / SEC
Propulsion.PlotTPvsN(N, V2, fig=3)
Propulsion.Draw(fig=4)
pyl.show()
