def get_airports_from_icao_code(departure_airport_icao_code, destination_airport_icao_code):
with open_database_session() as session:
departure_airport = Airport.airport_from_icao_code(
session, departure_airport_icao_code)
destination_airport = Airport.airport_from_icao_code(
session, destination_airport_icao_code)
return departure_airport, destination_airport
def search_intersections_convection_cells(airport_tracking_list=None,
algorithm_name=None,
**kwargs):
global session
manager = IntersectionManager()
with open_database_session() as session:
all_convection_cells = ConvectionCell.all_convection_cells(session)
for departure_airport, destination_airport in (
_gen_departure_destination_airports(airport_tracking_list)):
# filter convection cells withing departure and destination airports
convection_cells = [
cell for cell in all_convection_cells
if cell.is_convection_cells_between_airports(
departure_airport, destination_airport)
]
# find intersections
intersections = _check_multiple_intersections(
departure_airport, destination_airport, convection_cells,
algorithm_name, **kwargs)
# workaround - set airports
manager.set_default_airports(departure_airport,
destination_airport)
# record results
for intersection in intersections:
manager.set_intersection(intersection)
return manager
def main():
def transform_to_portuguese(airport_name):
if airport_name.endswith('International Airport'):
return 'Aeroporto Internacional {}'.format(
airport_name.strip(' International Airport'))
if airport_name.endswith('Airport'):
return 'Aeroporto {}'.format(
airport_name.strip(' Airport'))
with open_database_session() as session:
airports = session.query(Airport).all()
airports_str = ', '.join(['{} ({})'.format(
transform_to_portuguese(a.name), a.icao_code) for a in airports])
print (airports_str)
print (len(airports))
print ('-' * 100)
flight_plans = session.query(FlightPlan).all()
counter = Counter()
for flight_plan in flight_plans:
company = flight_plan.callsign[:3]
counter[company] += 1
print (counter.most_common())
print (len(flight_plans))
def get_normalization_results(filepath, manager, min_entries_per_section):
with open_database_session() as session:
for departure_airport, destination_airport in manager:
count_flight_positions = sum(1
for flight_plan in (FlightPlan.
flight_plans_from_airports(session, departure_airport, destination_airport))
for flight_location in session.query(FlightLocation).join(Flight)
.filter(Flight.flight_plan == flight_plan))
# (# positions) - (# positions')
sections = Section.sections_from_airports(
departure_airport,
destination_airport,
min_entries_per_section=min_entries_per_section)
count_normalized_flight_positions = sum(
len(section) for section in sections)
# ratio: positions -> positions'
ratio = round(count_normalized_flight_positions / count_flight_positions, 3)
df = pd.DataFrame(
data={
'Posições de voo': [count_flight_positions],
'Posições de voo normalizadas': [count_normalized_flight_positions],
'Proporção': [ratio],
}
)
df.to_csv(path_or_buf=os.path.join(filepath, 'normalization.csv'), index=False)
def insert_airports_in_database(airports_dataframe):
with open_database_session() as session:
for _, airport_data in airports_dataframe.iterrows():
if check_valid_airport(airport_data):
airport = get_airport_from_airport_data(airport_data)
session.add(airport)
session.commit()
def insert_flight_plans_in_database(flight_plans):
with open_database_session() as session:
for i, flight_plan in enumerate(flight_plans):
q = session.query(FlightPlan).filter(
FlightPlan.callsign == flight_plan.callsign)
if (not session.query(literal(True))
.filter(q.exists()).scalar()):
session.add(flight_plan)
session.commit()
def plot_most_descriptive_flight_paths(filepath, departure_airport, destination_airport):
with open_database_session() as session:
top_flights = sorted([
flight
for flight_plan in (FlightPlan.
flight_plans_from_airports(session, departure_airport, destination_airport))
for flight in session.query(Flight).filter(Flight.flight_plan == flight_plan)],
key=lambda flight: len(flight.flight_locations),
reverse=True,
)[:10]
for flight in top_flights:
filename = build_filename_from_flight(flight)
plot_from_flight_locations(
filepath=os.path.join(filepath, filename + '.1.pdf'),
flight_locations=flight.flight_locations,
departure_airport=departure_airport,
destination_airport=destination_airport,
)
normalized_flight_locations = normalize_from_flight_locations(flight.flight_locations)
plot_from_flight_locations(
filepath=os.path.join(filepath, filename + '.2.norm.pdf'),
flight_locations=normalized_flight_locations,
departure_airport=departure_airport,
destination_airport=destination_airport,
)
plot_from_multiple_flight_locations(
filepath=os.path.join(filepath, filename + '.3.mult.pdf'),
multiple_flight_locations=[
flight.flight_locations,
normalized_flight_locations],
departure_airport=departure_airport,
destination_airport=destination_airport,
)
# plot flight path params
plot_flight_locations_params(
filepath=os.path.join(filepath, filename + '.4.params.pdf'),
flight_locations=flight.flight_locations,
)
normalized_flight_locations = normalize_from_flight_locations(flight.flight_locations)
plot_flight_locations_params(
filepath=os.path.join(filepath, filename + '.5.params.norm.pdf'),
flight_locations=normalized_flight_locations,
)
plot_multiple_flight_locations_params(
filepath=os.path.join(filepath, filename + '.6.params.mult.pdf'),
multiple_flight_locations=[
flight.flight_locations,
normalized_flight_locations],
)
def track_en_route_flights():
'''Keep track of ALL en-route flights'''
global session
address_to_flight = {}
count_iterations = 0
with open_database_session() as session:
while count_iterations < ITERATIONS_LIMIT_TO_SEARCH_FLIGHTS:
time.sleep(SLEEP_TIME_TO_GET_FLIGHT_IN_SECS)
if _should_update_flight_addresses(count_iterations):
addresses = _get_addresses_within_brazilian_airspace()
_update_flights(address_to_flight, addresses)
count_iterations += 1
def track_convection_cells():
'''Keep track of ALL convection cells'''
global session
client = STSC()
count_iterations = 0
prev_cells = set()
with open_database_session() as session:
while count_iterations < ITERATIONS_LIMIT_TO_SEARCH_CONVECTION_CELLS:
time.sleep(SLEEP_TIME_TO_GET_CONVECTION_CELLS_IN_SECS)
if client.has_changed:
curr_cells = client.cells
save_convection_cells(new_cells=curr_cells - prev_cells)
prev_cells = curr_cells
count_iterations += 1
def sections_from_airports(departure_airport, destination_airport,
**kwargs):
'''Return sections from flight locations'''
min_entries_per_section = kwargs.get('min_entries_per_section',
NUMBER_ENTRIES_PER_SECTION)
key = (
departure_airport.icao_code,
destination_airport.icao_code,
min_entries_per_section,
)
if key not in Section.cache:
with open_database_session() as session:
flight_locations = normalizer.normalize_from_airports(
session, departure_airport, destination_airport)
# section should be longitude based
longitude_based = Airport.should_be_longitude_based(
departure_airport, destination_airport)
sections = []
if not flight_locations:
return sections
prev_flight_location = flight_locations[0]
section_flight_locations = [prev_flight_location]
for curr_flight_location in flight_locations[1:]:
if Section._flight_locations_are_part_of_the_same_section(
prev_flight_location, curr_flight_location,
longitude_based):
section_flight_locations.append(curr_flight_location)
else:
if len(section_flight_locations
) >= min_entries_per_section:
section = Section.from_flight_locations(
section_flight_locations)
sections.append(section)
section_flight_locations = [curr_flight_location]
prev_flight_location = curr_flight_location
Section.cache[key] = sections
# return cached results
return Section.cache[key]
def get_intersection_results(filepath, manager):
for (departure_airport, destination_airport), intersections in manager.items():
# convection cells within departure and destination airports
with open_database_session() as session:
cells = [cell for cell in ConvectionCell.all_convection_cells(session)
if cell.is_convection_cells_between_airports(departure_airport, destination_airport)]
intersected_cells = [cell for cell, _, _, impact in intersections]
ratio = None
if cells:
ratio = len(intersected_cells) / len(cells)
df = pd.DataFrame(
data={
'Células convectivas': [len(cells)],
'Células convectivas intersectadas': [len(intersected_cells)],
'Proporção': [ratio],
}
)
df.to_csv(path_or_buf=os.path.join(filepath, 'cells.csv'), index=False)
impacts = [impact for cell, _, _, impact in intersections]
latitudes = [lat for lat, _, _ in intersected_cells]
longitudes = [lon for _, lon, _ in intersected_cells]
radiuses = [rad for _, _, rad in intersected_cells]
timestamps = [cell.timestamp.strftime(r'%d-%m-%Y %H:%M') for cell in intersected_cells]
df = pd.DataFrame(
data={
'Impacto': impacts,
'Latitude': latitudes,
'Longitude': longitudes,
'Raio': radiuses,
'Timestamp': timestamps,
}
)
df.index += 1 # index starts from 1
(df.sort_values(by=['Impacto'], ascending=False)
.to_csv(path_or_buf=os.path.join(filepath, 'intersection.csv')))
def convection_cells_stats(convection_cell_ids):
global session
with open_database_session() as session:
BSB = Airport.airport_from_icao_code(session, 'SBBR')
GRU = Airport.airport_from_icao_code(session, 'SBGR')
print('create intersections table from', BSB, 'to', GRU)
# create_intersections_table(session, convection_cell_ids, BSB, GRU)
print('#' * 20)
print()
print('create intersections table from', GRU, 'to', BSB)
create_intersections_table(session, convection_cell_ids, GRU, BSB)
print('#' * 20)
print()
print('generate flights vs convection cells charts')
plot_flights_vs_convection_cells(session, convection_cell_ids)
def track_en_route_flights_by_airports(
departure_airport_code, destination_airport_code, round_trip_mode=False):
'''Keep track of current flights information from departure airport to destination airport.'''
global session
logger.info('Track flight addresses from {0} to {1} in {2} mode'.format(
departure_airport_code, destination_airport_code, 'round trip' if round_trip_mode else 'one way'))
address_to_flight = {}
count_iterations = 0
with open_database_session() as session:
departure_airport = Airport.airport_from_icao_code(session, departure_airport_code)
destination_airport = Airport.airport_from_icao_code(session, destination_airport_code)
while count_iterations < ITERATIONS_LIMIT_TO_SEARCH_FLIGHTS:
time.sleep(SLEEP_TIME_TO_GET_FLIGHT_IN_SECS)
if _should_update_flight_addresses(count_iterations):
addresses = _update_flight_addresses(
departure_airport, destination_airport, round_trip_mode)
_update_flights(address_to_flight, addresses)
count_iterations += 1
def get_convection_cells(departure_airport, destination_airport):
# convection cells within departure and destination airports
with open_database_session() as session:
return {cell for cell in ConvectionCell.all_convection_cells(session)
if cell.is_convection_cells_between_airports(departure_airport, destination_airport)}
def has_flight_plan_data_valid_callsign(flight_plan_data):
callsign = flight_plan_data['callsign']
with open_database_session() as session:
airlines = session.query(Airline).all()
return any(callsign.startswith(airline.icao_code) for airline in airlines)
def get_airport_from_icao_code(icao_code):
with open_database_session() as session:
return session.query(Airport).filter(Airport.icao_code == icao_code).first()
def get_all_airports():
with open_database_session() as session:
return session.query(Airport).all()
def has_flight_plan_data_valid_destination_airport(flight_plan_data):
icao_code = flight_plan_data['destination_airport']
with open_database_session() as session:
q = session.query(Airport).filter(Airport.icao_code == icao_code)
return session.query(literal(True)).filter(q.exists()).scalar()
