updated code

flight_route_ui.py → Old/flight_route_ui.py

@@ -1,6 +1,6 @@
 import gradio as gr
 import pandas as pd
-from optimizer import *
+from Old.optimizer import *
 from weather import *
 from flight_distance import *  # Assuming this function is defined in your aircraft capabilities module
 

Old/main.py

@@ -0,0 +1,36 @@
+import pandas as pd
+from flight_distance import *
+from Old.optimizer import *
+from weather import *
+
+airport_identifiers = ['CCU', 'CDG', 'SIN']  # Replace with actual identifiers
+
+#Get Airport Coordinates
+lat_long_dict = get_airport_lat_long(airport_identifiers)
+# print("Coordinates: \n",lat_long_dict)
+
+#Get Distance between each node (airports)
+trip_distance = calculate_distances(airport_identifiers)
+# print("Distance b/w Airports: \n",trip_distance)
+
+#Get onroute 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, route_factors)
+
+# Display the optimal route and the total adjusted distance/cost
+print("Optimal Route:", " -> ".join(optimal_route) + f" -> {optimal_route[0]}")
+print("Total Round Trip Distance:", optimal_distance)
+
+aircraft_type = "Airbus A350-900"
+
+# Check if the aircraft can fly the route without refuel
+result = can_fly_route(aircraft_type, airport_identifiers)
+print(result)

flight_distance.py

@@ -1,234 +1,86 @@
 import pandas as pd
-from math import *
+from math import radians, sin, cos, sqrt, asin
+
+### Modular Flight Calculation Functions ###
 
 def get_aircraft_details(aircraft_type):
-    # Load the CSV file
-    csv_file = r'aircraft.csv'  # Replace with the actual path if needed
+    """
+    Fetch aircraft details based on the given aircraft type.
+    """
+    csv_file = 'aircraft.csv'
     df = pd.read_csv(csv_file)
-
-    # Check if the aircraft type exists in the DataFrame
     if aircraft_type not in df['Aircraft'].values:
         return f"Aircraft type '{aircraft_type}' not found in the dataset."
-
-    # Fetch the relevant details for the given aircraft type
+    
     aircraft_details = df[df['Aircraft'] == aircraft_type][[
-        'Range_km',
-        'Fuel_Consumption_kg/hr',
-        'Cruising Speed (kts)',
-        'Speed_kmh',
-        'MaxFlightTime_hr',
-        'Max_Fuel_Capacity_kg'
-    ]]
-
-    # Convert the result to a dictionary for easier reading
-    details_dict = aircraft_details.to_dict(orient='records')[0]
+        'Range_km', 'Fuel_Consumption_kg/hr', 'Cruising Speed (kts)', 
+        'Speed_kmh', 'MaxFlightTime_hr', 'Max_Fuel_Capacity_kg']]
+    
+    return aircraft_details.to_dict(orient='records')[0]
 
-    return details_dict
 
 def get_airport_lat_long(identifiers):
     """
-    Fetch latitude and longitude for a list of airport names or IATA codes.
-
-    :param identifiers: List of airport names or IATA codes (minimum of 2)
-    :return: Dictionary with airport identifiers as keys and (latitude, longitude) tuples as values
+    Get latitude and longitude for a list of airport identifiers (IATA codes).
     """
-    if len(identifiers) < 2:
-        return "Please provide at least two airport identifiers."
-
-    # Load the CSV file
-    csv_file = r'airport.csv'  # Replace with the actual path if needed
+    csv_file = 'airport.csv'
     df = pd.read_csv(csv_file)
-
-    # Efficiently filter rows where the 'Name' or 'IATA' matches any of the provided identifiers
     df_filtered = df[df['Airport_Name'].isin(identifiers) | df['IATA'].isin(identifiers)]
-
-    # Extract relevant information and store in a dictionary
-    lat_long_dict = {}
-    for _, row in df_filtered.iterrows():
-        identifier = row['IATA'] if row['IATA'] in identifiers else row['Name']
-        lat_long_dict[identifier] = (row['Lat'], row['Long'])
-
-    # Check if all identifiers were found
-    not_found = [id for id in identifiers if id not in lat_long_dict]
-    if not_found:
-        return f"These identifiers were not found: {', '.join(not_found)}"
-
+    lat_long_dict = {row['IATA']: (row['Lat'], row['Long']) for _, row in df_filtered.iterrows()}
     return lat_long_dict
 
+
 def haversine_distance(lat1, lon1, lat2, lon2):
     """
-    Calculate the Haversine distance between two points on the Earth.
+    Calculate the Haversine distance between two points on Earth (in kilometers).
     """
-    R = 6371.0  # Radius of Earth in kilometers
-    
-    # Convert latitude and longitude from degrees to radians
+    R = 6371.0  # Earth radius in kilometers
     lat1, lon1, lat2, lon2 = map(radians, [lat1, lon1, lat2, lon2])
-
-    # Haversine formula
-    dlat = lat2 - lat1
-    dlon = lon2 - lon1
+    dlat, dlon = lat2 - lat1, lon2 - lon1
     a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2
-    c = 2 * asin(sqrt(a))
-    distance = round(R * c,2)
-    return distance
-
-def calculate_distances(airport_identifiers):
-    """
-    Calculate the distance between multiple airports.
-    :param airport_identifiers: List of airport names or IATA codes
-    :return: Dictionary with airport pairs as keys and their distances in kilometers as values
-    """
-    lat_long_dict = get_airport_lat_long(airport_identifiers)
-    if isinstance(lat_long_dict, str):  # Check if there was an error fetching airport data
-        return lat_long_dict
-
-    # Calculate the distance for each combination of airports
-    distances = {}
-    identifiers = list(lat_long_dict.keys())
-    for i in range(len(identifiers)):
-        for j in range(i + 1, len(identifiers)):
-            airport1 = identifiers[i]
-            airport2 = identifiers[j]
-            lat1, lon1 = lat_long_dict[airport1]
-            lat2, lon2 = lat_long_dict[airport2]
-            distance = haversine_distance(lat1, lon1, lat2, lon2)
-            distances[(airport1, airport2)] = distance
+    return round(R * 2 * asin(sqrt(a)), 2)
 
-    return distances
 
 def calculate_distances(airport_identifiers):
     """
-    Calculate the distance between multiple airports.
-
-    :param airport_identifiers: List of airport names or IATA codes
-    :return: Dictionary with airport pairs as keys and their distances in kilometers as values
+    Calculate the distance between each pair of airports.
     """
     lat_long_dict = get_airport_lat_long(airport_identifiers)
-    if isinstance(lat_long_dict, str):  # Check if there was an error fetching airport data
-        return lat_long_dict
-
-    # Calculate the distance for each combination of airports
     distances = {}
-    identifiers = list(lat_long_dict.keys())
-    for i in range(len(identifiers)):
-        for j in range(i + 1, len(identifiers)):
-            airport1 = identifiers[i]
-            airport2 = identifiers[j]
+    for i in range(len(airport_identifiers)):
+        for j in range(i + 1, len(airport_identifiers)):
+            airport1, airport2 = airport_identifiers[i], airport_identifiers[j]
             lat1, lon1 = lat_long_dict[airport1]
             lat2, lon2 = lat_long_dict[airport2]
-            distance = haversine_distance(lat1, lon1, lat2, lon2)
-            distances[(airport1, airport2)] = distance
-
+            distances[(airport1, airport2)] = haversine_distance(lat1, lon1, lat2, lon2)
     return distances
 
-def calculate_fuel_and_time(distance, cruising_speed, fuel_burn_rate, reserve_fuel_percentage, max_fuel_capacity, climb_descent_fraction=0.02):
-    """
-    Calculate the total fuel required for a given distance including reserve fuel and flight time.
 
-    :param distance: Distance of the trip in kilometers
-    :param cruising_speed: Cruising speed of the aircraft in km/h
-    :param fuel_burn_rate: Fuel consumption rate in kg/hr
-    :param reserve_fuel_percentage: Percentage of fuel to keep as reserve
-    :param max_fuel_capacity: Maximum fuel capacity of the aircraft in kg
-    :return: Total fuel required including reserve, and estimated flight time
+def calculate_fuel_and_time_for_segment(segment_distance, aircraft_specs):
     """
-    # Phase speeds and times
-    climb_speed = cruising_speed*0.3 # km/h
-    descent_speed = cruising_speed*0.3  # km/h
-    climb_descent_distance = round(distance * climb_descent_fraction,2)
-    cruise_distance = round(distance - (2 * climb_descent_distance),2)  # Remaining distance for cruise
-
-    # Adjust if cruise distance is negative (short flights)
-    if cruise_distance < 0:
-        climb_time = climb_descent_distance / climb_speed
-        descent_time = climb_descent_distance / descent_speed
-        cruise_distance = 0
-
-    cruise_time = round(cruise_distance / cruising_speed,2)
-    climb_time = round(climb_descent_distance / climb_speed,2)
-    descent_time = round(climb_descent_distance / descent_speed,2)
-    # Total flight time
-    # print(climb_descent_distance,climb_time,cruise_distance, cruise_time,descent_time)
+    Calculate the fuel and time required for a single flight segment.
+    """
+    cruising_speed = aircraft_specs['Speed_kmh']
+    fuel_burn_rate = aircraft_specs['Fuel_Consumption_kg/hr']
+    max_fuel_capacity = aircraft_specs['Max_Fuel_Capacity_kg']
+    reserve_fuel_percentage = 0.05  # 5% reserve fuel
+
+    climb_speed, descent_speed = 300, 350
+    climb_time, descent_time = 15 / 60, 10 / 60  # in hours
+    climb_distance = climb_speed * climb_time
+    descent_distance = descent_speed * descent_time
+
+    # Calculate cruise distance
+    cruise_distance = segment_distance - (climb_distance + descent_distance)
+    cruise_distance = max(0, cruise_distance)  # Ensure cruise distance is not negative
+
+    # Calculate flight time for each phase
+    cruise_time = cruise_distance / cruising_speed
     total_flight_time = climb_time + cruise_time + descent_time
 
-    # Fuel calculations
+    # Calculate fuel required
     fuel_required = total_flight_time * fuel_burn_rate
     reserve_fuel = reserve_fuel_percentage * max_fuel_capacity
-    # print(fuel_burn_rate, fuel_required, reserve_fuel)
     total_fuel_with_reserve = fuel_required + reserve_fuel
 
     return total_fuel_with_reserve, total_flight_time
-
-
-def check_route_feasibility(aircraft_type, trip_distances, aircraft_specs):
-    """
-    Check if the aircraft can fly each route without needing refuel and return expected flight times.
-
-    :param aircraft_type: The type of the aircraft (e.g., "Airbus A320")
-    :param trip_distances: Dictionary with airport pairs and distances
-    :param aircraft_specs: Dictionary containing aircraft details
-    :return: Dictionary with feasibility and flight time for each route
-    """
-    # Extract aircraft specifications
-    fuel_burn_rate = aircraft_specs['Fuel_Consumption_kg/hr']  # kg per hour
-    cruising_speed = aircraft_specs['Speed_kmh']  # km/h
-    max_fuel_capacity = aircraft_specs['Max_Fuel_Capacity_kg']  # kg
-    reserve_fuel_percentage = 0.05  # 5% reserve
-
-    results = {}
-
-    # Check feasibility for each route
-    for (airport1, airport2), distance in trip_distances.items():
-        # Calculate the total fuel required and flight time for the trip including reserve
-        total_fuel_with_reserve, flight_time = calculate_fuel_and_time(
-            distance, cruising_speed, fuel_burn_rate, reserve_fuel_percentage, max_fuel_capacity
-        )
-
-        if total_fuel_with_reserve > max_fuel_capacity:
-            results[(airport1, airport2)] = {
-                "Can Fly": False,
-                "Reason": f"Cannot fly without refuel. Required: {round(total_fuel_with_reserve, 2)} kg, Capacity: {max_fuel_capacity} kg",
-                "Expected Flight Time (hrs)": round(flight_time, 2)
-            }
-        else:
-            results[(airport1, airport2)] = {
-                "Can Fly": True,
-                "Expected Flight Time (hrs)": round(flight_time, 2),
-                "Total Fuel Required (kg)": round(total_fuel_with_reserve, 2)
-            }
-    return results
-
-def can_fly_route(aircraft_type, airport_identifiers):
-    """
-    Determine if the aircraft can fly the route without needing refuel, considering fuel capacity and reserve.
-
-    :param aircraft_type: The type of the aircraft (e.g., "Airbus A320")
-    :param airport_identifiers: List of airport names or IATA codes
-    :return: String message indicating if the aircraft can complete the trip or not
-    """
-    # Fetch aircraft details
-    aircraft_specs = get_aircraft_details(aircraft_type)
-    if isinstance(aircraft_specs, str):
-        return aircraft_specs  # Return the error message if aircraft details are not found
-
-    # Calculate distances between airports
-    trip_distances = calculate_distances(airport_identifiers)
-    if isinstance(trip_distances, str):
-        return trip_distances  # Return the error message if distances could not be calculated
-
-    # Check if the aircraft can fly each route without refuel
-    return check_route_feasibility(aircraft_type, trip_distances, aircraft_specs)
-
-# aircraft_type = input("Enter the aircraft type: ")
-# aircraft_specs = get_aircraft_details(aircraft_type)
-# print(aircraft_specs)
-
-# airport_list = ['CCU', 'CDG', 'SIN']
-# print(get_airport_lat_long(airport_list))
-
-# trip_distance = calculate_distances(airport_list)
-# print(trip_distance)
-
-# # Check if the aircraft can fly the route without refuel
-# result = can_fly_route(aircraft_type, airport_list)
-# print(result)

gradio_ui.py

@@ -0,0 +1,124 @@
+import gradio as gr
+import pandas as pd
+from flight_distance import *
+from optimize import *
+from weather import *
+
+# Load airport data and aircraft data from CSV files
+airport_df = pd.read_csv(r'airport.csv')  # Adjust the path to your CSV file
+aircraft_df = pd.read_csv(r'aircraft.csv')  # Adjust the path to your CSV file
+
+# Create a combined option list with both IATA codes and airport names
+airport_options = [f"{row['IATA']} - {row['Airport_Name']}" for _, row in airport_df.iterrows()]
+
+# Ensure the correct column is used for aircraft types
+aircraft_type_column = 'Aircraft'
+aircraft_options = aircraft_df[aircraft_type_column].tolist()
+
+# Gradio function to determine if a route can be flown
+def check_route(airport_selections, aircraft_type):
+    # Extract IATA codes from the selected options
+    airports = [selection.split(" - ")[0] for selection in airport_selections]
+    
+    # Step 1: Get Airport Coordinates
+    lat_long_dict = get_airport_lat_long(airports)
+    
+    # Step 2: Calculate Distances between each node (airports)
+    trip_distance = calculate_distances(airports)
+    
+    # Step 3: Get on-route weather
+    raw_weather = fetch_weather_for_all_routes(airports, lat_long_dict)
+    route_factors = extract_route_factors(raw_weather)
+    
+    # Step 4: Ensure the graph is bidirectional (undirected)
+    for (a, b), dist in list(trip_distance.items()):
+        trip_distance[(b, a)] = dist
+    
+    # Step 5: Find the optimal route based on weather, temperature, and distance
+    optimal_route, optimal_distance = find_optimal_route(airports, trip_distance, route_factors)
+    
+    # Step 6: Fetch Aircraft Details
+    aircraft_specs = get_aircraft_details(aircraft_type)
+    
+    # Check if aircraft details were retrieved successfully
+    if isinstance(aircraft_specs, str):
+        return {"Error": aircraft_specs}  # Return error message if aircraft not found
+    
+    # Prepare sector-wise details for flight time, fuel required, and refueling need
+    sector_details = []
+    refuel_required = False  # Flag to track if refueling is required
+    
+    for i in range(len(optimal_route) - 1):
+        segment = (optimal_route[i], optimal_route[i + 1])
+        segment_distance = trip_distance.get(segment) or trip_distance.get((segment[1], segment[0]))
+        
+        # Calculate fuel and time for this sector
+        fuel, time = calculate_fuel_and_time_for_segment(segment_distance, aircraft_specs)
+        sector_info = {
+            "Sector": f"{optimal_route[i]} -> {optimal_route[i+1]}",
+            "Fuel Required (kg)": round(fuel, 2),
+            "Flight Time (hrs)": round(time, 2)
+        }
+        
+        # Check if refueling is required for this sector
+        if fuel > aircraft_specs['Max_Fuel_Capacity_kg']:
+            sector_info["Refuel Required"] = "Yes"
+            refuel_required = True
+        else:
+            sector_info["Refuel Required"] = "No"
+        
+        sector_details.append(sector_info)
+
+    # Check the final leg (return to the starting point)
+    last_segment = (optimal_route[-1], optimal_route[0])
+    last_segment_distance = trip_distance.get(last_segment) or trip_distance.get((last_segment[1], last_segment[0]))
+    fuel, time = calculate_fuel_and_time_for_segment(last_segment_distance, aircraft_specs)
+    
+    # Add final leg details
+    final_leg_info = {
+        "Sector": f"{optimal_route[-1]} -> {optimal_route[0]}",
+        "Fuel Required (kg)": round(fuel, 2),
+        "Flight Time (hrs)": round(time, 2)
+    }
+    
+    if fuel > aircraft_specs['Max_Fuel_Capacity_kg']:
+        final_leg_info["Refuel Required"] = "Yes"
+        refuel_required = True
+    else:
+        final_leg_info["Refuel Required"] = "No"
+    
+    sector_details.append(final_leg_info)
+    
+    # Step 7: Prepare and return result
+    if refuel_required:
+        result = {
+            "Optimal Route": " -> ".join(optimal_route) + f" -> {optimal_route[0]}",
+            "Total Round Trip Distance": str(optimal_distance) + " km",
+            "Can Fly Entire Route": "No, refueling required in one or more sectors.",
+            "Sector Details": sector_details
+        }
+    else:
+        result = {
+            "Optimal Route": " -> ".join(optimal_route) + f" -> {optimal_route[0]}",
+            "Total Round Trip Distance": str(optimal_distance) + " km",
+            "Can Fly Entire Route": "Yes, no refueling required.",
+            "Sector Details": sector_details
+        }
+    
+    return result
+
+
+# Gradio Interface
+with gr.Blocks() as demo:
+    gr.Markdown("## Airport Route Feasibility Checker")
+    airport_selector = gr.Dropdown(airport_options, multiselect=True, label="Select Airports (IATA - Name)")
+    aircraft_selector = gr.Dropdown(aircraft_options, label="Select Aircraft Type")
+    check_button = gr.Button("Check Route Feasibility")
+    
+    result_output = gr.JSON(label="Result")
+
+    # Connect the button click to the check_route function
+    check_button.click(fn=check_route, inputs=[airport_selector, aircraft_selector], outputs=result_output)
+
+# Launch the Gradio app
+demo.launch()

main.py

@@ -1,36 +1,45 @@
 import pandas as pd
 from flight_distance import *
-from optimizer import *
+from optimize import *
 from weather import *
 
-airport_identifiers = ['BLR', 'SFO']  # Replace with actual identifiers
+airport_identifiers = ['CCU', 'SIN', 'LHR']  # Replace with actual identifiers
 
-#Get Airport Coordinates
+# Step 1: Get Airport Coordinates
 lat_long_dict = get_airport_lat_long(airport_identifiers)
-# print("Coordinates: \n",lat_long_dict)
 
-#Get Distance between each node (airports)
+# Step 2: Get Distance between each node (airports)
 trip_distance = calculate_distances(airport_identifiers)
-# print("Distance b/w Airports: \n",trip_distance)
 
-#Get onroute weather
+# Step 3: Get on-route weather
+# Assuming 'fetch_weather_for_all_routes' is available in weather module
 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)
+# Step 4: 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
+# Step 5: Find the optimal route based on weather, temperature, and distance
 optimal_route, optimal_distance = find_optimal_route(airport_identifiers, trip_distance, route_factors)
 
-# Display the optimal route and the total adjusted distance/cost
+# Display the optimal route and total adjusted distance
 print("Optimal Route:", " -> ".join(optimal_route) + f" -> {optimal_route[0]}")
-print("Total Round Trip Distance:", optimal_distance)
-
-aircraft_type = "Boeing 777-200LR"
-
-# Check if the aircraft can fly the route without refuel
-result = can_fly_route(aircraft_type, airport_identifiers)
-print(result)
+print("Total Round Trip Distance:", optimal_distance, "km")
+
+# Step 6: Fetch Aircraft Details (e.g., Boeing 787-9)
+aircraft_type = "Boeing 737-800"
+aircraft_specs = get_aircraft_details(aircraft_type)
+
+# Check if aircraft details were retrieved successfully
+if isinstance(aircraft_specs, str):
+    print(aircraft_specs)  # Print error if aircraft not found
+else:
+    # Step 7: Check if the aircraft can fly the route
+    route_feasibility = check_route_feasibility(optimal_route, trip_distance, aircraft_specs)
+
+    if route_feasibility["Can Fly Entire Route"]:
+        print(f"Total fuel required for the entire route: {route_feasibility['Total Fuel Required (kg)']} kg")
+        print(f"Total flight time for the entire route: {route_feasibility['Total Flight Time (hrs)']} hours")
+    else:
+        print("The aircraft cannot fly the entire route without refueling for at least one sector.")

optimize.py

@@ -0,0 +1,142 @@
+import itertools
+from flight_distance import *
+
+def extract_route_factors(raw_weather):
+    """
+    Extract weather and temperature factors for each route segment.
+    """
+    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
+
+
+def weather_risk(weather):
+    """
+    Return the risk factor associated with weather conditions.
+    """
+    risk_factors = {
+        "clear sky": 0.1, "few clouds": 0.2, "scattered clouds": 0.3,
+        "broken clouds": 0.4, "overcast clouds": 0.5, "light rain": 0.6,
+        "rain": 0.7, "storm": 0.9
+    }
+    return risk_factors.get(weather, 0.5)  # Default risk factor
+
+
+def temperature_impact(temperature):
+    """
+    Calculate the impact of temperature on fuel efficiency.
+    """
+    if temperature < 20 or temperature > 25:
+        return abs(temperature - 22.5) / 30  # Normalize impact to a value between 0 and 1
+    return 0.1  # Low impact in the ideal range
+
+
+def calculate_adjusted_cost(segment, base_distance, route_factors):
+    """
+    Calculate the adjusted cost of a segment considering weather and temperature.
+    """
+    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.")
+    
+    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(most_common_weather) * 100  # Weather impact weight
+    temperature_cost = temperature_impact(avg_temperature) * 50  # Temperature impact weight
+
+    total_cost = base_distance + weather_cost + temperature_cost
+    return total_cost
+
+
+def find_optimal_route(airports, distances, route_factors):
+    """
+    Find the optimal route between airports considering distance and weather factors.
+    """
+    best_route, min_distance = None, float('inf')
+    for route in itertools.permutations(airports):
+        total_distance = 0
+        for i in range(len(route) - 1):
+            segment = (route[i], route[i + 1])
+            base_distance = distances.get(segment) or distances.get((segment[1], segment[0]))
+            total_distance += calculate_adjusted_cost(segment, base_distance, route_factors)
+
+        last_segment = (route[-1], route[0])
+        base_distance = distances.get(last_segment) or distances.get((last_segment[1], last_segment[0]))
+        total_distance += calculate_adjusted_cost(last_segment, base_distance, route_factors)
+
+        if total_distance < min_distance:
+            min_distance, best_route = round(total_distance, 2), route
+
+    return best_route, min_distance
+
+
+### Modular Route Feasibility Checking Functions ###
+
+def check_segment_feasibility(segment, trip_distance, aircraft_specs):
+    """
+    Check if the aircraft can fly a single segment without refueling.
+    """
+    segment_distance = trip_distance.get(segment) or trip_distance.get((segment[1], segment[0]))
+    fuel_required, flight_time = calculate_fuel_and_time_for_segment(segment_distance, aircraft_specs)
+
+    if fuel_required > aircraft_specs['Max_Fuel_Capacity_kg']:
+        return False, fuel_required, flight_time
+    return True, fuel_required, flight_time
+
+
+def check_route_feasibility(optimal_route, trip_distance, aircraft_specs):
+    """
+    Check if the aircraft can fly the entire optimal route without refueling.
+    """
+    total_fuel = 0
+    total_time = 0
+    can_fly_entire_route = True  # Flag to check if entire route is feasible
+
+    for i in range(len(optimal_route) - 1):
+        segment = (optimal_route[i], optimal_route[i + 1])
+        can_fly, fuel, time = check_segment_feasibility(segment, trip_distance, aircraft_specs)
+        if not can_fly:
+            print(f"Cannot fly the sector {optimal_route[i]} -> {optimal_route[i+1]} without refueling.")
+            print(f"Fuel required: {round(fuel, 2)} kg, capacity: {aircraft_specs['Max_Fuel_Capacity_kg']} kg")
+            can_fly_entire_route = False
+        else:
+            print(f"Fuel required for {optimal_route[i]} -> {optimal_route[i+1]}: {round(fuel, 2)} kg")
+            print(f"Flight time for this sector: {round(time, 2)} hours")
+        total_fuel += fuel
+        total_time += time
+
+    last_segment = (optimal_route[-1], optimal_route[0])
+    can_fly, fuel, time = check_segment_feasibility(last_segment, trip_distance, aircraft_specs)
+    if not can_fly:
+        print(f"Cannot fly the sector {optimal_route[-1]} -> {optimal_route[0]} without refueling.")
+        print(f"Fuel required: {round(fuel, 2)} kg, capacity: {aircraft_specs['Max_Fuel_Capacity_kg']} kg")
+        can_fly_entire_route = False
+    else:
+        print(f"Fuel required for {optimal_route[-1]} -> {optimal_route[0]}: {round(fuel, 2)} kg")
+        print(f"Flight time for this sector: {round(time, 2)} hours")
+    total_fuel += fuel
+    total_time += time
+
+    if can_fly_entire_route:
+        return {
+            "Total Fuel Required (kg)": round(total_fuel, 2),
+            "Total Flight Time (hrs)": round(total_time, 2),
+            "Can Fly Entire Route": True
+        }
+    else:
+        return {"Can Fly Entire Route": False}

ui.py

@@ -1,90 +0,0 @@
-import tkinter as tk
-from tkinter import ttk
-import pandas as pd
-
-class AirportSearchApp:
-    def __init__(self, root, csv_file):
-        self.root = root
-        self.root.title("Airport Search")
-
-        self.df = pd.read_csv(csv_file)
-        self.iata_index = {row['IATA']: row['Airport_Name'] for idx, row in self.df.iterrows()}
-        self.name_index = {row['Airport_Name'].lower(): row['IATA'] for idx, row in self.df.iterrows()}
-        self.trie = self.build_trie()
-
-        self.create_widgets()
-
-    def build_trie(self):
-        trie = {}
-        for _, row in self.df.iterrows():
-            node = trie
-            for char in row['Airport_Name'].lower():
-                node = node.setdefault(char, {})
-            node['_end_'] = row['Airport_Name']
-        return trie
-
-    def search_iata(self, iata):
-        return self.iata_index.get(iata.upper(), "Airport not found")
-
-    def search_name(self, prefix):
-        node = self.trie
-        for char in prefix.lower():
-            if char not in node:
-                return []
-            node = node[char]
-        return self.find_airports(node)
-
-    def find_airports(self, node, prefix='', results=None):
-        if results is None:
-            results = []
-        if '_end_' in node:
-            results.append(node['_end_'])
-        for char, next_node in node.items():
-            if char != '_end_':
-                self.find_airports(next_node, prefix + char, results)
-        return results
-
-    def autocomplete(self, prefix, max_results=5):
-        results = self.search_name(prefix)
-        return results[:max_results]
-
-    def create_widgets(self):
-        self.label = tk.Label(self.root, text="Enter Airport Name or IATA Code:")
-        self.label.pack(pady=10)
-
-        self.entry = ttk.Entry(self.root, width=50)
-        self.entry.pack(pady=10)
-        self.entry.bind('<KeyRelease>', self.on_key_release)
-
-        self.listbox = tk.Listbox(self.root, width=50, height=10)
-        self.listbox.pack(pady=10)
-        self.listbox.bind('<<ListboxSelect>>', self.on_select)
-
-        self.result_label = tk.Label(self.root, text="")
-        self.result_label.pack(pady=10)
-
-    def on_key_release(self, event):
-        input_text = self.entry.get()
-        if len(input_text) == 3:
-            # Likely an IATA code
-            airport_name = self.search_iata(input_text)
-            self.result_label.config(text=f"IATA Code: {input_text} -> Airport: {airport_name}")
-            self.listbox.delete(0, tk.END)
-        else:
-            # Autocomplete based on airport name
-            suggestions = self.autocomplete(input_text)
-            self.listbox.delete(0, tk.END)
-            for suggestion in suggestions:
-                self.listbox.insert(tk.END, f"{suggestion} ({self.name_index[suggestion.lower()]})")
-
-    def on_select(self, event):
-        selected_airport = self.listbox.get(self.listbox.curselection())
-        self.result_label.config(text=f"Selected Airport: {selected_airport}")
-
-def main():
-    root = tk.Tk()
-    app = AirportSearchApp(root, 'airport.csv')
-    root.mainloop()
-
-if __name__ == "__main__":
-    main()