def test_deterministic_scheduler_with_one_conflict(self):
Config.params["scheduler"]["name"] = "deterministic_scheduler"
a1 = Aircraft("A1", None, self.g1, State.stop)
a3 = Aircraft("A3", None, self.g2, State.stop)
# Create mock objects, then schedule it
simulation = self.SimulationMock(
a1, a3, self.g1, self.g2, self.s1, self.runway_start)
scheduler = get_scheduler()
schedule, priority = scheduler.schedule(simulation)
self.assertEqual(len(schedule.itineraries), 2)
# a3 has an early departure time, so it goes first
self.assertTrue(self.a1 in schedule.itineraries)
self.assertTrue(self.a3 in schedule.itineraries)
# Gets itineraries
iti1 = schedule.itineraries[self.a1]
iti2 = schedule.itineraries[self.a3]
self.assertEqual(iti1.targets[1].nodes[0], self.g1)
self.assertEqual(iti1.targets[1].nodes[1], self.s1)
self.assertEqual(iti1.targets[2].nodes[0], self.s1)
self.assertEqual(iti1.targets[2].nodes[1], self.runway_start)
self.assertEqual(iti2.targets[2].nodes[0], self.g2)
self.assertEqual(iti2.targets[2].nodes[1], self.s1)
self.assertEqual(iti2.targets[3].nodes[0], self.s1)
self.assertEqual(iti2.targets[3].nodes[1], self.runway_start)
def test_conflicts(self):
simulation = self.SimulationMock()
airport = Airport.create("simple")
a1 = Aircraft("A1", None, self.n1, State.stop)
a2 = Aircraft("A2", None, self.n1, State.stop)
a3 = Aircraft("A3", None, self.n2, State.stop)
airport.aircrafts.append(a1)
airport.aircrafts.append(a2)
airport.aircrafts.append(a3)
# Get only one conflict
self.assertEqual(len(airport.conflicts), 1)
# Test if the conflict looks like what we expected
conflict = airport.conflicts[0]
self.assertTrue(conflict.locations[0] == self.n1)
self.assertEqual(len(conflict.aircrafts), 2)
self.assertTrue(a1 in conflict.aircrafts)
self.assertTrue(a2 in conflict.aircrafts)
# Add one far aircraft to the same spot
a4 = Aircraft("A4", None, self.n1, State.stop)
airport.aircrafts.append(a4)
# Test if the third aircraft shown in conflict correctly
self.assertEqual(len(airport.conflicts), 3)
def get_all_aircraft(self) -> [Aircraft]:
"""
Returns list of all aircraft scanner has seen regardless of whether it
has received all Aircraft information (such as tail number or Flight #)
:return: List of Airfract seen by the receiver
"""
_raw_aircraft_data = self._query(self._scanner_aircraft_path)
# List of attributes from aircraft JSON. Is there a better way?
_response_keys = [
'hex',
'flight',
'squawk',
'lat',
'lon',
'alt_geom', #altitude
'geom_rate',
'track',
'gs',
'seen' ,
]
known_aircarft = []
_parameters = {}
# To-Do: n^2, need something better instead of brute force,
# (Replace with generator? )
for i in _raw_aircraft_data['aircraft']:
for k in _response_keys:
try:
_parameters.update({k : i[k]})
except KeyError: # Data was not picked up by reciever
pass
known_aircarft.append(Aircraft(**_parameters))
_parameters = {}
return known_aircarft
def test_tick(self):
itinerary = deepcopy(self.itinerary_template)
aircraft = Aircraft("F1", "M1", self.n1, State.stop)
aircraft.set_location(self.n1)
self.assertEqual(aircraft.state, State.stop)
# Stop state
aircraft.tick()
self.assertEqual(aircraft.itinerary, None)
# Moving state
aircraft.set_itinerary(itinerary)
self.assertTrue(aircraft.itinerary)
self.assertEqual(aircraft.state, State.moving)
self.assertEqual(aircraft.itinerary.current_target, self.n1)
aircraft.tick()
self.assertEqual(aircraft.itinerary.current_target, self.n2)
aircraft.tick()
self.assertEqual(aircraft.itinerary.current_target, self.n3)
aircraft.tick()
self.assertTrue(aircraft.itinerary.is_completed)
def __init__(self, callsign, model, to_airport, from_gate, runway,
departure_time, appear_time):
super().__init__(Aircraft(callsign, model, None, State.stop))
self.to_airport = to_airport
self.from_gate = from_gate
self.departure_time = departure_time
self.appear_time = appear_time
def __init__(self, callsign, model, from_airport, to_gate, runway,
arrival_time, appear_time):
super().__init__(Aircraft(callsign, model, None, State.flying))
self.from_airport = from_airport
self.to_gate = to_gate
self.arrival_time = arrival_time
self.appear_time = appear_time
def connect_to(self, comm_port):
aircraft = Aircraft(comm_port)
# wait for the heartbeat msg to find the system ID
print("Waiting for APM heartbeat from aircraft %s" % comm_port)
aircraft.wait_heartbeat()
print("I saw a heartbeat, now I am going to acknowledge I have seen the aircraft")
aircraft.send_ack()
print("Waiting for APM home location from aircraft %s" % comm_port)
aircraft.wait_set_home_location()
self.aircrafts[comm_port] = aircraft
def _update_aircraft(cls, msg: Message) -> None:
for craft in cls.aircraft:
if craft == msg.icao:
craft.update(msg.data)
break
else:
cls.aircraft.insert(0, Aircraft(msg.icao, msg.data))
if len(cls.aircraft) > 100:
cls.aircraft = cls.aircraft[25:]
def eachAircraft():
groundstation = Groundstation()
aircraft_seen = {}
conn = sqlite3.connect('flightevents.db')
nmea = open('data.nmea', 'r')
for line in nmea:
try:
commas = line.count(',')
sentence = pynmea2.parse(line, check=True)
except pynmea2.ChecksumError:
# ignore sentences that produce a checksum error
continue
except pynmea2.ParseError:
# ignore sentences that can't be parsed
continue
# ignore Flarm PFLAU sentences
if Observation.is_pflau_sentence(sentence):
continue
# The groundstation must have received the UTC time from the GPS
# before we permit any processing of Flarm PFLAA observations.
if (groundstation.valid_time()
and Observation.is_pflaa_sentence(sentence)):
observation = Observation()
if observation.set(conn, groundstation, sentence):
aircraft_id = observation.get_aircraft_id()
if aircraft_id not in aircraft_seen:
aircraft_seen[aircraft_id] = Aircraft(aircraft_id)
aircraft_seen[aircraft_id].append_observations(observation)
elif sentence.sentence_type == 'RMC':
# this sentence contains the current date
groundstation.set_date(sentence.datestamp)
groundstation.set(sentence)
elif (sentence.sentence_type == 'GGA' and groundstation.valid_date()
and commas == 14):
# this sentence has the groundstation timestamp, lat, lon, elevation
groundstation.set(sentence)
conn.commit()
conn.close()
print("%s" % list(aircraft_seen.keys()))
groundstation.report()
return
def load_data(filename):
aircraft_dict = {}
with open(os.path.join("", "clean_files", filename),
"rt",
encoding="utf8") as f:
reader = csv.reader(f)
for row in reader:
aircraft_code = row[0]
# remove cr
aircraft_dict[aircraft_code] =\
Aircraft(row[0], row[1], row[2], row[3], row[4])
return aircraft_dict
def __init__(self, conf):
self.conf = conf
self.aircraft = Aircraft()
self.flight_phase = FlightPhase(self.aircraft)
self.flight = Flight()
self.time = 0
self.sample_rate = 1 # Hz
self.recording = False
self.flush_interval_sec = 10
self.flush_time = 0
self.flight_data = []
def game_Runner():
pygame.init() # Initialize
game_settings = Setting()
screen = pygame.display.set_mode(
(game_settings.screen_width, game_settings.screen_height))
pygame.display.set_caption("Aircraft Game")
# create an aircraft
aircraft = Aircraft(game_settings, screen)
missiles = Group()
# loop of processing
while True:
function.check_events(game_settings, screen, aircraft, missiles)
aircraft.update()
missiles.update()
function.update_screen(game_settings, screen, aircraft, missiles)
def test_tick_with_delay(self):
itinerary = deepcopy(self.itinerary_template)
aircraft = Aircraft("F1", "M1", self.n1, State.stop)
aircraft.set_location(self.n1)
self.assertEqual(aircraft.state, State.stop)
# Stop state
aircraft.tick()
self.assertEqual(aircraft.itinerary, None)
# Moving state
aircraft.set_itinerary(itinerary)
self.assertTrue(aircraft.itinerary)
self.assertEqual(aircraft.state, State.moving)
self.assertEqual(aircraft.itinerary.current_target, self.n1)
# targets: n1 - n2 - n3
aircraft.add_uncertainty_delay()
# targets: n1 - n1 - n2 - n3
aircraft.tick()
# targets: n1 - n2 - n3
self.assertEqual(aircraft.itinerary.current_target, self.n1)
aircraft.add_uncertainty_delay()
# targets: n1 - n1 - n2 - n3
self.assertEqual(aircraft.itinerary.current_target, self.n1)
aircraft.tick()
# targets: n1 - n2 - n3
self.assertEqual(aircraft.itinerary.current_target, self.n1)
aircraft.tick()
# targets: n2 - n3
self.assertEqual(aircraft.itinerary.current_target, self.n2)
def __init__(self, path, fromdate=None):
self.flex_start = 0
self.flex_end = 0
date_regexp = re.compile(r'\d{1,2}/\d{1,2}/\d{4}\s\d{1,2}:\d{1,2}')
self.aclist = []
import pandas as pd
df = pd.read_csv(path, sep=',', header=0)
df["ACTUAL_ARRIVAL_DT"] = pandas.to_datetime(df["ACTUAL_ARRIVAL_DT"],
dayfirst=True)
df["ACTUAL_DEPARTURE_DT"] = pandas.to_datetime(
df["ACTUAL_DEPARTURE_DT"], dayfirst=True)
arr = df.sort_values(by="ACTUAL_DEPARTURE_DT")
for row in arr.values:
if 'XXX' in row[7:8]:
continue
if row[3] == row[4]:
continue
if fromdate is not None:
if row[3].value // 10**9 < datetime.datetime.strptime(
fromdate, "%d/%m/%Y").timestamp():
continue
self.aclist.append(
Aircraft(row[8],
row[7],
row[3].value // 10**9,
row[4].value // 10**9,
debug=False,
flight_type_code=row[9]))
if self.flex_start == 0:
self.flex_start = row[3].value // 10**9
self.flex_end = row[4].value // 10**9
else:
if row[3].value // 10**9 < self.flex_start:
self.flex_start = row[3].value // 10**9
if row[4].value // 10**9 > self.flex_end:
self.flex_end = row[4].value // 10**9
def create_sensor(num, delta, air):
"""Creating Random Sensors with position -12,000 <= x, y <= 12000"""
sensors = []
for i in range(num):
x = randrange(-12000, 12000)
y = randrange(-12000, 12000)
pos = np.array([x, y]).reshape((2, 1))
sensors.append(Sensor(50, 20, 0.2, delta, pos, air))
return sensors
if __name__ == "__main__":
T = 420 # number of framess
# set up objects
air = Aircraft(300, 9, 0)
# set up figure and subplots
font = {'size': 9}
matplotlib.rc('font', **font)
fig = figure(num=0, figsize=(16, 9))
fig.suptitle("ground truth generator", fontsize=12)
gs1 = gridspec.GridSpec(3, 3)
gs1.update(left=0.05, right=0.48, wspace=0.05)
ax1 = plt.subplot(gs1[:3, :])
gs2 = gridspec.GridSpec(3, 3)
gs2.update(left=0.55, right=0.98, hspace=0.5)
ax2 = plt.subplot(gs2[1, :2])
ax3 = plt.subplot(gs2[2, :])
ax4 = plt.subplot(gs2[0, :2])
def __init__(self):
"""Start up aircraft."""
self.aircraft = Aircraft()
def initialize_aircraft(self):
for ac_data in c.data['aircraft']:
aircraft_obj = Aircraft(ac_data)
self.aircraft_list.append(aircraft_obj)
aircraft_obj.handler = FgmsHandler(aircraft_obj)
import numpy as np from aircraft import Aircraft from atmosphere import Atmosphere, Wind from constants import Constants import sim_setup from Planes.B737 import B737 from Planes.C172 import C172 from Planes.T38 import T38 # Initialization of objects used in overall sim architecture SIM = sim_setup.Sim_Parameters() CONSTANTS = Constants() Atmosphere = Atmosphere() plane1 = Aircraft() #################################################################################################### # BEGIN INPUT FIELDS #################################################################################################### # Modify simulation parameters SIM.START_TIME = 0.0 SIM.END_TIME = 2000.0 SIM.DELTA_T = 2 # Modify aircraft inital conditions # Choose airplane type - B737, C172, T38 plane1.design = B737()
def test_init(self):
aircraft = Aircraft("F1", "M1", self.n1, State.unknown)
aircraft.set_location(self.n1)
self.assertEqual(aircraft.location, self.n1)
def __init__(self, logger):
"""
Initialize and create a new HUD.
"""
self.__last_perf_render__ = None
self.__logger__ = logger
self.__view_element_timers = {}
self.__fps__ = RollingStats('FPS')
self.__texture_cache_size__ = RollingStats('TextureCacheSize')
self.__texture_cache_misses__ = RollingStats('TextureCacheMisses')
self.__texture_cache_purges__ = RollingStats('TextureCachePurges')
self.render_perf = TaskTimer('Render')
self.frame_setup = TaskTimer('Setup')
self.frame_cleanup = TaskTimer('Cleanup')
self.__frame_timers__ = {
'Setup': self.frame_setup,
'Render': self.render_perf,
'Cleanup': self.frame_cleanup
}
self.cache_perf = TaskTimer('Cache')
self.__fps__.push(0)
adsb_traffic_address = "ws://{0}/traffic".format(
CONFIGURATION.stratux_address())
self.__connection_manager__ = traffic.ConnectionManager(
adsb_traffic_address)
self.__backpage_framebuffer__, screen_size = display.display_init(
) # args.debug)
self.__width__, self.__height__ = screen_size
pygame.mouse.set_visible(False)
pygame.font.init()
self.__should_render_perf__ = False
font_size_std = int(self.__height__ / 10.0)
font_size_detail = int(self.__height__ / 12.0)
font_size_loading = int(self.__height__ / 4.0)
self.__font__ = pygame.font.Font(
get_absolute_file_path("./assets/fonts/LiberationMono-Bold.ttf"),
font_size_std)
self.__detail_font__ = pygame.font.Font(
get_absolute_file_path("./assets/fonts/LiberationMono-Bold.ttf"),
font_size_detail)
self.__loading_font__ = pygame.font.Font(
get_absolute_file_path(
"./assets/fonts/LiberationMono-Regular.ttf"),
font_size_loading)
self.__show_boot_screen__()
self.__aircraft__ = Aircraft(self.__logger__)
self.__pixels_per_degree_y__ = int(
(self.__height__ / CONFIGURATION.get_degrees_of_pitch()) *
CONFIGURATION.get_pitch_degrees_display_scaler())
self.__ahrs_not_available_element__ = self.__build_ahrs_hud_element(
ahrs_not_available.AhrsNotAvailable)
self.__hud_views__ = self.__build_hud_views()
self.__view_index__ = 0
logger = None
if self.__logger__ is not None:
logger = self.__logger__.logger
self.web_server = restful_host.HudServer()
RecurringTask("rest_host",
0.1,
self.web_server.run,
start_immediate=False)
RecurringTask("purge_old_traffic",
10.0,
self.__purge_old_reports__,
start_immediate=False)
RecurringTask("update_traffic",
0.1,
self.__update_traffic_reports__,
start_immediate=True)
RecurringTask("update_aithre",
5.0,
self.__update_aithre__,
start_immediate=True)
def __init__(self, logger):
"""
Initialize and create a new HUD.
"""
self.__logger__ = logger
self.render_perf = TaskTimer("Render")
self.orient_perf = TaskTimer("Orient")
adsb_traffic_address = "ws://{0}/traffic".format(
CONFIGURATION.stratux_address())
self.__connection_manager__ = traffic.ConnectionManager(
adsb_traffic_address)
self.__backpage_framebuffer__, screen_size = display.display_init(
) # args.debug)
self.__width__, self.__height__ = screen_size
pygame.mouse.set_visible(False)
pygame.font.init()
self.__should_render_perf__ = False
font_name = "consolas,monaco,courier,arial,helvetica"
font_size_std = int(self.__height__ / 10.0)
font_size_detail = int(self.__height__ / 12.0)
font_size_loading = int(self.__height__ / 4.0)
self.__font__ = pygame.font.Font(
get_absolute_file_path("./assets/fonts/LiberationMono-Bold.ttf"),
font_size_std)
self.__detail_font__ = pygame.font.Font(
get_absolute_file_path("./assets/fonts/LiberationMono-Bold.ttf"),
font_size_detail)
self.__loading_font__ = pygame.font.SysFont(font_name,
font_size_loading, True,
False)
self.__show_boot_screen__()
self.__aircraft__ = Aircraft()
self.__pixels_per_degree_y__ = (
self.__height__ / HeadsUpDisplay.DEGREES_OF_PITCH
) * HeadsUpDisplay.PITCH_DEGREES_DISPLAY_SCALER
self.__ahrs_not_available_element__ = self.__build_ahrs_hud_element(
ahrs_not_available.AhrsNotAvailable)
bottom_compass_element = self.__build_ahrs_hud_element(
compass_and_heading_bottom_element.CompassAndHeadingBottomElement,
True)
adsb_target_bug_element = adsb_target_bugs.AdsbTargetBugs(
HeadsUpDisplay.DEGREES_OF_PITCH, self.__pixels_per_degree_y__,
self.__font__, (self.__width__, self.__height__))
adsb_onscreen_reticle_element = adsb_on_screen_reticles.AdsbOnScreenReticles(
HeadsUpDisplay.DEGREES_OF_PITCH, self.__pixels_per_degree_y__,
self.__font__, (self.__width__, self.__height__))
altitude_element = self.__build_ahrs_hud_element(
altitude.Altitude, True)
time_element = self.__build_ahrs_hud_element(time.Time, True)
system_info_element = self.__build_ahrs_hud_element(
system_info.SystemInfo, False)
groundspeed_element = self.__build_ahrs_hud_element(
groundspeed.Groundspeed, True)
traffic_only_view = [
bottom_compass_element, adsb_target_bug_element,
adsb_onscreen_reticle_element
]
system_info_view = [system_info_element]
traffic_listing_view = [
adsb_traffic_listing.AdsbTrafficListing(
HeadsUpDisplay.DEGREES_OF_PITCH, self.__pixels_per_degree_y__,
self.__detail_font__, (self.__width__, self.__height__))
]
# norden_view = [
# bottom_compass_element,
# heading_target_bugs.HeadingTargetBugs(HeadsUpDisplay.DEGREES_OF_PITCH, self.__pixels_per_degree_y__, self.__detail_font__,
# (self.__width__, self.__height__)),
# # Draw the ground speed and altitude last so they
# # will appear "on top".
# self.__build_ahrs_hud_element(target_count.TargetCount, True),
# groundspeed_element,
# altitude_element
# ]
ahrs_view = [
self.__build_ahrs_hud_element(level_reference.LevelReference,
True),
self.__build_ahrs_hud_element(artificial_horizon.ArtificialHorizon,
True), bottom_compass_element,
altitude_element,
self.__build_ahrs_hud_element(skid_and_gs.SkidAndGs, True),
self.__build_ahrs_hud_element(roll_indicator.RollIndicator,
True), groundspeed_element
]
time_view = [time_element]
self.__hud_views__ = [
("Traffic", traffic_only_view),
("AHRS", ahrs_view),
("ADSB List", traffic_listing_view),
# ("Norden", norden_view),
("Time", time_view),
("System Info", system_info_view),
("", [])
]
self.__view_index__ = 0
logger = None
if self.__logger__ is not None:
logger = self.__logger__.logger
m += 1
return heading_differences
######################Scenario###############################################
target_1 = Target("target_1", 1, 100, 370,
100) #(name, location, speed, heading, power)
target_2 = Target("target_2", 5, 100, 900, 100)
target_3 = Target("target_3", 9, 100, 90, 100)
target_4 = Target("target_4", 4, 100, 270, 100)
print("number of targets is: ", Target.number_of_targets)
print("number of targets is: ", Target.number_of_targets, file=f)
aircraft_1 = Aircraft("aircraft_1", 365, 100, 10000,
0) #(name, heading, speed, altitude, ownship_location)
target_list = Target.target_list
#target_list = [target_1, target_2, target_3, target_4]
#print(target_list, file = f)
target_names = [o.name for o in target_list]
target_locations = [o.location for o in target_list]
target_powers = [o.power for o in target_list]
target_speeds = [o.speed for o in target_list]
target_headings = [o.heading for o in target_list]
beam_width = 5.0
half_power_beam_width = beam_width / 2
gps = GPS()
compass = Compass()
threads["compass"] = threading.Thread(target=compass.track_ahrs,
args=(),
daemon=True)
threads["compass"].start()
display = Display(gps, compass)
# Blocks until the GPS is ready
display.start()
os.nice(15)
ac = Aircraft(gps)
threads["aircraft"] = threading.Thread(target=ac.track_aircraft,
args=(),
daemon=True)
threads["aircraft"].start()
gdl90 = GDL90(gps, ac, compass)
threads["gdl90"] = threading.Thread(target=gdl90.transmit_gdl90,
args=(),
daemon=True)
threads["gdl90"].start()
startup_tasks()
delay = 20
while True:
def create_aircraft(self):
self.aircraft = Aircraft()
# vehicles, policy = policies('Scenarios/policy.txt')
allowed_ports = ['WP52','WP555','WP322']
second_tower = ['WP802','WP989','WP778']
third_tower = ['WP94','WP661','WP9']
launch_points = ['WP98','WP880','WP14']
verts.findTower_ind(allowed_ports[2]).towerSchedules('Scenarios/test_medium19.csv',allowed_ports)
verts.findTower_ind(second_tower[2]).towerSchedules('Scenarios/test_medium40_csv.csv',second_tower)
verts.findTower_ind(third_tower[2]).towerSchedules('Scenarios/test_medium40_csv.csv',third_tower)
vehicles, time_policy = schedules('Scenarios/scn_UAM_testW.trp')
vehicle_array = []
vehicle_queue = []
i = 0
if time_policy:
pass
else:
for v_i in vehicles:
track = verts.convertTrack(policy[v_i])
vehicle_array[v_i] = Aircraft(loc=tuple(verts.array[policy[v_i][0][0]].loc_gps)+(100,), POV_center=SF_GPS,col=(0,1,0),ax=ax,track=track,track_col=my_palette(i),verts=verts)
i+=1
#
# for i in range(500):
# update(i)
ani = FuncAnimation(fig, update, frames=500, interval=0.02, blit=True,repeat=False)
# ani = FuncAnimation(fig, update, frames=1000,repeat=False)
ani.save('Pass_through_allocation_Any.mp4',writer = writer)
plt.show(block=True)
# plt.show(block=True)
def eachAircraft(infile):
groundstation = Groundstation()
aircraft_seen = {}
conn = sqlite3.connect('flightevents.db')
nmea = open(infile, 'r')
for line in nmea:
try:
commas = line.count(',')
sentence = pynmea2.parse(line, check=True)
except pynmea2.ChecksumError:
# ignore sentences that produce a checksum error
continue
except pynmea2.ParseError:
# ignore sentences that can't be parsed
continue
# ignore Flarm PFLAU sentences
if Observation.is_pflau_sentence(sentence):
continue
# The groundstation must have received the UTC time from the GPS
# before we permit any processing of Flarm PFLAA observations.
if (groundstation.valid_time()
and Observation.is_pflaa_sentence(sentence)):
observation = Observation()
if observation.set(conn, groundstation, sentence):
aircraft_id = observation.get_aircraft_id()
if aircraft_id not in aircraft_seen:
aircraft_seen[aircraft_id] = Aircraft(aircraft_id)
aircraft_seen[aircraft_id].append_observations(observation)
elif sentence.sentence_type == 'RMC':
# this sentence contains the current date
groundstation.set_date(sentence.datestamp)
groundstation.set(sentence)
elif (sentence.sentence_type == 'GGA' and groundstation.valid_date()
and commas == 14):
# this sentence has the groundstation timestamp, lat, lon, elevation
groundstation.set(sentence)
conn.close()
print("%s" % list(aircraft_seen.keys()))
groundstation.report()
# reg = "C-GFOP"
# print("")
# print(reg)
# aircraft_seen[reg].printObservations()
print("")
print("FLIGHTS PER AIRCRAFT")
print("====================")
for aircraft in list(aircraft_seen.keys()):
print("")
print(aircraft)
aircraft_seen[aircraft].detect_events()
aircraft_seen[aircraft].report_events()
flight_sheet = []
for aircraft in list(aircraft_seen.keys()):
reg = aircraft_seen[aircraft].get_aircraft_id()
the_events = aircraft_seen[aircraft].events
for event in the_events:
if isinstance(event, TakeoffEvent):
launch_event = LaunchEvent(reg, event.getTimestamp(),
event.getLat(), event.getLon(),
event.getAltitudeAGL(),
event.getTrack(), event.speed)
flight_sheet.append(launch_event)
flight_sheet.sort()
print("")
print("Flight Sheet")
print("============")
item_num = 1
# we work with pairs, so starting at the second takeoff and looking at
# the first...
for ndx in range(1, len(flight_sheet)):
previous = flight_sheet[ndx - 1].getTimestamp()
current = flight_sheet[ndx].getTimestamp()
if ndx < len(flight_sheet) - 1:
nxt = flight_sheet[ndx + 1].getTimestamp()
else:
nxt = Event.event_not_detected
# are the current and previous takeoff within 30 seconds?
if (previous - datetime.timedelta(seconds=30) < current <
previous + datetime.timedelta(seconds=30)):
# this is a takeoff pair
print("%02d" % item_num, "Launch ", current,
"R%02d" % flight_sheet[ndx].getRwy(),
flight_sheet[ndx].getReg(), flight_sheet[ndx - 1].getReg())
item_num += 1
# the pair is not a match. what about the upcoming pair?
elif nxt - datetime.timedelta(
seconds=30) < current < nxt + datetime.timedelta(seconds=30):
# do nothing. the next iteration of the loop will process the pair
pass
else:
# this is a lone takeoff event
print("%02d" % item_num, "Takeoff", current,
"R%02d" % flight_sheet[ndx].getRwy(),
flight_sheet[ndx].getReg())
item_num += 1
return
tk.Button(buttonFrame, text='Confirm',
command=self.updatePlane).pack(side=tk.LEFT,
fill=tk.X,
expand=tk.YES)
tk.Button(buttonFrame, text='Cancel',
command=self.window.destroy).pack(side=tk.LEFT,
fill=tk.X,
expand=tk.YES)
buttonFrame.pack(side=tk.BOTTOM, fill=tk.X, expand=tk.NO)
def __getImage(self):
try:
maxsize = (240, 240)
im = Image.open(
self.selectedPlane.image
) # opens the Aircraft.image to be passed PIL.ImageTk.PhotoImage, need this for jpg
im.thumbnail(maxsize,
Image.ANTIALIAS) # SCALE the image, not crop it
tkim = imgtk.PhotoImage(image=im)
pic = tk.Label(self.window, image=tkim)
pic.image = tkim # VERY IMPORTANT!! wont display picture otherwise
return pic
except FileNotFoundError:
return None
if __name__ == '__main__':
from aircraft import Aircraft, SelectedAircraft
aircraft = SelectedAircraft.from_base(
Aircraft('A319', 'jet', 'metric', 'Airbus', 3750))
AircraftConfigurationWindow(aircraft)
def update(i):
global prev_time, j, vehicle_queue, verts
dt = 0.2
print(i)
# loiter_dict = dict([[verts.findTower_ind(allowed_ports[2]), set()], [verts.findTower_ind(second_tower[2]), set()]])
land_s = False
# print(open_slots)
if time_policy:
t_i = i*dt
if time_policy.get(t_i):
# Usable cache of 8 aircraft
for v_i in time_policy[t_i]:
if len(verts.findTower_ind(time_policy[t_i][v_i][-1]).vehicle_array) < 8:
# in_track = time_policy[t_i][v_i] if time_policy[t_i][v_i][0] in launch_points else [np.random.choice(launch_points),time_policy[t_i][v_i][-1]]
in_track = [np.random.choice(launch_points),time_policy[t_i][v_i][-1]]
track = verts.convertTrack(in_track)
vehicle_array.append(Aircraft(loc=tuple(verts.array[in_track[0]].loc_gps)+(100,),POV_center=SF_GPS,col=(0,1,0),ax=ax,track=track,track_col=my_palette(j),land_tower=verts.findTower(in_track[-1]),land_wp=in_track[-1],verts=verts))
if len(vehicle_array[-1].scheduler_ind)> 0:vehicle_array[-1].loiter()
for s_k in vehicle_array[-1].scheduler_ind:
verts.towers[s_k].add_vehicle(vehicle_array[-1])
j += 1
else:
in_track = [np.random.choice(launch_points), time_policy[t_i][v_i][-1]]
track = verts.convertTrack(in_track)
vehicle_queue.append((v_i,tuple(verts.array[in_track[0]].loc_gps)+(100,),track,verts.findTower(in_track[-1]),in_track[-1],in_track[-1]))
else:
for v_i,v_q in enumerate(vehicle_queue):
if len(verts.findTower_ind(v_q[5]).vehicle_array) < 8:
v_q = vehicle_queue.pop(v_i)
vehicle_array.append(Aircraft(loc=v_q[1],POV_center=SF_GPS,col=(0,1,0),ax=ax,track=v_q[2],track_col=my_palette(j),land_tower=v_q[3],land_wp=v_q[4],verts=verts))
if len(vehicle_array[-1].scheduler_ind) > 0: vehicle_array[-1].loiter()
for s_k in vehicle_array[-1].scheduler_ind:
verts.towers[s_k].add_vehicle(vehicle_array[-1])
j += 1
artist_array = []
landed_drones = []
for t_a in verts.towers:
if t_a.allocating_flag:
# if t_i.avail_slots > 0:
t_a.queue_full = True
t_a.activeRequest()
# print("Avail Slots: {}".format(t_a.avail_slots))
# t_i.clearRequest()
land_signals = dict([[v_i,None] for v_i in vehicle_array])
## Allocate pass-throughs/landings
for t_ind,t_a in enumerate(verts.towers):
for ind,v_ind in enumerate(t_a.vehicle_array):
v_i = t_a.vehicle_array[v_ind]
if t_a.active_request:
if v_ind+1 in t_a.active_request['Allocate']:
v_i.pass_flag[t_ind] = True
# land_s = verts.array[v_i.land_wp].loc_xy # verts.array[t_i.landWaypoint(ind)].loc_xy ## TODO fix with pass-throughs
# print(land_s)
# land_signals[v_i] = land_s
for v_i in vehicle_array:
artist_array += v_i.simulate(dt, land_signal=land_signals[v_i])
if v_i.kill:
landed_drones.append(v_i)
# Remove landing drones
for v_i in landed_drones:
for t_a in v_i.scheduler_ind:
if v_i in verts.towers[t_a].vehicle_array.values():
verts.towers[t_a].remove_vehicle(v_i)
verts.towers[t_a].requestLanded()
vehicle_array.remove(v_i)
## Add vehicles to towers if not in
for v_i in vehicle_array:
for t_a in v_i.scheduler_ind:
if v_i not in verts.towers[t_a].vehicle_array.values():
verts.towers[t_a].add_vehicle(v_i)
for t_ind,t_a in enumerate(verts.towers):
pass_vehicles = []
for v_i in t_a.vehicle_array:
if verts.insideTower(t_a.vehicle_array[v_i].loc[0:2])[t_ind] == 0:
pass_vehicles.append(t_a.vehicle_array[v_i])
for v_i in pass_vehicles:
t_a.remove_vehicle(v_i)
t_a.requestLanded()
for t_a in verts.towers:
out_art = t_a.towerUpdate()
if out_art: artist_array.append(out_art)
# f = open('loiter_log.txt',"a")
# f.write(str(i) + "|\t")
# for l_i in loiter_dict:
# f.write(str(loiter_dict[l_i])+", "+str(l_i.avail_slots)+", "+str(l_i.no_active)+"|\t")
# f.write("\n")
prev_time = i
return artist_array
class TestScheduler(unittest.TestCase):
Config.params["simulator"]["test_mode"] = True
Config.params["simulation"]["time_unit"] = 30
# (G1)
# |
# | <3647.9 ft, 12.2 mins>
# |
# (S1)-----<2456.7 ft, 8:11 mins>-----(RANWAY.start)
# |
# | <3647.9 ft, 12.2 mins>
# |
# (G2)
g1 = Node("G1", {"lat": 47.812000, "lng": -122.079057})
g2 = Node("G2", {"lat": 47.832000, "lng": -122.079057})
s1 = Spot("S1", {"lat": 47.822000, "lng": -122.079057})
runway_start = RunwayNode({"lat": 47.822000, "lng": -122.069057})
a1 = Aircraft("A1", None, g1, State.stop)
a2 = Aircraft("A2", None, g2, State.stop)
a3 = Aircraft("A3", None, g2, State.stop)
a4 = Aircraft("A4", None, s1, State.stop)
a5 = Aircraft("A5", None, s1, State.stop)
class AirportMock():
def __init__(self, simulation, aircraft1, aircraft2):
self.aircrafts = [aircraft1, aircraft2]
self.aircraft1 = aircraft1
self.aircraft2 = aircraft2
def apply_schedule(self, schedule):
for aircraft, itinerary in schedule.itineraries.items():
if aircraft == self.aircraft1:
self.aircraft1.set_itinerary(itinerary)
else:
self.aircraft2.set_itinerary(itinerary)
def set_quiet(self, logger):
self.aircraft1.logger = logger
self.aircraft2.logger = logger
def tick(self):
self.aircraft1.tick()
self.aircraft2.tick()
@property
def conflicts(self):
if self.aircraft1.location == self.aircraft2.location:
return [Conflict(None, [self.aircraft1, self.aircraft2])]
return []
@property
def next_conflicts(self):
if self.aircraft1.itinerary is None or\
self.aircraft2.itinerary is None:
return []
if self.aircraft1.itinerary.next_target is None or\
self.aircraft2.itinerary.next_target is None:
return []
if self.aircraft1.itinerary.next_target == \
self.aircraft2.itinerary.next_target:
return [Conflict(None, [self.aircraft1, self.aircraft2])]
return []
class RunwayMock():
def __init__(self, runway_start):
self.runway_start = runway_start
@property
def start(self):
return self.runway_start
class ScenarioMock():
def __init__(self, g1, g2, s1, runway_start):
self.runway = TestScheduler.RunwayMock(runway_start)
self.g1, self.g2, self.s1 = g1, g2, s1
def get_flight(self, aircraft):
if aircraft.callsign == "A1":
return DepartureFlight(
"A1", None, None, self.g1, self.s1, self.runway,
time(2, 36), time(2, 36)
)
elif aircraft.callsign == "A2":
return DepartureFlight(
"A2", None, None, self.g2, self.s1, self.runway,
time(2, 36, 30), time(2, 36, 30)
)
elif aircraft.callsign == "A3":
return DepartureFlight(
"A3", None, None, self.g2, self.s1, self.runway,
time(2, 36, 1), time(2, 36, 1)
)
elif aircraft.callsign == "A4":
return DepartureFlight(
"A4", None, None, self.g2, self.s1, self.runway,
time(2, 36, 1), time(2, 36, 1)
)
elif aircraft.callsign == "A5":
return DepartureFlight(
"A5", None, None, self.g2, self.s1, self.runway,
time(2, 36, 2), time(2, 36, 2)
)
class RouteMock():
def __init__(self, nodes):
self.nodes = nodes
class RoutingExpertMock():
def __init__(self, g1, g2, s1, runway_start):
self.g1, self.g2, self.s1 = g1, g2, s1
self.runway_start = runway_start
def get_shortest_route(self, src, dst):
if src == self.g1 and dst == self.runway_start:
return TestScheduler.RouteMock([self.g1, self.s1,
self.runway_start])
if src == self.g2 and dst == self.runway_start:
return TestScheduler.RouteMock([self.g2, self.s1,
self.runway_start])
if src == self.s1 and dst == self.runway_start:
return TestScheduler.RouteMock([self.s1, self.runway_start])
else:
raise Exception("Unsupported routing query")
class SimulationMock():
def __init__(self, a1, a2, g1, g2, s1, runway_start):
self.airport = TestScheduler.AirportMock(self, a1, a2)
self.scenario = TestScheduler.ScenarioMock(
g1, g2, s1, runway_start)
self.routing_expert = TestScheduler.RoutingExpertMock(
g1, g2, s1, runway_start)
self.clock = Clock()
self.clock.now = time(2, 30)
def set_quiet(self, logger):
self.airport.set_quiet(logger)
def remove_aircrafts(self):
pass
def pre_tick(self):
pass
def tick(self):
self.clock.tick()
self.airport.tick()
def post_tick(self):
pass
@property
def now(self):
return self.clock.now
@property
def copy(self):
s = deepcopy(self)
s.set_quiet(logging.getLogger("QUIET_MODE"))
return s
def test_deterministic_scheduler_with_one_conflict(self):
Config.params["scheduler"]["name"] = "deterministic_scheduler"
# Create mock objects, then schedule it
simulation = self.SimulationMock(
self.a1, self.a3, self.g1, self.g2, self.s1, self.runway_start)
scheduler = get_scheduler()
schedule = scheduler.schedule(simulation)
self.assertEqual(len(schedule.itineraries), 2)
# a3 has an early departure time, so it goes first
self.assertTrue(self.a1 in schedule.itineraries)
self.assertTrue(self.a3 in schedule.itineraries)
# Gets itineraries
iti1 = schedule.itineraries[self.a1]
iti2 = schedule.itineraries[self.a3]
self.assertEqual(iti1.targets[0], self.g1)
self.assertEqual(iti1.targets[1], self.s1)
self.assertEqual(iti1.targets[2], self.runway_start)
self.assertEqual(iti2.targets[0], self.g2)
self.assertEqual(iti2.targets[1], self.g2)
self.assertEqual(iti2.targets[2], self.s1)
self.assertEqual(iti2.targets[3], self.runway_start)
def test_deterministic_scheduler_with_one_unsolvable_conflict(self):
# Sets two aircraft standing at the same node
self.a4.location = self.s1
self.a5.location = self.s1
# Create mock objects, then schedule it
simulation = self.SimulationMock(
self.a4, self.a5, self.g1, self.g2, self.s1, self.runway_start)
scheduler = get_scheduler()
schedule = scheduler.schedule(simulation)
self.assertEqual(len(schedule.itineraries), 2)
# a3 has an early departure time, so it goes first
self.assertTrue(self.a4 in schedule.itineraries)
self.assertTrue(self.a5 in schedule.itineraries)
# Gets itineraries
iti1 = schedule.itineraries[self.a4]
iti2 = schedule.itineraries[self.a5]
self.assertEqual(schedule.n_unsolvable_conflicts, 0)
self.assertEqual(iti1.targets[0], self.s1)
self.assertEqual(iti1.targets[1], self.runway_start)
self.assertEqual(iti2.targets[0], self.s1)
self.assertEqual(iti2.targets[1], self.s1)
self.assertEqual(iti2.targets[2], self.runway_start)
geometry.add(BodyGeometry(
name='fuselage',
fuselage_aspect_ratio=10.,
))
geometry.add(PartGeometry(
name='balance',
parasite_drag_coeff=0.006,
))
#
analyses = Analyses()
aerodynamics = Aerodynamics()
analyses.add(aerodynamics)
#
aircraft = Aircraft(
geometry=geometry,
analyses=analyses,
aircraft_type='transport',
)
prob = Problem()
comp = IndepVarComp()
comp.add_output('speed', val=250., lower=200., upper = 300.) # units='m/s' , val=250.
comp.add_output('altitude', val=7., lower=4., upper = 14.)# units = 'km' , val=7
comp.add_output('ref_mac', val=7., lower=4., upper = 14.) # , val=7.
comp.add_output('alpha', val=3. * np.pi / 180., lower=0.* np.pi / 180., upper = 5.* np.pi / 180.)# , val=3. * np.pi / 180.
comp.add_output('ref_area', val=427.8,lower=200., upper = 800.) # , val=427.8
comp.add_output('empty_weight_fraction',val=0.5,lower=0.45, upper =0.55)
comp.add_design_var('speed', lower=200., upper = 300.) # units='m/s' , val=250.
comp.add_design_var('altitude',lower=4., upper = 14.)# units = 'km' , val=7
