weather and optimizer operational

flight_distance.py

@@ -101,6 +101,10 @@ def calculate_distances(airport_identifiers):
 # aircraft_specs = get_aircraft_details(aircraft_type)
 # print(aircraft_specs)
 
+# airport_list = ['SIN','CDG']
+# print(get_airport_lat_long(airport_list))
+# print(calculate_distances(airport_list))
+
 # fuel_burn_rate = aircraft_specs['Fuel_Consumption_kg/hr']
 # cruising_speed = aircraft_specs['Max_Fuel_Capacity_kg']
 # max_fuel_capacity = aircraft_specs['Speed_kmh']

main.py

@@ -1,9 +1,9 @@
 import pandas as pd
 from flight_distance import *
-# from optimizer import *
+from optimizer import *
 from weather import *
 
-airport_identifiers = ['SIN', 'LAX', 'JFK', 'CDG', 'LHR']  # Replace with actual identifiers
+airport_identifiers = ['BOM', 'CCU', 'DEL']  # Replace with actual identifiers
 
 #Get Airport Coordinates
 lat_long_dict = get_airport_lat_long(airport_identifiers)
@@ -14,15 +14,25 @@ trip_distance = calculate_distances(airport_identifiers)
 print("Distance b/w Airports: \n",trip_distance)
 
 #Get onroute weather
-weather = fetch_weather_for_all_routes(airport_identifiers,lat_long_dict)
-print("On Route weather: \n", weather)
+raw_weather = fetch_weather_for_all_routes(airport_identifiers, lat_long_dict)
+route_factors = extract_route_factors(raw_weather)
+print("On Route weather: \n", raw_weather)
 
 # # Ensure the graph is bidirectional (undirected)
 # for (a, b), dist in list(trip_distance.items()):
 #     trip_distance[(b, a)] = dist
 
 # # Find the optimal route with the new cost metric
-# optimal_route, optimal_distance = find_optimal_route(airport_identifiers, trip_distance)
+# Ensure the graph is bidirectional (undirected)
+for (a, b), dist in list(trip_distance.items()):
+    trip_distance[(b, a)] = dist
+
+# Find the optimal route with the new cost metric
+optimal_route, optimal_distance = find_optimal_route(airport_identifiers, trip_distance, route_factors)
+
+# Display the optimal route and the total adjusted distance/cost
+print("Optimal Route:", " -> ".join(optimal_route) + f" -> {optimal_route[0]}")
+print("Total Adjusted Distance/Cost:", optimal_distance)
 
 # print("Optimal Route:", " -> ".join(optimal_route) + f" -> {optimal_route[0]}")
 # print("Total Adjusted Distance/Cost:", optimal_distance)

optimizer.py

@@ -1,24 +1,27 @@
 import itertools
 
-# Define the distances between the airports
-distances = {
-    ('SIN', 'LAX'): 14101.48,
-    ('LAX', 'JFK'): 3974.20,
-    ('JFK', 'CDG'): 5833.66,
-}
+def extract_route_factors(raw_weather):
+    """
+    Extracts route factors from raw weather data by breaking down routes into individual segments.
 
-# Define the factors for each route segment
-route_factors = {('SIN', 'LAX'): {'weather': 'clear sky', 'temperature': 27.18}, ('LAX', 'JFK'): {'weather': 'clear sky', 'temperature': 25.37}, ('JFK', 
-'CDG'): {'weather': 'clear sky', 'temperature': 21.18}}
+    Parameters:
+    - raw_weather (dict): The raw weather data with routes and corresponding weather details.
 
-# Ensure the graph is bidirectional (undirected)
-for (a, b), dist in list(distances.items()):
-    distances[(b, a)] = dist
+    Returns:
+    - dict: A dictionary with segments as keys (in tuple format) and a list of weather and temperature data.
+    """
+    route_factors = {}
+    for route, segments in raw_weather.items():
+        for segment in segments:
+            segment_key = tuple(segment['segment'].split(' -> '))
+            if segment_key not in route_factors:
+                route_factors[segment_key] = []
+            route_factors[segment_key].append({
+                'weather': segment['weather'],
+                'temperature': segment['temperature']
+            })
+    return route_factors
 
-for (a, b), factors in list(route_factors.items()):
-    route_factors[(b, a)] = factors
-
-# Function to assign a risk factor based on weather
 def weather_risk(weather):
     risk_factors = {
         "clear sky": 0.1,
@@ -40,20 +43,30 @@ def temperature_impact(temperature):
     return 0.1  # Low impact in the ideal range
 
 # Calculate the adjusted cost for each route segment
-def calculate_adjusted_cost(segment, base_distance):
-    if segment not in route_factors:
-        segment = (segment[1], segment[0])  # Check the reversed segment
-    weather = route_factors[segment]["weather"]
-    temperature = route_factors[segment]["temperature"]
+def calculate_adjusted_cost(segment, base_distance, route_factors):
+    # Handle both directions of the segment
+    if segment in route_factors:
+        factors = route_factors[segment]
+    elif (segment[1], segment[0]) in route_factors:
+        factors = route_factors[(segment[1], segment[0])]
+    else:
+        raise ValueError(f"Segment {segment} not found in route factors.")
+
+    # Aggregate weather and temperature data if there are multiple entries for the segment
+    weather_descriptions = [factor["weather"] for factor in factors]
+    temperatures = [factor["temperature"] for factor in factors]
+
+    most_common_weather = max(set(weather_descriptions), key=weather_descriptions.count)
+    avg_temperature = sum(temperatures) / len(temperatures)
     
-    weather_cost = weather_risk(weather) * 100  # Weight for weather impact
-    temperature_cost = temperature_impact(temperature) * 50  # Weight for temperature impact
+    weather_cost = weather_risk(most_common_weather) * 100  # Weight for weather impact
+    temperature_cost = temperature_impact(avg_temperature) * 50  # Weight for temperature impact
     
     total_cost = base_distance + weather_cost + temperature_cost
     return total_cost
 
 # Update the distance function to include additional factors
-def calculate_route_distance(route, distances):
+def calculate_route_distance(route, distances, route_factors):
     """Calculate the total cost for a given route, including additional factors."""
     total_distance = 0
     for i in range(len(route) - 1):
@@ -61,35 +74,30 @@ def calculate_route_distance(route, distances):
         if segment not in distances:
             segment = (route[i + 1], route[i])
         base_distance = distances[segment]
-        total_distance += calculate_adjusted_cost(segment, base_distance)
+        total_distance += calculate_adjusted_cost(segment, base_distance, route_factors)
+    
     # Add distance to return to the starting point
     last_segment = (route[-1], route[0])
     if last_segment not in distances:
         last_segment = (route[0], route[-1])
     base_distance = distances[last_segment]
-    total_distance += calculate_adjusted_cost(last_segment, base_distance)
+    total_distance += calculate_adjusted_cost(last_segment, base_distance, route_factors)
     
     return total_distance
 
-def find_optimal_route(airports, distances):
+def find_optimal_route(airports, distances, route_factors):
     """Find the optimal route that covers all airports."""
     best_route = None
     min_distance = float('inf')
 
     # Generate all possible permutations of the route
     for route in itertools.permutations(airports):
-        current_distance = calculate_route_distance(route, distances)
-        if current_distance < min_distance:
-            min_distance = current_distance
-            best_route = route
+        try:
+            current_distance = calculate_route_distance(route, distances, route_factors)
+            if current_distance < min_distance:
+                min_distance = current_distance
+                best_route = route
+        except ValueError as e:
+            print(e)  # Log the error to debug missing segments
 
     return best_route, min_distance
-
-# List of all airports
-airports = ['SIN', 'LAX', 'JFK', 'CDG']
-
-# Find the optimal route with the new cost metric
-optimal_route, optimal_distance = find_optimal_route(airports, distances)
-
-print("Optimal Route:", " -> ".join(optimal_route) + f" -> {optimal_route[0]}")
-print("Total Adjusted Distance/Cost:", optimal_distance)

weather.py

@@ -1,12 +1,13 @@
 import requests
 import itertools
 from geopy.distance import geodesic
+from functools import lru_cache
 
 # Replace with your OpenWeather API key
 API_KEY = '9811dd1481209c64fba6cb2c90f27140'
 
 # Interpolation function to get intermediate points between airports
-def get_intermediate_points(start, end, num_points=4):
+def get_intermediate_points(start, end, num_points=2):
     points = []
     lat_step = (end[0] - start[0]) / (num_points + 1)
     lon_step = (end[1] - start[1]) / (num_points + 1)
@@ -18,6 +19,7 @@ def get_intermediate_points(start, end, num_points=4):
     return points
 
 # Fetch weather data for a given coordinate
+@lru_cache(maxsize=128)
 def fetch_weather(lat, lon):
     url = f'http://api.openweathermap.org/data/2.5/weather?lat={lat}&lon={lon}&appid={API_KEY}&units=metric'
     response = requests.get(url)
@@ -65,26 +67,25 @@ def fetch_weather_for_all_routes(airport_identifiers, airports):
                 "weather": most_common_weather,
                 "temperature": round(avg_temperature, 2)
             })
-
     return route_factors
 
-# Example airport coordinates
-airports = {
-    'SIN': (1.3644, 103.9915),  # Singapore Changi Airport
-    'LAX': (33.9416, -118.4085),  # Los Angeles International Airport
-    'JFK': (40.6413, -73.7781),  # John F. Kennedy International Airport
-    'CDG': (49.0097, 2.5479),  # Charles de Gaulle Airport
-    'LHR': (51.4700, -0.4543)   # London Heathrow Airport
-}
+# # Example airport coordinates
+# airports = {
+#     'SIN': (1.3644, 103.9915),  # Singapore Changi Airport
+#     'LAX': (33.9416, -118.4085),  # Los Angeles International Airport
+#     'JFK': (40.6413, -73.7781),  # John F. Kennedy International Airport
+#     'CDG': (49.0097, 2.5479),  # Charles de Gaulle Airport
+#     'LHR': (51.4700, -0.4543)   # London Heathrow Airport
+# }
 
-airport_identifiers = ['SIN', 'LAX', 'JFK', 'CDG', 'LHR']  # Replace with actual identifiers
+# airport_identifiers = ['SIN', 'LAX', 'JFK', 'CDG', 'LHR']  # Replace with actual identifiers
 
-# Fetch the weather along all possible routes
-route_weather = fetch_weather_for_all_routes(airport_identifiers, airports)
+# # Fetch the weather along all possible routes
+# route_weather = fetch_weather_for_all_routes(airport_identifiers, airports)
 
-# Display the weather data for each route
-for route, factors in route_weather.items():
-    print(f"Route: {route}")
-    for factor in factors:
-        print(f"  Segment: {factor['segment']}, Weather: {factor['weather']}, Temperature: {factor['temperature']} °C")
-    print()
+# # Display the weather data for each route
+# for route, factors in route_weather.items():
+#     print(f"Route: {route}")
+#     for factor in factors:
+#         print(f"  Segment: {factor['segment']}, Weather: {factor['weather']}, Temperature: {factor['temperature']} °C")
+#     print()