def __init__(self):
deque.__init__(self)
self.currentTime = 0
self.nextAvailable = 0
self.lastPlane = Aircraft('nil', 0, 0, 0, 0)
self.totalFuelBurned = 0
self.totalDelayCost = 0
def main():
Aircraft.load_aircrafts()
route = ['DUB','LHR','SYD','JFK','AAL']
valid_aircraft = 'A330'
test_itin = Itinerary(route,valid_aircraft)
print(test_itin)
invalid_aircaft = '£££'
test_itin2 = Itinerary(route,invalid_aircaft)
print(test_itin2)
def create_groups(self):
is_play1 = False
is_play2 = False
for air in gl.aircraft_group.sprites():
if air.play.index == 0:
is_play1 = True
elif air.play.index == 1:
is_play2 = True
if self.aircraft_time == 0 or self.clock_ticks - self.aircraft_time > 4000:
if is_play1 is False and self.play1.play > 0:
self.aircraft_time = self.clock_ticks
Aircraft((gl.all_group, gl.aircraft_group), self, self.play1)
self.aircraft_start.play(0, 0, 0)
if self.meteorite_time == 0 or self.clock_ticks - self.meteorite_time > 100:
m_count = len(gl.meteorite_group.sprites())
if m_count < self.meteorites_count:
self.meteorite_time = self.clock_ticks
Meteorite((gl.all_group, gl.meteorite_group), self)
if self.reward_time == 0 or self.clock_ticks - self.reward_time > 100:
r_count = len(gl.reward_group.sprites())
if r_count < self.reward_count:
self.reward_time = self.clock_ticks
rtype = random.randint(0, 1)
if rtype == 1:
Reward((gl.all_group, gl.reward_group, gl.s_reward_group),
self, random.randint(0, 5))
else:
Reward((gl.all_group, gl.reward_group, gl.p_reward_group),
self, random.randint(6, 9))
class TakeOffQueue(deque):
def __init__(self):
deque.__init__(self)
self.currentTime = 0
self.nextAvailable = 0
self.lastPlane = Aircraft('nil', 0, 0, 0, 0)
self.totalFuelBurned = 0
self.totalDelayCost = 0
def print(self):
print("next available " + str(self.nextAvailable))
for plane in self:
plane.printAircraft()
print("\n")
# depart aircraft if available, otherwise update time
def update(self, newTime):
self.currentTime = newTime
self.nextAvailable = max(self.nextAvailable, self.currentTime)
if len(self) > 0 and self.nextAvailable <= self.currentTime:
self.lastPlane = self.popleft()
res = self.lastPlane.depart(self.nextAvailable, self)
self.nextAvailable = self.nextAvailable + self.lastPlane.delayToOthers
return res + self.update(newTime)
return 0, 0
# insert new plane into queue at appropriate index
def insertIntoTakeoffQueue(self, plane):
res = self.update(plane.arrivalTime)
self.insert(plane.findIndex(self), plane)
return res
def __init__(self):
self.data = pd.read_excel('data/fleet.xlsx', index_col=0, usecols='A:D')
self.amount = {}
self.aircraftList = {}
for i in self.data.columns:
fl = self.data[i]
self.amount[i] = fl['Fleet']
self.aircraftList[i] = Aircraft(i, fl['Speed'], fl['Cargo capacity'], fl['Average TAT'], fl['Maximum Range'], fl['Runway Required'], fl['Lease Cost'], fl['Fixed Operating Cost'], fl['Cost per Hour'], fl['Fuel Cost Parameter'])
def test():
print(
"-------------------------------------Testing AC----------------------------------"
)
x0 = [0.0, 0.0, 0.0]
vel0 = [1.0, 2.0, 3.0]
euler0 = [0.1, 0.2, 0.3]
ang_vel0 = [0.1, 0.2, 0.3]
initial_parameters = [x0, vel0, euler0, ang_vel0]
ac = Aircraft(initial_parameters, Tsc=0.01, RK4=False)
forces = [1, 1, 1]
forces = [0, 0, 0]
moments = [0, 0, 0]
print(ac.RK4)
print(ac.vel, ac.ang_vel)
print(ac.DotAngVel_get())
ac.update_onestep(forces, moments)
print(ac.vel, ac.ang_vel)
def loadData(self, csvFile):
try:
with open(csvFile) as csvFile:
reader = csv.DictReader(csvFile)
try:
for row in reader:
self._aircraftDict[row['code']] = Aircraft(
row['type'], row['units'], row['manufacturer'],
row['range'])
except Exception:
pass
except FileNotFoundError:
return ('CSV file not found!')
sys.exit(1)
def setup():
aircraftList = []
os.chdir(
r'C:/Users/zblue/Documents/Fall 2017/Algorithms for Nonlinear Optimization/'
)
unMergeExcelCell('AircraftInfo_final.xls')
workbook = xlrd.open_workbook('AircraftInfo_temp2_unmerged.xls',
formatting_info=True)
sheet = workbook.sheet_by_index(0)
row_idx = 1
while row_idx < sheet.nrows:
name = sheet.cell(row_idx, 0).value + ' '
if type(sheet.cell(row_idx, 1).value) is str:
name += sheet.cell(row_idx, 1).value
else:
name += str(int(sheet.cell(row_idx, 1).value))
if not sheet.cell(row_idx, 2).value == '':
if type(sheet.cell(row_idx, 2).value) is str:
name += '-' + sheet.cell(row_idx, 2).value
else:
name += '-' + str(int(sheet.cell(row_idx, 2).value))
myACDict = {
'Light': AircraftType.TURBOPROP,
'Medium': AircraftType.NARROW,
'Heavy': AircraftType.HEAVY
}
acType = myACDict[sheet.cell(row_idx, 3).value]
inService = sheet.cell(row_idx, 4).value
if inService == '':
inService = 0
capacity = sheet.cell(row_idx, 5).value
if capacity == '':
capacity = 0
fuelBurn = sheet.cell(row_idx, 6).value
if fuelBurn == '':
fuelBurn = 0
aircraftList.append((Aircraft(name, acType, capacity, fuelBurn,
3), inService))
row_idx += 1
return aircraftList
def loadData(self, filename):
"""
gets the filename and loads all the information
about the Aircraft
**Parameters**\n
----------\n
filename: Aircraft data filename
"""
with open(filename, encoding="utf8") as file:
reader = csv.reader(file)
try:
for row in reader:
self.aircraftdict[row[0]] = Aircraft(
row[0], row[1], row[2], row[3], row[4])
except FileNotFoundError:
print("File not found")
# s1 = int(input('Enter y coordinate for the source: '))
# source_1 = [s0, s1]
# dest_1 = [d0, d1]
#
# d0_2 = int(input('Enter x coordinate for destination: '))
# d1_2 = int(input('Enter y coordinate for the destination: '))
# s0_2 = int(input('Enter x coordinate for the source: '))
# s1_2 = int(input('Enter y coordinate for the source: '))
# source_2 = [s0_2, s1_2]
# dest_2 = [d0_2, d1_2]
#
# A1 = Aircraft(dest_1, 0, source_1)
# A2 = Aircraft(dest_2, 0, source_2)
# Creating the instance of Aircrafts
A1 = Aircraft([1, 8], 0, [1, 2])
A2 = Aircraft([1, 2], 0, [1, 7])
# A1 = Aircraft([1, 5], 0, [1, 1])
# A2 = Aircraft([1, 5], 0, [1, 7])
# A1 = Aircraft([2,7], 0, [5, 4])
# A2 = Aircraft([5,6], 0, [8, 9])
#Creating the instance of controller
C1 = AircraftController()
C2 = AircraftController()
t1 = A1.isDestination()
t2 = A2.isDestination()
m1 = A1.Message()
m2 = A2.Message()
def add_aircraft(self, mode_s):
self.dict[mode_s] = Aircraft("", "", [], [], [], [], [], [], [], [])
#from os import environ as _environ; _environ["scalar_off"] = "off"
from scalar.units import ARCDEG, IN
from scalar.units import AsUnit
from Aircraft import Aircraft
# from Aircraft_Models.Reg2014Aircraft_AeroCats.TradeStudies.WeightTrade.Aircraft_NickSchwartz import Aircraft
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()
self.store_of_ammo = store_of_ammo
self.health_point = health_point
def addAircraft(self, aircraft):
self.list_of_aircraft.append(aircraft)
def fill(self):
for item in self.list_of_aircraft:
if item.getType() == "F35":
self.store_of_ammo = item.refill(self.store_of_ammo)
print(str(self.store_of_ammo))
def fight(self, Carrier):
carrier_max_dmg = 0
for item in self.list_of_aircraft:
carrier_max_dmg +=
carrier = Carrier(1000, 2000)
aircraft1 = Aircraft("F35")
carrier.addAircraft(aircraft1)
aircraft2 = Aircraft("F16")
carrier.addAircraft(aircraft2)
aircraft3 = Aircraft("F35")
carrier.addAircraft(aircraft3)
aircraft4 = Aircraft("F16")
carrier.addAircraft(aircraft4)
aircraft5 = Aircraft("F35")
carrier.addAircraft(aircraft5)
aircraft6 = Aircraft("F16")
carrier.addAircraft(aircraft6)
class testAircraftClass(unittest.TestCase):
"""Unit tests for Aircraft class"""
def setUp(self):
self.testAircraft1 = Aircraft("A330", "metric", "Airbus", 13430)
self.testAircraft2 = Aircraft("777", "imperial", "Boeing", 9700)
# Test to check if aircraft attributes are set up for metric units
def testMetricAttributes(self):
self.assertEqual(self.testAircraft1.planeType, "A330")
self.assertEqual(self.testAircraft1.manufacturer, "Airbus")
self.assertEqual(self.testAircraft1.range, 13430)
self.assertEqual(self.testAircraft1.MIN_FUEL, 1000)
self.assertEqual(self.testAircraft1.maxFuel, 13430)
# Test to check aircraft attributes are correct for imperial units
def testImperialAttributes(self):
self.assertEqual(self.testAircraft2.planeType, "777")
self.assertEqual(self.testAircraft2.manufacturer, "Boeing")
self.assertEqual(self.testAircraft2.range, 15607.3)
self.assertEqual(self.testAircraft2.MIN_FUEL, 1000)
self.assertEqual(self.testAircraft2.maxFuel, 15607.3)
# Test to check strings of Aircraft class
def testString(self):
self.assertEqual(str(self.testAircraft1), "Airbus A330")
self.assertEqual(str(self.testAircraft2), "Boeing 777")
# Test to check for invalid units given on aircraft setup
def testUnits(self):
testAircraft = Aircraft("A330", "bob", "Airbus", 13430)
self.assertEqual(testAircraft.range, 13430)
# Test to check for units given as wrong data type
def testUnitDataType(self):
testAircraft = Aircraft("A330", "metric", "Airbus", "abc")
self.assertEqual(testAircraft.range, 0)
testAircraft = Aircraft("A330", "metric", "Airbus", [12, 13])
self.assertEqual(testAircraft.range, 0)
testAircraft = Aircraft("A330", "metric", "Airbus", self.testAircraft2)
self.assertEqual(testAircraft.range, 0)
# Test to check adding amount of fuel less than maximum fuel level
def testAddLessFuel(self):
self.testAircraft1.addFuel(5000)
self.assertEqual(self.testAircraft1.getFuel(), 5000)
self.testAircraft1.addFuel(3000)
self.assertEqual(self.testAircraft1.getFuel(), 8000)
# Test to check adding amount of fuel greater than maximum fuel level
def testAddMoreFuel(self):
fuelOver = self.testAircraft1.addFuel(20000)
self.assertEqual(fuelOver, 6570)
# Test to check adding fuel less than zero
def testSyphonFuel(self):
self.testAircraft1.addFuel(-5000)
self.assertEqual(self.testAircraft1.getFuel(), 0)
# Test to check adding fuel where volume is of incorrect data type
def testAddFuelAsString(self):
self.testAircraft1.addFuel("abc") # Volume as string
self.assertEqual(self.testAircraft1.getFuel(), 0)
self.testAircraft1.addFuel([123, 345]) # Volume as list
self.assertEqual(self.testAircraft1.getFuel(), 0)
self.testAircraft1.addFuel((123, 345)) # Volume as tuple
self.assertEqual(self.testAircraft1.getFuel(), 0)
self.testAircraft1.addFuel(self.testAircraft2) # Volume as object
self.assertEqual(self.testAircraft1.getFuel(), 0)
# Test to check that aircraft can use fuel
def testUseFuel(self):
self.testAircraft1.addFuel(13000)
self.testAircraft1.useFuel(3000)
self.assertEqual(self.testAircraft1.getFuel(), 10000)
self.testAircraft1.useFuel(4500)
self.assertEqual(self.testAircraft1.getFuel(), 5500)
# Test to check using invalid amounts of fuel
def testUseInvalidFuel(self):
self.testAircraft1.addFuel(13000)
self.testAircraft1.useFuel(-3000) # Test negative amount of fuel
self.assertEqual(self.testAircraft1.getFuel(), 13000)
self.testAircraft1.useFuel("abc") # Test adding string value as fuel
self.assertEqual(self.testAircraft1.getFuel(), 13000)
self.testAircraft1.useFuel([123, 24]) # Test using list to add fuel
self.assertEqual(self.testAircraft1.getFuel(), 13000)
def setUp(self):
self.testAircraft1 = Aircraft("A330", "metric", "Airbus", 13430)
self.testAircraft2 = Aircraft("777", "imperial", "Boeing", 9700)
def __init__(self):
self.file.seek(0)
for Aircraft_line in self.file:
self.aircrafts.append(Aircraft.parse(Aircraft_line))
import pylab as pyl
from Aircraft import Aircraft
#
# This will generate a weight table of the entire aircraft
# The objects in the table are labeled based on their .name attribute
#
WeightTable = Aircraft.GetWeightTable()
#
# You can turn off sub categories of a part by setting Collapse = True
#
#WeightTable.Fuselage.Collapse = True
#WeightTable.Fuselage.Nose.Collapse = True
#
# You can give a specific order to the parts in the table
#
WeightTable.Wing.Order = 0
WeightTable.HTail.Order = 1
WeightTable.VTail.Order = 2
WeightTable.Fuselage.Order = 3
#
# This is how you change what it is sorted by. Options are
# 'Weight', 'CG' or 'Order' ('Weight' is default)
#
WeightTable.SortBy = 'Order'
#
# This will draw the plot table
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 create(self, capacity, registrationNo, types, name):
a = Aircraft(capacity, registrationNo, types, name)
self.aircrafts.append(a)
self.file.write(f"{str(a)}\n")
self.file.flush()
def check_aircraft_type(self,equipment): # check if aircraft type is valid
if Aircraft.check_aircraft_type(equipment) is not False:
return Aircraft(equipment) # if valid, create aircraft object
else:
return 'Invalid Aircraft Type'
def __init__(self):
self.maxAmmo = 8
self.base_damage = 30
self.type = "F16"
Aircraft.__init__(self)
import numpy as np np.errstate(divide='ignore') import matplotlib.pyplot as plt from math import sin from math import cos time_end = 350 dt = 0.05 t = 0 wingspan = 10 weight = 5 #State tuning: bxd, bx, bhd, bh, bVa b_i = np.array([.9, .2, .6, .2, .1]) myAircraft1 = Aircraft(wingspan, weight, b_i) myFlightPlan = FlightPlan() #State variables: pn, pe, Xid, Xi, hd, h, Va x = np.array([[0], [0], [0], [0], [0], [0], [0]]) #wind inputs : wn, we w = np.array([0, 0]) #State inputs: CourseDerivative, Course (rads), Altitude Derivative, Altitude, Airspeed u = np.array([0, .1, 0, 100, 12]) steps = int(time_end / dt) psi_array = np.zeros(steps) pn_array = np.zeros(steps) pe_array = np.zeros(steps) h_array = np.zeros(steps) u_h_array = np.zeros(steps)
from Airport import Airport
from Route import Route
from Aircraft import Aircraft
plane = Aircraft("737", 5600, "LHR", "imperial")
madrid = Airport("Madrid", 3.7038, 40.4168, 0.84)
london = Airport("London", 0.1278, 51.5074, 1.17)
moscow = Airport("Moscow", 37.618423, 55.7558, 0.5)
shanghai = Airport("Shanghai", 121.4737, 31.2304, 0.4)
paris = Airport("Paris", 2.3522, 48.864716, 1)
hk = Airport("Hong Kong", 114.149139, 22.286394, 0.3)
athens = Airport("Athens", 23.727539, 37.983810, 1)
la = Airport("Los Angeles", -118.243683, 34.052235, 1.5)
hawaii = Airport("Honolulu", -157.917480, 21.289373, 1.5)
NYC = Airport("New York", -73.935242, 40.730610, 1.5)
dublin = Airport("Dublin", -6.266155, 53.350140, 1)
# dublin = Airport("Dublin", )
print("plane range is ", plane.getRange())
print(Route.calculate_distance(hk, la))
# stops = {
# "Madrid": [london, dublin, madrid],
# "Dublin": [london, madrid, dublin],
# "London": [madrid, dublin, london]
# }
'''
Step 1:
Produce a dictionary with possibilities.
# return the price of the start_vertex to the home_vertex
return price_table[home_vertex]
else:
name_key = start_vertex + ":" + previous_vertex
current_price += price_table[name_key]
visited.append(name_key)
return min(
salesman(home_vertex, subset[0], start_vertex,
[x for x in subset if x != subset[0]], price_table,
current_price, visited),
salesman(home_vertex, subset[0], start_vertex,
[x for x in subset if x != subset[1]], price_table,
current_price, visited))
plane = Aircraft("737", 5600, "LHR", "imperial")
madrid = Airport("Madrid", 3.7038, 40.4168, 0.84)
london = Airport("London", 0.1278, 51.5074, 1.17)
dublin = Airport("Dublin", 6.2603, 53.3498, 1)
berlin = Airport("Berlin", 13.4050, 13.4050, 1.99)
print(madrid.getName())
our_graph = Graph()
plane = Aircraft("737", 5600, "LHR", "imperial")
airport_list = [madrid, london, dublin, berlin]
for airport in airport_list:
x = Vertex(airport.getName(), airport)
our_graph.add_vertex(x)
def create(self, capacity, registrationNo, types, name):
info = Aircraft(capacity, registrationNo, types, name)
self.aircraft.append(info)
self.file.write(f"{str(info)}\n")
self.file.flush()
from Aircraft import Aircraft # this runs without an error but doesn't give me the output I expected
jumbo = Aircraft("747")
print("About to start preparing a ", jumbo.planeType, " for takeoff")
jumbo.addFuel(30)
jumbo.printStatus()
jumbo.fuelCheck()
jumbo.fly(500)
airbus = Aircraft("A330")
print("About to start preparing a ", airbus.planeType, " for takeoff")
airbus.addFuel(2000)
airbus.printStatus()
airbus.fuelCheck()
airbus.fly(1000)
boeing = Aircraft("737")
print("About to start preparing a ", boeing.planeType, " for takeoff")
fuelInTruck = 50000
fuelInTruck = boeing.addFuel(fuelInTruck)
boeing.printStatus()
boeing.fuelCheck()
boeing.fly(5000)
print("Fuel Truck still has: ", fuelInTruck)
from Transport import Engine
from PassengerCar import PassengerCar
from Aircraft import Aircraft
from Ship import Ship
if __name__ == "__main__":
rb25 = Engine(3.0, 220, 6)
nissan = PassengerCar(1000, 500, 300, rb25)
airbus = Aircraft(10000, 2000, 4000)
ship = Ship(20000, 6000, 2000)
nissan.start()
nissan.tank_up(120)
nissan.start()
nissan.make_sound()
nissan.open_doors()
airbus.make_sound()
ship.make_sound()
@author: ozmatron
'''
from Costs import Costs
from Aircraft import Aircraft
from Shortest_path import Shortest_path
import csv
try:
with open('test.csv', newline='') as file:
reader = csv.reader(file)
for line in reader:
list = line
aircraft = list[5]
list = list[0:5]
range = Aircraft(aircraft).find_range()
costs_dict = Costs(list, range).find_costs()
the_path = Shortest_path(costs_dict, list).path_finder()
print(the_path)
if the_path != "Cannot make the distance, get a bigger plane":
output = []
x = 0
y = 3
while x < 34:
output.append(the_path[x:y])
x += 6
y += 6
output.append(the_path[x - 1:])
with open("bestroutes.csv", "a") as writing_file:
