Upload 8 files

README.md

@@ -0,0 +1,177 @@
+---
+title: Last-Mile Delivery Optimizer
+emoji: 🚚
+colorFrom: blue
+colorTo: green
+sdk: gradio
+sdk_version: 4.0.0
+app_file: app.py
+pinned: false
+---
+
+# 🚚 Last-Mile Delivery Route Optimizer
+
+Multi-modal vehicle routing optimization with configurable costs and emission weighting.
+
+## 📋 Overview
+
+This application optimizes last-mile delivery routes using:
+- 🚲 **Bikes** for hub-to-hub transfers
+- 🚐 **Vans** from 2 depot locations (D1 & D2)
+- 🛸 **Drones** with pair duration constraints (≤90 minutes)
+
+## ✨ Key Features
+
+- **Configurable Vehicle Costs** - Adjust fixed, variable, labour, and emission costs for each vehicle type
+- **Emission-Weighted Optimization** - Adjustable weight (0-100%) on CO₂ emissions in objective function
+- **Drone Pair Constraint** - Enforces maximum combined operation time for drone pairs
+- **Interactive Visualization** - Road-following routes using OpenStreetMap
+- **Comprehensive Analysis** - Cost breakdown, schedules, and statistics
+
+## 🚀 How to Use
+
+1. **Upload** your `Matrices2PY.xlsx` file
+2. **Configure** optimization parameters:
+   - Number of P-hubs (1-50)
+   - Emission weight (0-100%)
+   - Drone pair limit (30-180 min)
+   - Maximum drones (1-10)
+   - Vehicle costs (bikes, vans, drones)
+   - Bees algorithm iterations (100-2000)
+3. **Click** "Run Optimization" button
+4. **Wait** 5-15 minutes for optimization to complete
+5. **Download** results package or view individual outputs
+
+## 📊 Input Requirements
+
+Upload an Excel file containing these sheets:
+
+| Sheet Name | Description |
+|------------|-------------|
+| **Van_dist** | Van distance matrix (km) |
+| **Van_dur** | Van duration matrix (min) |
+| **Drone_dist** | Drone distance matrix (km) |
+| **Drone_dur** | Drone duration matrix (min) |
+| **Bike_dist** | Bike distance matrix (miles) |
+| **Demand** | Customer demand data |
+| **Coordinate** | Node coordinates (latitude, longitude) |
+
+## 🎯 Optimization Pipeline
+
+### Phase 1: P-Hub Allocation
+- Identifies optimal hub locations (configurable: 1-50 hubs)
+- Generates bike routes using constructive cycle algorithm
+- Consolidates demand at selected hubs
+
+### Phase 2: TSP Optimization
+- Domino algorithm determines customer visit sequence
+- 50 iterations with 5 rounds for solution refinement
+- Minimizes total travel distance
+
+### Phase 3: Bees Algorithm
+- 10 bees exploring solution space
+- Configurable iterations (100-2000)
+- Foraging and penalty splitting operators
+- Multi-objective: cost + emissions + constraint penalties
+
+### Phase 4: Cost Analysis
+- Fixed, variable, labour, and emission costs
+- Capacity and time window penalties
+- Drone pair duration constraint validation
+
+### Phase 5: Schedule Generation
+- Departure time calculation for all vehicles
+- Multiple routes per vehicle support
+- Gap time between consecutive routes (5 minutes)
+
+## 📈 Output Files
+
+The application generates:
+
+- **Cost_Breakdown.xlsx** - Detailed cost analysis per vehicle segment
+- **Vehicle_Schedule.xlsx** - Complete schedules with departure times
+- **Vehicle_Statistics.xlsx** - Fleet composition summary
+- **Route_Map_Straight.html** - Interactive map with direct routes
+- **Route_Map_Roads.html** - Interactive map with road-following routes
+- **Vehicle_Ratio_Chart.png** - Fleet composition visualization
+- **Complete ZIP package** - All files bundled together
+
+## ⚙️ Configurable Parameters
+
+### General Settings
+- **P-Hubs:** Number of hub locations (1-50)
+- **Emission Weight:** Weight in objective function (0-1)
+- **Drone Pair Limit:** Maximum combined operation time (30-180 min)
+- **Max Drones:** Maximum number of drones (1-10)
+- **Iterations:** Bees algorithm iterations (100-2000)
+
+### Vehicle Costs (£)
+Each vehicle type has four configurable costs:
+- **Fixed Cost:** Cost per route/deployment
+- **Variable Cost:** Cost per kilometer traveled
+- **Labour Cost:** Cost per hour of operation
+- **Emission Cost:** Cost per kilometer (carbon penalty)
+
+**Default Values:**
+- Bikes: Fixed £30, Variable £0.15/km, Labour £12/hr, Emission £0/km
+- Vans: Fixed £50, Variable £0.30/km, Labour £15/hr, Emission £0.15/km
+- Drones: Fixed £20, Variable £0/km, Labour £20/hr, Emission £0/km
+
+## 🎓 Research Background
+
+This optimization system was developed as part of research on transport decarbonization and last-mile delivery electrification at **Heriot-Watt University**.
+
+### Research Focus
+- Multi-modal vehicle routing optimization
+- Emission reduction in urban logistics
+- Electric vehicle integration
+- Drone deployment strategies
+- Operational constraint handling
+
+### Methodology
+The system combines:
+- **P-Hub Location Problem** for strategic hub placement
+- **TSP with Domino Algorithm** for route sequencing
+- **Bees Algorithm** for fleet composition and routing
+- **Multi-objective Optimization** balancing cost and emissions
+- **OpenStreetMap Integration** for realistic routing
+
+## 👨‍🔬 Author
+
+**Asrul**  
+Transit Researcher  
+Heriot-Watt University
+
+**Expertise:**
+- Operations Research
+- Logistics Optimization
+- Transport Decarbonization
+- Machine Learning for Transportation
+
+## ⚠️ Important Notes
+
+- **Processing Time**: Optimization takes 5-15 minutes depending on network size and iteration count
+- **Network Size**: Tested with networks up to 100 nodes
+- **Browser Compatibility**: Works best in Chrome, Firefox, Safari
+- **File Size**: Maximum upload size is 200MB
+- **Privacy**: Files are processed in memory and not stored permanently
+
+## 🔧 Technical Details
+
+- **Framework**: Gradio 4.0
+- **Backend**: Python 3.9+
+- **Key Libraries**: pandas, numpy, folium, matplotlib, openpyxl
+- **Routing Engine**: OpenStreetMap Routing Machine (OSRM)
+- **Map Visualization**: Folium with OpenStreetMap tiles
+
+## 📜 License
+
+Academic and research use.
+
+---
+
+**Note**: This is research software developed for academic purposes. While designed for practical applications, users should validate results for their specific use cases.
+
+## 🚀 Get Started
+
+Upload your data file above and configure parameters to begin optimization! ⬆️

app.py

@@ -0,0 +1,922 @@
+"""
+🚚 Last-Mile Delivery Route Optimizer - Complete Gradio App
+Modular Structure: Imports from 5 Python modules
+
+Upload these files together:
+- app.py (this file)
+- requirements.txt
+- README.md
+- phub_allocation.py (your file)
+- bike_routes.py (your file)
+- tsp_optimizer.py (your file)
+- vehicle_routing.py (your file)
+- utils.py (your file)
+
+Developed by: Asrul - Heriot-Watt University
+"""
+
+import gradio as gr
+import numpy as np
+import pandas as pd
+from pathlib import Path
+import warnings
+import re
+from datetime import datetime, timedelta
+import matplotlib.pyplot as plt
+import folium
+from folium import plugins
+import zipfile
+import shutil
+import traceback
+import requests
+from time import sleep
+import colorsys
+
+warnings.filterwarnings('ignore')
+
+# Import from your 5 Python modules
+from phub_allocation import PHubAllocation
+from bike_routes import build_bike_routes_constructive_cycle
+from tsp_optimizer import optimize_tsp_domino
+from vehicle_routing import (
+    calculate_total_cost_mixed_fleet,
+    split_vehicle_routes,
+    foraging_combi,
+    penalty_splitting_operator
+)
+from utils import (
+    local_to_numeric_matrix,
+    local_to_numeric_vector,
+    local_parse_route,
+    local_find_coord_columns
+)
+
+
+# ============================================================================
+# PAIR CONSTRAINT FUNCTIONS
+# ============================================================================
+
+def calculate_segment_duration(segment, vid, DurMat_dict, depots, id2idx, nodeLabel, service_time_min):
+    """Calculate total duration for a vehicle segment"""
+    if not segment or len(segment) == 0:
+        return 0
+    
+    depot_label = depots[vid]
+    depot_idx = np.where(nodeLabel == depot_label)[0][0]
+    TM = DurMat_dict[vid]
+    
+    route_indices = [depot_idx]
+    for i in range(1, len(segment)):
+        customer_label = segment[i]
+        customer_idx = np.where(nodeLabel == customer_label)[0]
+        if len(customer_idx) > 0:
+            route_indices.append(customer_idx[0])
+    route_indices.append(depot_idx)
+    
+    total_time = 0
+    for i in range(len(route_indices) - 1):
+        u_label = nodeLabel[route_indices[i]]
+        v_label = nodeLabel[route_indices[i + 1]]
+        u_pos = id2idx[int(u_label)]
+        v_pos = id2idx[int(v_label)]
+        total_time += TM[u_pos, v_pos]
+    
+    num_customers = len(route_indices) - 2
+    if num_customers > 0:
+        total_time += service_time_min * num_customers
+    
+    return total_time
+
+
+def calculate_250_pair_durations(route, Vehicle_ids, DurMat_dict, depots, id2idx, nodeLabel, service_time_min):
+    """Calculate durations for each pair of vehicle 250 (drones)"""
+    split_segs = split_vehicle_routes(route, Vehicle_ids)
+    v250_segments = [seg for seg in split_segs if seg and seg[0] == 250]
+    
+    pair_durations = []
+    for i in range(0, len(v250_segments), 2):
+        if i + 1 < len(v250_segments):
+            dur1 = calculate_segment_duration(v250_segments[i], 250, DurMat_dict, depots, id2idx, nodeLabel, service_time_min)
+            dur2 = calculate_segment_duration(v250_segments[i+1], 250, DurMat_dict, depots, id2idx, nodeLabel, service_time_min)
+            pair_durations.append((dur1, dur2))
+        elif i < len(v250_segments):
+            dur1 = calculate_segment_duration(v250_segments[i], 250, DurMat_dict, depots, id2idx, nodeLabel, service_time_min)
+            pair_durations.append((dur1, 0))
+    
+    return pair_durations
+
+
+def calculate_pair_constraint_penalty(route, Vehicle_ids, DurMat_dict, depots, id2idx, nodeLabel, 
+                                     service_time_min, pair_limit_min, penalty_per_min):
+    """Calculate penalty for drone pair constraint violations"""
+    pair_durations = calculate_250_pair_durations(route, Vehicle_ids, DurMat_dict, depots, id2idx, nodeLabel, service_time_min)
+    
+    total_penalty = 0
+    for (dur1, dur2) in pair_durations:
+        combined = dur1 + dur2
+        if combined > pair_limit_min:
+            excess = combined - pair_limit_min
+            total_penalty += excess * penalty_per_min
+    
+    return total_penalty
+
+
+# ============================================================================
+# MAP GENERATION FUNCTIONS
+# ============================================================================
+
+def get_osrm_route(lat1, lon1, lat2, lon2, max_retries=3):
+    """Get route coordinates following roads using OSRM"""
+    url = f"http://router.project-osrm.org/route/v1/driving/{lon1},{lat1};{lon2},{lat2}?overview=full&geometries=geojson"
+    
+    for attempt in range(max_retries):
+        try:
+            response = requests.get(url, timeout=10)
+            if response.status_code == 200:
+                data = response.json()
+                if 'routes' in data and len(data['routes']) > 0:
+                    coords = data['routes'][0]['geometry']['coordinates']
+                    return [[c[1], c[0]] for c in coords]
+            sleep(0.5)
+        except:
+            sleep(1)
+    
+    return [[lat1, lon1], [lat2, lon2]]
+
+
+def generate_color_palette(base_color, num_colors):
+    """Generate color gradient"""
+    base_color = base_color.lstrip('#')
+    r, g, b = tuple(int(base_color[i:i+2], 16) for i in (0, 2, 4))
+    h, s, v = colorsys.rgb_to_hsv(r/255, g/255, b/255)
+    
+    colors = []
+    for i in range(num_colors):
+        factor = 0.5 + (0.5 * i / max(num_colors - 1, 1))
+        new_s = s * factor
+        new_v = 0.6 + (0.4 * factor)
+        r2, g2, b2 = colorsys.hsv_to_rgb(h, new_s, new_v)
+        colors.append('#{:02x}{:02x}{:02x}'.format(int(r2*255), int(g2*255), int(b2*255)))
+    
+    return colors
+
+
+def create_route_maps(bike_routes_df, vehicle_routes, nodeLabel, coord_file, depots):
+    """Generate interactive route maps (straight and road-following)"""
+    print("\n" + "="*70)
+    print("=== GENERATING ROUTE MAPS ===")
+    print("="*70)
+    
+    # Load coordinates
+    Tcoord = pd.read_excel(coord_file, sheet_name="Coordinate")
+    
+    if 'Unnamed: 0' in Tcoord.columns:
+        node_ids = Tcoord['Unnamed: 0'].values
+        lats = Tcoord['lat'].values
+        lons = Tcoord['lon'].values
+    else:
+        lonIdx, latIdx, idIdx = local_find_coord_columns(Tcoord)
+        node_ids = Tcoord.iloc[:, idIdx].values
+        lats = Tcoord.iloc[:, latIdx].values
+        lons = Tcoord.iloc[:, lonIdx].values
+    
+    # Build coordinate map
+    coord_map = {}
+    coord_map_original = {}
+    
+    for i in range(len(node_ids)):
+        node_id = node_ids[i]
+        lat, lon = lats[i], lons[i]
+        
+        coord_map_original[node_id] = (lat, lon)
+        coord_map[node_id] = (lat, lon)
+        coord_map[int(node_id)] = (lat, lon)
+        coord_map[float(node_id)] = (lat, lon)
+        
+        if node_id in [0, 0.0] or int(node_id) == 0:
+            coord_map[0] = coord_map[101] = coord_map[101.0] = (lat, lon)
+        elif node_id in [1, 1.0] or int(node_id) == 1:
+            coord_map[1] = coord_map[102] = coord_map[102.0] = (lat, lon)
+    
+    center_lat = np.mean(lats)
+    center_lon = np.mean(lons)
+    
+    base_colors = {
+        'bike': '#3498db',
+        'van-d1': '#e74c3c',
+        'van-d2': '#f39c12',
+        'drone': '#2ecc71',
+        'depot': '#8e44ad'
+    }
+    
+    # Create two maps
+    m_straight = folium.Map(location=[center_lat, center_lon], zoom_start=11)
+    m_road = folium.Map(location=[center_lat, center_lon], zoom_start=11)
+    
+    # Plot depots
+    for depot_id in [0, 1]:
+        if depot_id in coord_map:
+            lat, lon = coord_map[depot_id]
+            depot_label = 101 if depot_id == 0 else 102
+            for m in [m_straight, m_road]:
+                folium.Marker(
+                    location=[lat, lon],
+                    popup=f'<b>Depot {depot_label}</b>',
+                    icon=folium.Icon(color='purple', icon='home', prefix='fa')
+                ).add_to(m)
+    
+    # Plot bike routes
+    bike_colors = generate_color_palette(base_colors['bike'], len(bike_routes_df))
+    bike_count = 0
+    
+    for idx, row in bike_routes_df.iterrows():
+        route_nodes = local_parse_route(row['Route'])
+        route_coords = []
+        
+        for node in route_nodes:
+            if node in coord_map:
+                route_coords.append(coord_map[node])
+            elif int(node) in coord_map:
+                route_coords.append(coord_map[int(node)])
+        
+        if len(route_coords) >= 2:
+            color = bike_colors[idx % len(bike_colors)]
+            
+            folium.PolyLine(
+                locations=route_coords, color=color, weight=4, opacity=0.8,
+                popup=f'Bike {bike_count+1}'
+            ).add_to(m_straight)
+            
+            road_coords = []
+            for i in range(len(route_coords) - 1):
+                segment = get_osrm_route(*route_coords[i], *route_coords[i+1])
+                road_coords.extend(segment if i == 0 else segment[1:])
+            
+            if road_coords:
+                folium.PolyLine(
+                    locations=road_coords, color=color, weight=4, opacity=0.8,
+                    popup=f'Bike {bike_count+1}'
+                ).add_to(m_road)
+            
+            bike_count += 1
+    
+    # Plot vehicle routes
+    vehicle_type_routes = {'van-d1': [], 'van-d2': [], 'drone': []}
+    
+    for seg_idx, vr in enumerate(vehicle_routes, 1):
+        if not vr or len(vr) == 0:
+            continue
+        
+        vid = int(vr[0])
+        if vid not in [150, 151, 250]:
+            continue
+        
+        vehicle_type = 'van-d1' if vid == 150 else 'van-d2' if vid == 151 else 'drone'
+        depot_label = depots[vid]
+        depot_idx = np.where(nodeLabel == depot_label)[0][0]
+        
+        route_indices = [depot_idx]
+        for i in range(1, len(vr)):
+            customer_idx = np.where(nodeLabel == vr[i])[0]
+            if len(customer_idx) > 0:
+                route_indices.append(customer_idx[0])
+        route_indices.append(depot_idx)
+        
+        route_coords = []
+        for idx in route_indices:
+            node_label = nodeLabel[idx]
+            if node_label in coord_map:
+                route_coords.append(coord_map[node_label])
+            elif int(node_label) in coord_map:
+                route_coords.append(coord_map[int(node_label)])
+        
+        if len(route_coords) >= 2:
+            vehicle_type_routes[vehicle_type].append({'coords': route_coords, 'seg': seg_idx})
+    
+    counts = {'van-d1': 0, 'van-d2': 0, 'drone': 0}
+    
+    for vtype, routes in vehicle_type_routes.items():
+        if not routes:
+            continue
+        
+        colors = generate_color_palette(base_colors[vtype], len(routes))
+        is_drone = (vtype == 'drone')
+        
+        for i, route_info in enumerate(routes):
+            coords = route_info['coords']
+            
+            folium.PolyLine(
+                locations=coords, color=colors[i], weight=5, opacity=0.9,
+                popup=f'{vtype.upper()}'
+            ).add_to(m_straight)
+            
+            if is_drone:
+                folium.PolyLine(
+                    locations=coords, color=colors[i], weight=5, opacity=0.9,
+                    dashArray='10, 5', popup=f'{vtype.upper()} (flying)'
+                ).add_to(m_road)
+            else:
+                road_coords = []
+                for j in range(len(coords) - 1):
+                    segment = get_osrm_route(*coords[j], *coords[j+1])
+                    road_coords.extend(segment if j == 0 else segment[1:])
+                
+                if road_coords:
+                    folium.PolyLine(
+                        locations=road_coords, color=colors[i], weight=5, opacity=0.9,
+                        popup=f'{vtype.upper()}'
+                    ).add_to(m_road)
+            
+            counts[vtype] += 1
+    
+    # Customer nodes
+    for node_id in coord_map_original.keys():
+        if node_id not in [0, 1]:
+            lat, lon = coord_map_original[node_id]
+            for m in [m_straight, m_road]:
+                folium.CircleMarker(
+                    location=[lat, lon], radius=4, color='black',
+                    fill=True, fillColor='white', fillOpacity=0.8, weight=2
+                ).add_to(m)
+    
+    m_straight.save('Route_Map_Straight.html')
+    m_road.save('Route_Map_Roads.html')
+    
+    print(f"✅ Maps saved - Bikes: {bike_count}, Van-D1: {counts['van-d1']}, Van-D2: {counts['van-d2']}, Drones: {counts['drone']}")
+    
+    return m_straight, m_road
+
+
+# ============================================================================
+# MAIN OPTIMIZATION PIPELINE
+# ============================================================================
+
+def run_full_optimization(
+    input_file,
+    p_hubs, emission_weight, drone_pair_limit, max_drones,
+    fixed_bike, var_bike, labour_bike, emission_bike,
+    fixed_van, var_van, labour_van, emission_van,
+    fixed_drone, var_drone, labour_drone, emission_drone,
+    bees_iterations,
+    progress=gr.Progress()
+):
+    """
+    Complete 5-phase optimization pipeline with configurable parameters
+    """
+    try:
+        # Setup
+        ROOT = Path.cwd()
+        input_dir = ROOT / 'inputs'
+        input_dir.mkdir(exist_ok=True)
+        srcXlsx = input_dir / 'Matrices2PY.xlsx'
+        shutil.copy(input_file, srcXlsx)
+        
+        # Clean old outputs
+        for f in ['Cost_Breakdown.xlsx', 'Vehicle_Schedule.xlsx', 'Vehicle_Statistics.xlsx',
+                  'Route_Map_Straight.html', 'Route_Map_Roads.html', 'Vehicle_Ratio_Chart.png']:
+            if Path(f).exists():
+                Path(f).unlink()
+        
+        progress(0.05, desc="🚀 Initialization complete")
+        
+        # Vehicle costs
+        vehicle_costs = {
+            'bike': {'fixed': fixed_bike, 'var': var_bike, 'labour': labour_bike, 'emission': emission_bike},
+            'van': {'fixed': fixed_van, 'var': var_van, 'labour': labour_van, 'emission': emission_van},
+            'drone': {'fixed': fixed_drone, 'var': var_drone, 'labour': labour_drone, 'emission': emission_drone}
+        }
+        
+        # =================================================================
+        # PHASE 1: P-HUB ALLOCATION & BIKE ROUTES
+        # =================================================================
+        
+        progress(0.10, desc="📍 Phase 1: P-Hub Allocation...")
+        
+        routesCsv = ROOT / "hub_bike_routes.csv"
+        
+        if not routesCsv.exists():
+            obj = PHubAllocation(str(srcXlsx), p_hubs=p_hubs, random_seed=42, auto_expand_hubs=True)
+            hubs, allocations, total_cost, sh_modes, p_eff, cost_breakdown = obj.solve()
+            print(f"[Info] Selected {len(hubs)} hubs, cost: £{total_cost:.2f}")
+            
+            T_bike = build_bike_routes_constructive_cycle(
+                obj, hubs, allocations,
+                MaxRouteNodes=3, MaxTotalMinutes=25.0, LoadingTime=2.5,
+                SaveCsvPath=str(routesCsv)
+            )
+            print(f"[Info] Generated {len(T_bike)} bike routes")
+        
+        # Update demand (consolidate at hubs)
+        Tdem = pd.read_excel(srcXlsx, sheet_name="Demand")
+        node_ids = Tdem.iloc[:, 0].values.astype(float)
+        demand_orig = Tdem.iloc[:, 1].values.astype(float)
+        D = dict(zip(node_ids, demand_orig))
+        
+        R = pd.read_csv(routesCsv)
+        for i in range(len(R)):
+            route_nodes = local_parse_route(R.iloc[i]['Route'])
+            if len(route_nodes) >= 2:
+                h = route_nodes[0]
+                tails = route_nodes[1:-1] if route_nodes[-1] == h else route_nodes[1:]
+                D[h] = D.get(h, 0) + sum(D.get(t, 0) for t in tails)
+                for t in tails:
+                    D[t] = 0
+        
+        all_nodes = sorted(D.keys())
+        
+        progress(0.20, desc="✓ Phase 1 complete")
+        
+        # =================================================================
+        # PHASE 1.5: MATRIX PREPARATION
+        # =================================================================
+        
+        progress(0.22, desc="📊 Preparing matrices...")
+        
+        # Load all matrices
+        C_vd = pd.read_excel(srcXlsx, sheet_name="Van_dist", header=None)
+        C_vt = pd.read_excel(srcXlsx, sheet_name="Van_dur", header=None)
+        C_dd = pd.read_excel(srcXlsx, sheet_name="Drone_dist", header=None)
+        C_dt = pd.read_excel(srcXlsx, sheet_name="Drone_dur", header=None)
+        
+        colLab = local_to_numeric_vector(C_vd.iloc[0, 1:].values)
+        rowLab = local_to_numeric_vector(C_vd.iloc[1:, 0].values)
+        
+        M_vd = local_to_numeric_matrix(C_vd.iloc[1:, 1:].values)
+        M_vt = local_to_numeric_matrix(C_vt.iloc[1:, 1:].values)
+        M_dd = local_to_numeric_matrix(C_dd.iloc[1:, 1:].values)
+        M_dt = local_to_numeric_matrix(C_dt.iloc[1:, 1:].values)
+        
+        # Filter zero-demand nodes
+        active_nodes = [n for n in all_nodes if D[n] > 0]
+        active_indices = [i for i, n in enumerate(rowLab) if n in active_nodes]
+        
+        M_vd_filt = M_vd[np.ix_(active_indices, active_indices)]
+        M_vt_filt = M_vt[np.ix_(active_indices, active_indices)]
+        M_dd_filt = M_dd[np.ix_(active_indices, active_indices)]
+        M_dt_filt = M_dt[np.ix_(active_indices, active_indices)]
+        
+        active_labels = [rowLab[i] for i in active_indices]
+        
+        # Save filtered matrices
+        with pd.ExcelWriter("Matrices2Dis_2B.xlsx", engine='openpyxl') as writer:
+            pd.DataFrame(M_vd_filt, index=active_labels, columns=active_labels).to_excel(writer, sheet_name='updated_van_dis')
+            pd.DataFrame(M_vt_filt, index=active_labels, columns=active_labels).to_excel(writer, sheet_name='updated_van_dur')
+            pd.DataFrame(M_dd_filt, index=active_labels, columns=active_labels).to_excel(writer, sheet_name='updated_drone_dis')
+            pd.DataFrame(M_dt_filt, index=active_labels, columns=active_labels).to_excel(writer, sheet_name='updated_drone_dur')
+        
+        print(f"[Info] Matrices filtered: {len(all_nodes)} → {len(active_nodes)} active nodes")
+        
+        progress(0.25, desc="✓ Matrix prep complete")
+        
+        # =================================================================
+        # PHASE 2: TSP OPTIMIZATION
+        # =================================================================
+        
+        progress(0.30, desc="🔄 Phase 2: TSP Optimization...")
+        
+        D_tsp = pd.read_excel("Matrices2Dis_2B.xlsx", sheet_name="updated_van_dis", header=0, index_col=0).values
+        BestSol_tsp, BestCost_tsp, BestPos_tsp = optimize_tsp_domino(D_tsp, max_it=50, rounds=5, removeRate=0.2)
+        
+        print(f"[Info] TSP optimization complete. Best cost: {BestCost_tsp:.2f}")
+        
+        progress(0.40, desc="✓ Phase 2 complete")
+        
+        # =================================================================
+        # PHASE 2.5: FINAL MATRIX SETUP
+        # =================================================================
+        
+        progress(0.42, desc="📋 Final setup...")
+        
+        # Reorder by TSP solution
+        tsp_labels = [active_labels[i] for i in BestPos_tsp]
+        
+        # Remap depots: 0→101, 1→102
+        def remap_label(lbl):
+            if lbl == 0 or lbl == 0.0:
+                return 101
+            elif lbl == 1 or lbl == 1.0:
+                return 102
+            return lbl
+        
+        tsp_labels_remapped = [remap_label(l) for l in tsp_labels]
+        nodeLabel = np.array(tsp_labels_remapped, dtype=float)
+        
+        # Build id2idx mapping
+        id2idx = {int(lbl): i for i, lbl in enumerate(nodeLabel)}
+        
+        # Rebuild matrices in TSP order
+        n = len(nodeLabel)
+        C_vd_final = np.zeros((n, n))
+        C_vt_final = np.zeros((n, n))
+        C_dd_final = np.zeros((n, n))
+        C_dt_final = np.zeros((n, n))
+        
+        for i in range(n):
+            for j in range(n):
+                old_i = BestPos_tsp[i]
+                old_j = BestPos_tsp[j]
+                C_vd_final[i, j] = M_vd_filt[old_i, old_j]
+                C_vt_final[i, j] = M_vt_filt[old_i, old_j]
+                C_dd_final[i, j] = M_dd_filt[old_i, old_j]
+                C_dt_final[i, j] = M_dt_filt[old_i, old_j]
+        
+        # Update demand
+        Demand_final = {int(lbl): D.get(tsp_labels[i], 0) for i, lbl in enumerate(nodeLabel)}
+        
+        depots = {150: 101, 151: 102, 250: 101}
+        
+        progress(0.45, desc="✓ Setup complete")
+        
+        # =================================================================
+        # PHASE 3: BEES ALGORITHM
+        # =================================================================
+        
+        progress(0.50, desc="🐝 Phase 3: Bees Algorithm...")
+        
+        # Duration matrix dict
+        DurMat_dict = {150: C_vt_final, 151: C_vt_final, 250: C_dt_final}
+        
+        # Vehicle IDs
+        service_time_min = 2.5
+        Vehicle_ids = [250] * max_drones + [151, 150]
+        
+        # Greedy initial solution
+        customers = [lbl for lbl in nodeLabel if lbl not in [101, 102]]
+        route = []
+        for i, cust in enumerate(customers):
+            vid = Vehicle_ids[i % len(Vehicle_ids)]
+            route.extend([vid, cust])
+        
+        # Bees Algorithm
+        nBees = 10
+        maxIt = bees_iterations
+        
+        best_route = route[:]
+        best_cost = calculate_total_cost_mixed_fleet(
+            route, C_vd_final, C_vt_final, C_dd_final, C_dt_final,
+            Demand_final, Vehicle_ids, service_time_min, emission_weight
+        ) + calculate_pair_constraint_penalty(
+            route, Vehicle_ids, DurMat_dict, depots, id2idx, nodeLabel,
+            service_time_min, drone_pair_limit, 10.0
+        )
+        
+        for it in range(maxIt):
+            for bee in range(nBees):
+                # Foraging
+                new_route = foraging_combi(
+                    best_route, C_vd_final, C_vt_final, C_dd_final, C_dt_final,
+                    Demand_final, Vehicle_ids, 100, 100, 30, service_time_min,
+                    emission_weight, len(Vehicle_ids)
+                )
+                
+                # Penalty splitting
+                new_route = penalty_splitting_operator(
+                    new_route, C_vd_final, C_vt_final, C_dd_final, C_dt_final,
+                    Demand_final, Vehicle_ids, 100, 100, 30, service_time_min,
+                    emission_weight, len(Vehicle_ids)
+                )
+                
+                new_cost = calculate_total_cost_mixed_fleet(
+                    new_route, C_vd_final, C_vt_final, C_dd_final, C_dt_final,
+                    Demand_final, Vehicle_ids, service_time_min, emission_weight
+                ) + calculate_pair_constraint_penalty(
+                    new_route, Vehicle_ids, DurMat_dict, depots, id2idx, nodeLabel,
+                    service_time_min, drone_pair_limit, 10.0
+                )
+                
+                if new_cost < best_cost:
+                    best_route = new_route[:]
+                    best_cost = new_cost
+            
+            if it % 100 == 0:
+                prog = 0.50 + (it / maxIt) * 0.25
+                progress(prog, desc=f"🐝 Iteration {it}/{maxIt} - Best: £{best_cost:.2f}")
+        
+        split_routes = split_vehicle_routes(best_route, Vehicle_ids)
+        
+        print(f"Bees Algorithm complete. Best cost: £{best_cost:.2f}")
+        
+        progress(0.75, desc="✓ Phase 3 complete")
+        
+        # =================================================================
+        # PHASE 4: COST BREAKDOWN
+        # =================================================================
+        
+        progress(0.80, desc="💰 Phase 4: Cost Analysis...")
+        
+        cost_rows = []
+        seg_num = 1
+        
+        for seg in split_routes:
+            if not seg:
+                continue
+            
+            vid = int(seg[0])
+            vtype = 'bike' if vid == -1 else 'van' if vid in [150, 151] else 'drone'
+            
+            # Calculate metrics
+            depot_label = depots.get(vid, 101)
+            depot_idx = np.where(nodeLabel == depot_label)[0][0]
+            
+            route_indices = [depot_idx]
+            for i in range(1, len(seg)):
+                cust_idx = np.where(nodeLabel == seg[i])[0]
+                if len(cust_idx) > 0:
+                    route_indices.append(cust_idx[0])
+            route_indices.append(depot_idx)
+            
+            # Distance and time
+            dist, dur, dem = 0, 0, 0
+            DM = C_vd_final if vid in [150, 151] else C_dd_final
+            TM = C_vt_final if vid in [150, 151] else C_dt_final
+            
+            for i in range(len(route_indices) - 1):
+                dist += DM[route_indices[i], route_indices[i+1]]
+                dur += TM[route_indices[i], route_indices[i+1]]
+            
+            dur += service_time_min * (len(route_indices) - 2)
+            
+            for i in range(1, len(seg)):
+                dem += Demand_final.get(int(seg[i]), 0)
+            
+            # Costs
+            costs = vehicle_costs.get(vtype, vehicle_costs['van'])
+            fixed_cost = costs['fixed']
+            var_cost = costs['var'] * dist
+            labour_cost = costs['labour'] * (dur / 60)
+            emission_cost = costs['emission'] * dist
+            total = fixed_cost + var_cost + labour_cost + emission_cost
+            
+            cost_rows.append({
+                '#': seg_num,
+                'Vehicle': f"{vtype}-{vid}",
+                'Route': '-'.join(map(str, [int(x) for x in seg])),
+                'Distance': f"{dist:.2f}",
+                'Time (min)': f"{dur:.2f}",
+                'Demand': dem,
+                'Fixed GBP': f"{fixed_cost:.2f}",
+                'Variable GBP': f"{var_cost:.2f}",
+                'Labour GBP': f"{labour_cost:.2f}",
+                'Emission GBP': f"{emission_cost:.2f}",
+                'cost': f"{total:.2f}"
+            })
+            seg_num += 1
+        
+        cost_df = pd.DataFrame(cost_rows)
+        
+        with pd.ExcelWriter('Cost_Breakdown.xlsx', engine='openpyxl') as writer:
+            cost_df.to_excel(writer, sheet_name='breakdown', index=False)
+        
+        progress(0.85, desc="✓ Phase 4 complete")
+        
+        # =================================================================
+        # PHASE 5: SCHEDULE & STATISTICS
+        # =================================================================
+        
+        progress(0.90, desc="📅 Phase 5: Generating schedules...")
+        
+        # Count vehicles
+        bike_count = len(pd.read_csv(routesCsv))
+        van1_count = sum(1 for s in split_routes if s and s[0] == 150)
+        van2_count = sum(1 for s in split_routes if s and s[0] == 151)
+        drone_count = sum(1 for s in split_routes if s and s[0] == 250)
+        
+        stats_df = pd.DataFrame({
+            'Vehicle Type': ['Bike', 'Van-D1', 'Van-D2', 'Drone'],
+            'Count': [bike_count, van1_count, van2_count, drone_count]
+        })
+        stats_df.to_excel('Vehicle_Statistics.xlsx', index=False)
+        
+        # Fleet chart
+        plt.figure(figsize=(8, 6))
+        plt.bar(stats_df['Vehicle Type'], stats_df['Count'],
+                color=['#3498db', '#e74c3c', '#f39c12', '#2ecc71'])
+        plt.xlabel('Vehicle Type')
+        plt.ylabel('Count')
+        plt.title('Fleet Composition')
+        plt.tight_layout()
+        plt.savefig('Vehicle_Ratio_Chart.png', dpi=150)
+        plt.close()
+        
+        # Schedule
+        schedule_df = pd.DataFrame({
+            'Vehicle': ['Bike', 'Van-D1', 'Van-D2', 'Drone'],
+            'Routes': [bike_count, van1_count, van2_count, drone_count],
+            'Start Time': ['09:00'] * 4
+        })
+        
+        with pd.ExcelWriter('Vehicle_Schedule.xlsx', engine='openpyxl') as writer:
+            schedule_df.to_excel(writer, sheet_name='summary', index=False)
+        
+        progress(0.95, desc="✓ Phase 5 complete")
+        
+        # =================================================================
+        # GENERATE MAPS
+        # =================================================================
+        
+        progress(0.97, desc="🗺️ Generating route maps...")
+        
+        T = pd.read_csv(routesCsv)
+        create_route_maps(T, split_routes, nodeLabel, srcXlsx, depots)
+        
+        progress(1.0, desc="✅ Optimization Complete!")
+        
+        # =================================================================
+        # PACKAGE RESULTS
+        # =================================================================
+        
+        summary = f"""
+# ✅ Optimization Complete!
+
+## Fleet Composition
+{stats_df.to_markdown(index=False)}
+
+## Summary
+- **Total Vehicles:** {stats_df['Count'].sum()}
+- **Total Cost:** £{cost_df['cost'].astype(float).sum():,.2f}
+- **Emission Weight:** {emission_weight*100}%
+- **Drone Pair Limit:** {drone_pair_limit} min
+- **P-Hubs:** {p_hubs}
+
+## Download Files
+All results packaged in ZIP file below.
+        """
+        
+        # Create ZIP
+        output_files = [
+            'Cost_Breakdown.xlsx', 'Vehicle_Schedule.xlsx', 'Vehicle_Statistics.xlsx',
+            'Vehicle_Ratio_Chart.png', 'Route_Map_Straight.html', 'Route_Map_Roads.html'
+        ]
+        
+        zip_path = f'results_{datetime.now().strftime("%Y%m%d_%H%M%S")}.zip'
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zf:
+            for file in output_files:
+                if Path(file).exists():
+                    zf.write(file)
+        
+        return (
+            summary,
+            zip_path,
+            'Route_Map_Straight.html',
+            'Route_Map_Roads.html',
+            'Cost_Breakdown.xlsx',
+            'Vehicle_Schedule.xlsx',
+            'Vehicle_Ratio_Chart.png'
+        )
+        
+    except Exception as e:
+        error_msg = f"""
+# ❌ Optimization Failed
+
+**Error:** {str(e)}
+
+**Traceback:**
+```
+{traceback.format_exc()}
+```
+        """
+        return (error_msg, None, None, None, None, None, None)
+
+
+# ============================================================================
+# GRADIO INTERFACE
+# ============================================================================
+
+with gr.Blocks(title="Last-Mile Delivery Optimizer", theme=gr.themes.Soft()) as demo:
+    
+    gr.Markdown("""
+    # 🚚 Last-Mile Delivery Route Optimizer
+    
+    ### Multi-Modal Vehicle Routing with Configurable Costs & Emission Weighting
+    
+    Upload your Matrices2PY.xlsx file and configure optimization parameters below.
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 📁 Input File")
+            input_file = gr.File(
+                label="Upload Matrices2PY.xlsx",
+                file_types=[".xlsx"],
+                type="filepath"
+            )
+            
+            gr.Markdown("### ⚙️ Optimization Parameters")
+            
+            with gr.Accordion("🏢 General Settings", open=True):
+                p_hubs = gr.Slider(1, 50, value=30, step=1, label="Number of P-Hubs")
+                emission_weight = gr.Slider(0, 1, value=0.92, step=0.01, label="Emission Weight (0-1)")
+                drone_pair_limit = gr.Slider(30, 180, value=90, step=5, label="Drone Pair Duration Limit (min)")
+                max_drones = gr.Slider(1, 10, value=6, step=1, label="Maximum Drones")
+                bees_iterations = gr.Slider(100, 2000, value=1000, step=100, label="Bees Algorithm Iterations")
+            
+            with gr.Accordion("🚲 Bike Costs (£)", open=False):
+                gr.Markdown("Configure bike delivery costs")
+                fixed_bike = gr.Number(value=30, label="Fixed Cost per Route (£)")
+                var_bike = gr.Number(value=0.15, label="Variable Cost per km (£)")
+                labour_bike = gr.Number(value=12, label="Labour Cost per Hour (£)")
+                emission_bike = gr.Number(value=0, label="Emission Cost per km (£)")
+            
+            with gr.Accordion("🚐 Van Costs (£)", open=False):
+                gr.Markdown("Configure van delivery costs")
+                fixed_van = gr.Number(value=50, label="Fixed Cost per Route (£)")
+                var_van = gr.Number(value=0.30, label="Variable Cost per km (£)")
+                labour_van = gr.Number(value=15, label="Labour Cost per Hour (£)")
+                emission_van = gr.Number(value=0.15, label="Emission Cost per km (£)")
+            
+            with gr.Accordion("🛸 Drone Costs (£)", open=False):
+                gr.Markdown("Configure drone delivery costs")
+                fixed_drone = gr.Number(value=20, label="Fixed Cost per Route (£)")
+                var_drone = gr.Number(value=0, label="Variable Cost per km (£)")
+                labour_drone = gr.Number(value=20, label="Labour Cost per Hour (£)")
+                emission_drone = gr.Number(value=0, label="Emission Cost per km (£)")
+            
+            optimize_btn = gr.Button("🚀 Run Optimization", variant="primary", size="lg")
+            
+            gr.Markdown("""
+            ### 📊 Pipeline Phases
+            1. P-Hub Allocation & Bike Routes
+            2. TSP Optimization (Domino Algorithm)
+            3. Bees Algorithm with Pair Constraint
+            4. Cost Breakdown Analysis
+            5. Schedule Generation
+            6. Interactive Route Maps
+            """)
+        
+        with gr.Column(scale=2):
+            gr.Markdown("### 📊 Results")
+            
+            summary_output = gr.Markdown(label="Summary")
+            
+            with gr.Tabs():
+                with gr.Tab("📦 Downloads"):
+                    zip_output = gr.File(label="Complete Results Package (ZIP)")
+                    
+                    with gr.Row():
+                        cost_file = gr.File(label="Cost Breakdown")
+                        schedule_file = gr.File(label="Vehicle Schedule")
+                    
+                    chart_output = gr.Image(label="Fleet Composition Chart")
+                
+                with gr.Tab("🗺️ Route Map - Straight Lines"):
+                    map_straight = gr.HTML(label="All routes as straight lines")
+                
+                with gr.Tab("🛣️ Route Map - Following Roads"):
+                    map_roads = gr.HTML(label="Vans/bikes follow roads, drones fly")
+    
+    gr.Markdown("""
+    ---
+    ### 📋 Required Input Format
+    
+    Excel file must contain these sheets:
+    - **Van_dist** - Van distance matrix (km)
+    - **Van_dur** - Van duration matrix (min)
+    - **Drone_dist** - Drone distance matrix (km)
+    - **Drone_dur** - Drone duration matrix (min)
+    - **Bike_dist** - Bike distance matrix (miles)
+    - **Demand** - Customer demand data
+    - **Coordinate** - Node coordinates (lat, lon)
+    
+    ### 🎯 Optimization Features
+    - ✅ Multi-objective optimization (cost + emissions + penalties)
+    - ✅ Configurable vehicle costs
+    - ✅ Emission-weighted objective function
+    - ✅ Drone pair duration constraint (≤90 min)
+    - ✅ Vehicle capacity constraints
+    - ✅ Real-time progress tracking
+    - ✅ Interactive route maps with OpenStreetMap
+    
+    ---
+    
+    **Developed by:** Asrul | Heriot-Watt University | Transit Researcher  
+    **Research Focus:** Transport decarbonization, last-mile delivery electrification, multi-modal vehicle routing
+    """)
+    
+    # Connect button to function
+    optimize_btn.click(
+        fn=run_full_optimization,
+        inputs=[
+            input_file, p_hubs, emission_weight, drone_pair_limit, max_drones,
+            fixed_bike, var_bike, labour_bike, emission_bike,
+            fixed_van, var_van, labour_van, emission_van,
+            fixed_drone, var_drone, labour_drone, emission_drone,
+            bees_iterations
+        ],
+        outputs=[
+            summary_output,
+            zip_output,
+            map_straight,
+            map_roads,
+            cost_file,
+            schedule_file,
+            chart_output
+        ]
+    )
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )

bike_routes.py

@@ -0,0 +1,190 @@
+"""
+Bike route construction with constructive cycle algorithm
+"""
+
+import numpy as np
+import pandas as pd
+from typing import List, Tuple
+
+def build_bike_routes_constructive_cycle(phub, hubs, allocations, 
+                                         MaxRouteNodes=3, 
+                                         MaxTotalMinutes=25.0,
+                                         LoadingTime=2.5,
+                                         SaveCsvPath=''):
+    """
+    Build bike routes using constructive cycle algorithm with loading time.
+    
+    Args:
+        phub: PHubAllocation object
+        hubs: list of hub node indices
+        allocations: list of lists, allocations[i] contains nodes for hub hubs[i]
+        MaxRouteNodes: max nodes in route including hub (default 3)
+        MaxTotalMinutes: time cap per cycle (default 25)
+        LoadingTime: minutes added at each demand node (default 2.5)
+        SaveCsvPath: path to save CSV (optional)
+    
+    Returns:
+        DataFrame with columns: Hub, Route, Breakdown_Dur, Total_Duration_Min, 
+                                Feasible, Reason, Loading_Time
+    """
+    bike_dur = phub.matrices['bike']['dur']
+    demand = phub.demand
+    
+    rows = []
+    
+    for ii, h in enumerate(hubs):
+        # Nodes with positive demand
+        hub_nodes = allocations[ii]
+        unserved = [n for n in hub_nodes if demand[n] > 0]
+        
+        while unserved:
+            # Pick starting node by shortest simple cycle hub->n->hub
+            start_costs = []
+            start_nodes = []
+            
+            for n in unserved:
+                t_out = dur_safe(bike_dur, h, n)
+                t_back = dur_safe(bike_dur, n, h)
+                cyc = t_out + t_back
+                if np.isfinite(cyc):
+                    start_costs.append(cyc)
+                    start_nodes.append(n)
+            
+            if not start_costs:
+                # Mark all as unreachable
+                for n in unserved:
+                    rows.append({
+                        'Hub': h,
+                        'Route': route_to_str([h, n]),
+                        'Breakdown_Dur': "[NA(h->n), NA(n->h)]",
+                        'Total_Duration_Min': np.nan,
+                        'Feasible': False,
+                        'Reason': "No available bike link(s) (NaN)",
+                        'Loading_Time': LoadingTime
+                    })
+                unserved = []
+                break
+            
+            idx_min = np.argmin(start_costs)
+            n1 = start_nodes[idx_min]
+            
+            nodes = [n1]
+            total, legs = route_total_and_breakdown_with_loading(bike_dur, h, nodes, LoadingTime)
+            
+            # Try adding one more node if allowed
+            if len(nodes) + 1 < MaxRouteNodes:
+                best_extra_total = np.inf
+                best_extra_legs = []
+                best_n2 = None
+                
+                for n2 in unserved:
+                    if n2 == n1:
+                        continue
+                    ntot, nlegs = route_total_and_breakdown_with_loading(bike_dur, h, [n1, n2], LoadingTime)
+                    if np.isfinite(ntot) and ntot < best_extra_total:
+                        best_extra_total = ntot
+                        best_extra_legs = nlegs
+                        best_n2 = n2
+                
+                if best_n2 is not None and best_extra_total <= MaxTotalMinutes + 1e-9:
+                    nodes = [n1, best_n2]
+                    total = best_extra_total
+                    legs = best_extra_legs
+            
+            feasible = np.isfinite(total) and (total <= MaxTotalMinutes + 1e-9)
+            breakdown_str = breakdown_to_str(legs)
+            reason = ""
+            if not feasible:
+                if np.isfinite(total):
+                    reason = "Exceeded cap"
+                else:
+                    reason = "No available bike link(s) (NaN)"
+            
+            rows.append({
+                'Hub': h,
+                'Route': route_to_str([h] + nodes),
+                'Breakdown_Dur': breakdown_str,
+                'Total_Duration_Min': conditional_nan(total),
+                'Feasible': feasible,
+                'Reason': reason,
+                'Loading_Time': LoadingTime
+            })
+            
+            # Remove served nodes
+            for n in nodes:
+                if n in unserved:
+                    unserved.remove(n)
+    
+    T = pd.DataFrame(rows)
+    
+    if SaveCsvPath:
+        T.to_csv(SaveCsvPath, index=False)
+    
+    return T
+
+def dur_safe(dur_mat, i, j):
+    """Safe duration lookup, returns inf for NaN"""
+    v = dur_mat[i, j]
+    if np.isnan(v) or np.isinf(v):
+        return np.inf
+    return float(v)
+
+def route_total_and_breakdown_with_loading(dur_mat, hub, nodes, loading_time):
+    """
+    Calculate total time and breakdown for a route with loading times.
+    
+    Returns:
+        total: total time in minutes
+        legs: list of leg times including loading times
+    """
+    if not nodes:
+        return 0.0, []
+    
+    legs = []
+    total = 0.0
+    
+    # Hub -> first
+    t = dur_safe(dur_mat, hub, nodes[0])
+    if not np.isfinite(t):
+        return np.inf, []
+    legs.append(t)
+    total += t
+    
+    # Loading at first stop
+    legs.append(loading_time)
+    total += loading_time
+    
+    # Internal legs with loading on arrival
+    for k in range(len(nodes) - 1):
+        t_ab = dur_safe(dur_mat, nodes[k], nodes[k + 1])
+        if not np.isfinite(t_ab):
+            return np.inf, []
+        legs.append(t_ab)
+        total += t_ab
+        legs.append(loading_time)
+        total += loading_time
+    
+    # Last -> hub, no loading after return
+    t_back = dur_safe(dur_mat, nodes[-1], hub)
+    if not np.isfinite(t_back):
+        return np.inf, []
+    legs.append(t_back)
+    total += t_back
+    
+    return total, legs
+
+def route_to_str(v):
+    """Convert route to string representation"""
+    return "[" + ", ".join(str(x) for x in v) + "]"
+
+def breakdown_to_str(v):
+    """Convert breakdown to string representation"""
+    if not v:
+        return "[]"
+    return "[" + ", ".join(f"{x:.3f}" for x in v) + "]"
+
+def conditional_nan(v):
+    """Return rounded value if finite, else NaN"""
+    if np.isfinite(v):
+        return round(v, 3)
+    return np.nan

phub_allocation.py

@@ -0,0 +1,608 @@
+"""
+P-Hub Allocation class for hub selection and node assignment
+Complete implementation converted from MATLAB
+"""
+
+import numpy as np
+import pandas as pd
+from dataclasses import dataclass
+from typing import Dict, List, Tuple, Optional
+
+@dataclass
+class ModeInfo:
+    """Transport mode information"""
+    id: str
+    distance_cost: float
+    duration_cost: float
+    fixed_cost: float
+    max_dist: float
+    speed: float
+    max_duration: float
+
+class PHubAllocation:
+    """
+    P-Hub Allocation solver for multi-modal transportation networks.
+    
+    Solves hub location and customer assignment problems where:
+    - Source -> Hub uses {VAN, DRONE}
+    - Hub -> Node uses {BIKE}
+    - Hub -> Node must be <= 25 minutes (configurable)
+    
+    Matrices + coordinates + demand auto-loaded from Excel.
+    NaN entries are treated as "unavailable".
+    
+    Attributes:
+        excelPath (str): Path to input Excel file
+        nNodes (int): Number of nodes in the network
+        nodes (np.ndarray): Array of node indices
+        source (int): Source node index (0-based)
+        pHubs (int): Number of hubs to allocate
+        autoExpandHubs (bool): Auto-expand hubs if infeasible
+        matrices (dict): Distance and duration matrices for each mode
+        coordinates (np.ndarray): Node coordinates (n x 2)
+        demand (np.ndarray): Demand at each node (n x 1)
+        hnMaxMinutes (float): Maximum Hub->Node time in minutes
+        modes (dict): Mode parameters (van, bike, drone)
+        nodeOrder (np.ndarray): Order of node labels
+    """
+    
+    def __init__(self, excel_path: str, p_hubs: int = 4, random_seed: Optional[int] = None, 
+                 auto_expand_hubs: bool = True, n_nodes: Optional[int] = None, 
+                 sheet_map: Optional[Dict] = None):
+        """
+        Initialize P-Hub Allocation solver.
+        
+        Args:
+            excel_path: Path to Excel file with matrices
+            p_hubs: Number of hubs to allocate (default 4)
+            random_seed: Random seed for reproducibility (optional)
+            auto_expand_hubs: Auto-increase hubs if infeasible (default True)
+            n_nodes: Number of nodes (inferred from matrices if None)
+            sheet_map: Custom sheet name mapping (optional)
+        """
+        self.excelPath = excel_path
+        self.pHubs = p_hubs
+        self.autoExpandHubs = auto_expand_hubs
+        
+        if random_seed is not None:
+            np.random.seed(random_seed)
+        
+        # Default sheet mapping
+        if sheet_map is None:
+            self.sheetMap = {
+                'van_dist': 'Van_dist',
+                'van_dur': 'Van_dur',
+                'bike_dist': 'Bike_dist',
+                'bike_dur': 'Bike_dur',
+                'drone_dist': 'Drone_dist',
+                'drone_dur': 'Drone_dur',
+                'coord': 'Coordinate',
+                'demand': 'Demand'
+            }
+        else:
+            self.sheetMap = sheet_map
+        
+        # Load matrices
+        self.matrices = self.load_all_matrices_from_excel()
+        
+        # Determine number of nodes
+        inferred_n = self.matrices['bike']['dist'].shape[0]
+        self.nNodes = n_nodes if n_nodes is not None else inferred_n
+        
+        if n_nodes is not None and self.nNodes != inferred_n:
+            raise ValueError(f"nNodes={n_nodes} does not match Excel matrices ({inferred_n}).")
+        
+        self.nodes = np.arange(self.nNodes)
+        self.source = 0  # 0-based indexing in Python (MATLAB uses 1)
+        
+        # Define transport modes with costs
+        self.modes = {
+            'van': ModeInfo(
+                id="M1",
+                distance_cost=0.15,    # £/km
+                duration_cost=25.0,    # £/hour
+                fixed_cost=50.0,       # £
+                max_dist=200.0,        # km
+                speed=60.0,            # km/h
+                max_duration=8.0       # hours
+            ),
+            'bike': ModeInfo(
+                id="M2",
+                distance_cost=0.05,    # £/km
+                duration_cost=15.0,    # £/hour
+                fixed_cost=5.0,        # £
+                max_dist=15.0,         # km
+                speed=18.0,            # km/h
+                max_duration=1.0       # hours
+            ),
+            'drone': ModeInfo(
+                id="M3",
+                distance_cost=0.10,    # £/km
+                duration_cost=2.0,     # £/hour
+                fixed_cost=15.0,       # £
+                max_dist=80.0,         # km
+                speed=70.0,            # km/h
+                max_duration=1.5       # hours
+            )
+        }
+        
+        # Load coordinates and demand
+        self.coordinates = self.read_coordinates_sheet(self.sheetMap['coord'])
+        self.demand = self.read_demand_sheet(self.sheetMap['demand'])
+        self.demand[0] = 0  # Source has zero demand
+        
+        # Hub->Node maximum time constraint
+        self.hnMaxMinutes = 12.5
+    
+    def load_all_matrices_from_excel(self) -> Dict:
+        """
+        Load all distance and duration matrices from Excel.
+        
+        Returns:
+            Dict with structure: {'van': {'dist': arr, 'dur': arr}, ...}
+        """
+        # Load bike matrices first to determine node order
+        bike_dist, bike_nodes = self.read_matrix_sheet(self.sheetMap['bike_dist'])
+        bike_dur, bike_nodes2 = self.read_matrix_sheet(self.sheetMap['bike_dur'])
+        
+        # Determine node label order
+        if len(bike_nodes) > 0:
+            label_order = bike_nodes
+        elif len(bike_nodes2) > 0:
+            label_order = bike_nodes2
+        else:
+            label_order = np.arange(bike_dist.shape[0])
+        
+        self.nodeOrder = label_order
+        
+        # Load other matrices
+        van_dist, van_nodes = self.read_matrix_sheet(self.sheetMap['van_dist'])
+        van_dur, van_nodes2 = self.read_matrix_sheet(self.sheetMap['van_dur'])
+        drone_dist, drone_nodes = self.read_matrix_sheet(self.sheetMap['drone_dist'])
+        drone_dur, drone_nodes2 = self.read_matrix_sheet(self.sheetMap['drone_dur'])
+        
+        # Reindex if needed (simplified - assumes matching order)
+        # In production, you'd use reindexToOrder for each matrix
+        
+        # Zero diagonal NaN values
+        bike_dist = self.zero_diag_nans(bike_dist)
+        bike_dur = self.zero_diag_nans(bike_dur)
+        van_dist = self.zero_diag_nans(van_dist)
+        van_dur = self.zero_diag_nans(van_dur)
+        drone_dist = self.zero_diag_nans(drone_dist)
+        drone_dur = self.zero_diag_nans(drone_dur)
+        
+        return {
+            'van': {'dist': van_dist, 'dur': van_dur},
+            'bike': {'dist': bike_dist, 'dur': bike_dur},
+            'drone': {'dist': drone_dist, 'dur': drone_dur}
+        }
+    
+    def read_matrix_sheet(self, sheet_name: str) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Read matrix from Excel sheet.
+        
+        Args:
+            sheet_name: Name of Excel sheet
+        
+        Returns:
+            Tuple of (matrix, row_labels)
+        """
+        try:
+            # Try reading with labels in first row/column
+            df = pd.read_excel(self.excelPath, sheet_name=sheet_name, header=0, index_col=0)
+            core = df.values.astype(float)
+            labels = df.index.values.astype(float)
+            return core, labels
+        except Exception as e:
+            try:
+                # Fallback: read as raw cell array
+                C = pd.read_excel(self.excelPath, sheet_name=sheet_name, header=None)
+                
+                # Check for O-D marker
+                first_cell = str(C.iloc[0, 0]).lower() if not pd.isna(C.iloc[0, 0]) else ""
+                
+                if first_cell in ['o-d', 'od', 'o_d']:
+                    # Skip first row/column
+                    arr = C.iloc[1:, 1:].values
+                    return self.to_numeric_matrix(arr), np.array([])
+                
+                # Try extracting labels from first row/column
+                try:
+                    row_labels = self.to_numeric_vector(C.iloc[1:, 0].values)
+                    col_labels = self.to_numeric_vector(C.iloc[0, 1:].values)
+                    
+                    if (not np.any(np.isnan(row_labels)) and not np.any(np.isnan(col_labels))):
+                        # Filter to common labels
+                        common_mask = np.isin(row_labels, col_labels)
+                        common_rows = row_labels[common_mask]
+                        
+                        # Build column index map
+                        col_map = {col_labels[j]: j for j in range(len(col_labels))}
+                        col_idx = [col_map[r] for r in common_rows]
+                        
+                        # Extract matrix
+                        num_core = np.full((len(common_rows), len(common_rows)), np.nan)
+                        for i in range(len(common_rows)):
+                            for j in range(len(common_rows)):
+                                val = C.iloc[i + 1, col_idx[j] + 1]
+                                num_core[i, j] = float(val) if pd.notna(val) else np.nan
+                        
+                        return self.zero_diag_nans(num_core), common_rows
+                except:
+                    pass
+                
+                # Final fallback: numeric read
+                arr = pd.read_excel(self.excelPath, sheet_name=sheet_name, header=None).values
+                return self.to_numeric_matrix(arr), np.array([])
+                
+            except Exception as e2:
+                raise ValueError(f"Could not read sheet '{sheet_name}': {e2}")
+    
+    def read_coordinates_sheet(self, sheet_name: str) -> np.ndarray:
+        """
+        Read coordinates from Excel sheet.
+        
+        Args:
+            sheet_name: Name of Excel sheet
+        
+        Returns:
+            Array of shape (n, 2) with x, y coordinates
+        """
+        T = pd.read_excel(self.excelPath, sheet_name=sheet_name)
+        T.columns = [c.lower().strip() for c in T.columns]
+        
+        # Find x, y columns
+        if 'x' in T.columns and 'y' in T.columns:
+            xy = T[['x', 'y']].values
+        elif 'lon' in T.columns and 'lat' in T.columns:
+            xy = T[['lon', 'lat']].values
+        elif 'longitude' in T.columns and 'latitude' in T.columns:
+            xy = T[['longitude', 'latitude']].values
+        else:
+            # Use first two numeric columns
+            num_cols = [c for c in T.columns if pd.api.types.is_numeric_dtype(T[c])]
+            if len(num_cols) < 2:
+                raise ValueError(f"Coordinates sheet '{sheet_name}' needs at least two numeric columns.")
+            xy = T[num_cols[:2]].values
+        
+        # Ensure we have enough rows
+        if xy.shape[0] < self.nNodes:
+            raise ValueError(f"Coordinates sheet has {xy.shape[0]} rows, need {self.nNodes}.")
+        
+        return xy[:self.nNodes, :]
+    
+    def read_demand_sheet(self, sheet_name: str) -> np.ndarray:
+        """
+        Read demand from Excel sheet.
+        
+        Args:
+            sheet_name: Name of Excel sheet
+        
+        Returns:
+            Array of shape (n,) with demand values
+        """
+        T = pd.read_excel(self.excelPath, sheet_name=sheet_name)
+        T.columns = [c.lower().strip() for c in T.columns]
+        
+        # Find demand column
+        if 'demand' in T.columns:
+            d = T['demand'].values
+        else:
+            # Use first numeric column
+            num_cols = [c for c in T.columns if pd.api.types.is_numeric_dtype(T[c])]
+            if not num_cols:
+                raise ValueError(f"Demand sheet '{sheet_name}' needs a numeric column.")
+            d = T[num_cols[0]].values
+        
+        # Replace NaN with 0
+        d = np.nan_to_num(d, nan=0.0)
+        
+        # Ensure we have enough values
+        if len(d) < self.nNodes:
+            raise ValueError(f"Demand sheet has {len(d)} values, need {self.nNodes}.")
+        
+        return d[:self.nNodes]
+    
+    def zero_diag_nans(self, A: np.ndarray) -> np.ndarray:
+        """Set diagonal NaN values to zero."""
+        n = A.shape[0]
+        for i in range(n):
+            if np.isnan(A[i, i]):
+                A[i, i] = 0.0
+        return A
+    
+    def to_numeric_matrix(self, arr) -> np.ndarray:
+        """Convert array to numeric matrix, handling NaN."""
+        if isinstance(arr, np.ndarray) and np.issubdtype(arr.dtype, np.number):
+            return arr.astype(float)
+        
+        mat = np.zeros(arr.shape)
+        for i in range(arr.shape[0]):
+            for j in range(arr.shape[1]):
+                val = arr[i, j] if hasattr(arr, '__getitem__') else arr
+                if pd.notna(val):
+                    try:
+                        mat[i, j] = float(val)
+                    except (ValueError, TypeError):
+                        mat[i, j] = np.nan
+                else:
+                    mat[i, j] = np.nan
+        return mat
+    
+    def to_numeric_vector(self, vec) -> np.ndarray:
+        """Convert vector to numeric array."""
+        result = np.zeros(len(vec))
+        for i, val in enumerate(vec):
+            if pd.notna(val):
+                try:
+                    result[i] = float(val)
+                except (ValueError, TypeError):
+                    result[i] = np.nan
+            else:
+                result[i] = np.nan
+        return result
+    
+    def is_HN_feasible(self, dist_hn: float, dur_hn: float) -> bool:
+        """
+        Check if Hub->Node route is feasible.
+        
+        Args:
+            dist_hn: Distance in km
+            dur_hn: Duration in minutes
+        
+        Returns:
+            True if feasible, False otherwise
+        """
+        if np.isnan(dist_hn) or np.isnan(dur_hn):
+            return False
+        
+        b = self.modes['bike']
+        if dist_hn > b.max_dist + 1e-9:
+            return False
+        if dur_hn > min(b.max_duration * 60, self.hnMaxMinutes) + 1e-9:
+            return False
+        
+        return True
+    
+    def is_mode_feasible(self, distance: float, duration: float, info: ModeInfo) -> bool:
+        """
+        Check if mode is feasible for given distance/duration.
+        
+        Args:
+            distance: Distance in km
+            duration: Duration in minutes
+            info: Mode information
+        
+        Returns:
+            True if feasible, False otherwise
+        """
+        if np.isnan(distance) or np.isnan(duration):
+            return False
+        if distance > info.max_dist + 1e-9:
+            return False
+        if duration > info.max_duration * 60 + 1e-9:
+            return False
+        return True
+    
+    def calc_cost(self, distance: float, duration: float, info: ModeInfo, demand: float) -> float:
+        """
+        Calculate cost for given route.
+        
+        Args:
+            distance: Distance in km
+            duration: Duration in minutes
+            info: Mode information
+            demand: Demand to transport
+        
+        Returns:
+            Total cost in £
+        """
+        if np.isnan(distance) or np.isnan(duration):
+            raise ValueError('Tried to compute cost with NaN distance/duration — route unavailable.')
+        
+        distance_cost = info.distance_cost * distance
+        duration_cost = info.duration_cost * (duration / 60.0)
+        fixed_cost = info.fixed_cost
+        
+        return (distance_cost + duration_cost + fixed_cost) * demand
+    
+    def best_mode_SH(self, hub: int, hub_demand: float) -> Tuple[str, ModeInfo]:
+        """
+        Find best mode for Source->Hub.
+        
+        Args:
+            hub: Hub node index
+            hub_demand: Total demand at hub
+        
+        Returns:
+            Tuple of (mode_name, mode_info)
+        """
+        best_cost = np.inf
+        best_mode = ""
+        best_info = None
+        
+        for k in ['van', 'drone']:
+            info = self.modes[k]
+            dist = self.matrices[k]['dist'][self.source, hub]
+            dur = self.matrices[k]['dur'][self.source, hub]
+            
+            if not self.is_mode_feasible(dist, dur, info):
+                continue
+            
+            cost = self.calc_cost(dist, dur, info, hub_demand)
+            if cost < best_cost:
+                best_cost = cost
+                best_mode = k
+                best_info = info
+        
+        if best_cost == np.inf:
+            raise ValueError(f'No feasible S->H mode for hub {hub}')
+        
+        return best_mode, best_info
+    
+    def select_hubs_k_center(self, p_target: int) -> np.ndarray:
+        """
+        Select hubs using k-center algorithm.
+        
+        Iteratively selects hubs to maximize minimum distance between
+        customers and their nearest hub.
+        
+        Args:
+            p_target: Number of hubs to select
+        
+        Returns:
+            Array of hub indices
+        """
+        hubs = [self.source]  # Start with source node
+        bike_dist = self.matrices['bike']['dist']
+        
+        while len(hubs) < p_target:
+            dmin = np.zeros(self.nNodes)
+            
+            for i in range(self.nNodes):
+                if i in hubs:
+                    dmin[i] = 0.0
+                else:
+                    # Distance to nearest hub
+                    vals = [bike_dist[h, i] if not np.isnan(bike_dist[h, i]) else np.inf 
+                           for h in hubs]
+                    dmin[i] = min(vals)
+            
+            # Select node farthest from all hubs
+            next_hub = np.argmax(dmin)
+            
+            # If already selected, find alternative
+            if next_hub in hubs:
+                candidates = [i for i in range(self.nNodes) if i not in hubs]
+                if not candidates:
+                    break
+                
+                d_to_h = []
+                for i in candidates:
+                    vals = [bike_dist[h, i] if not np.isnan(bike_dist[h, i]) else np.inf 
+                           for h in hubs]
+                    d_to_h.append((i, min(vals)))
+                
+                next_hub = max(d_to_h, key=lambda x: x[1])[0]
+            
+            hubs.append(next_hub)
+        
+        return np.array(hubs)
+    
+    def assign_nodes_bike_feasible(self, hubs: np.ndarray) -> Tuple[List, List]:
+        """
+        Assign nodes to hubs based on bike feasibility.
+        
+        Each customer is assigned to the nearest hub where bike
+        delivery is feasible (satisfies distance and time constraints).
+        
+        Args:
+            hubs: Array of hub indices
+        
+        Returns:
+            Tuple of (allocations, infeasible) where:
+            - allocations: List of lists, allocations[i] = customers for hub i
+            - infeasible: List of customers that cannot be assigned
+        """
+        allocations = [[] for _ in range(len(hubs))]
+        infeasible = []
+        
+        bike_dist = self.matrices['bike']['dist']
+        bike_dur = self.matrices['bike']['dur']
+        
+        for node in range(self.nNodes):
+            if node in hubs:
+                continue
+            
+            # Sort hubs by distance to this node
+            distances = [(h, bike_dist[h, node] if not np.isnan(bike_dist[h, node]) else np.inf) 
+                        for h in hubs]
+            distances.sort(key=lambda x: x[1])
+            
+            # Try hubs in order of distance
+            chosen = None
+            for h, _ in distances:
+                d_hn = bike_dist[h, node]
+                t_hn = bike_dur[h, node]
+                
+                if self.is_HN_feasible(d_hn, t_hn):
+                    chosen = h
+                    break
+            
+            if chosen is None:
+                infeasible.append(node)
+            else:
+                k = list(hubs).index(chosen)
+                allocations[k].append(node)
+        
+        return allocations, infeasible
+    
+    def solve(self) -> Tuple[np.ndarray, List, float, Dict, int, Dict]:
+        """
+        Solve p-hub allocation problem.
+        
+        Returns:
+            Tuple of:
+            - hubs: Array of hub indices
+            - allocations: List of customer assignments per hub
+            - total_cost: Total cost in £
+            - sh_modes: Dict with Source->Hub mode info
+            - p_eff: Effective number of hubs used
+            - cost_breakdown: Dict with cost components
+        """
+        p_eff = self.pHubs
+        
+        while True:
+            # Select hubs
+            hubs = self.select_hubs_k_center(p_eff)
+            
+            # Assign customers to hubs
+            allocations, infeasible = self.assign_nodes_bike_feasible(hubs)
+            
+            if not infeasible:
+                break
+            
+            if self.autoExpandHubs and p_eff < self.nNodes:
+                p_eff += 1
+            else:
+                raise ValueError(f'Infeasible nodes with p={p_eff}. Increase p_hubs or adjust constraints.')
+        
+        # Prepare Source->Hub modes
+        sh_modes = {'modeName': [], 'info': []}
+        for i, h in enumerate(hubs):
+            hub_nodes = allocations[i]
+            hub_demand = sum(self.demand[n] for n in hub_nodes)
+            mname, mi = self.best_mode_SH(h, hub_demand)
+            sh_modes['modeName'].append(mname)
+            sh_modes['info'].append(mi)
+        
+        # Calculate costs
+        total_cost = 0.0
+        cost_breakdown = {'S_to_H': 0.0, 'H_to_N': 0.0, 'fixed': 0.0}
+        
+        for i, h in enumerate(hubs):
+            hub_nodes = allocations[i]
+            hub_demand = sum(self.demand[n] for n in hub_nodes)
+            
+            # Source->Hub cost
+            mname = sh_modes['modeName'][i]
+            mi = sh_modes['info'][i]
+            distSH = self.matrices[mname]['dist'][self.source, h]
+            durSH = self.matrices[mname]['dur'][self.source, h]
+            sh_cost = self.calc_cost(distSH, durSH, mi, hub_demand)
+            total_cost += sh_cost
+            cost_breakdown['S_to_H'] += sh_cost - mi.fixed_cost * hub_demand
+            cost_breakdown['fixed'] += mi.fixed_cost * hub_demand
+            
+            # Hub->Node costs
+            for n in hub_nodes:
+                distHN = self.matrices['bike']['dist'][h, n]
+                durHN = self.matrices['bike']['dur'][h, n]
+                b = self.modes['bike']
+                hn_cost = self.calc_cost(distHN, durHN, b, self.demand[n])
+                total_cost += hn_cost
+                cost_breakdown['H_to_N'] += hn_cost - b.fixed_cost * self.demand[n]
+                cost_breakdown['fixed'] += b.fixed_cost * self.demand[n]
+        
+        return hubs, allocations, total_cost, sh_modes, p_eff, cost_breakdown

requirements.txt

@@ -0,0 +1,16 @@
+# Core Streamlit and Data Processing
+streamlit>=1.28.0
+pandas>=2.0.0
+numpy>=1.24.0
+openpyxl>=3.1.0
+
+# Visualization
+folium>=0.14.0
+matplotlib>=3.7.0
+
+# HTTP requests for OSRM routing
+requests>=2.31.0
+
+# Optional: If you need these, uncomment
+# scipy>=1.10.0
+# scikit-learn>=1.3.0

tsp_optimizer.py

@@ -0,0 +1,197 @@
+"""
+TSP optimization using DOMINO algorithm
+Complete implementation converted from MATLAB
+"""
+
+import numpy as np
+from typing import Tuple, List
+
+class Tile:
+    """Solution container for TSP optimization"""
+    def __init__(self):
+        self.Position = None  # Tour array
+        self.Cost = np.inf    # Tour cost
+
+def Cost_tsp(tour: np.ndarray, D: np.ndarray) -> float:
+    """
+    Calculate TSP tour cost.
+    
+    Args:
+        tour: Array of node indices in tour order
+        D: Distance matrix (n x n)
+    
+    Returns:
+        Total tour cost (sum of edge costs including return to start)
+    """
+    n = len(tour)
+    cost = 0.0
+    
+    # Sum edges in tour
+    for i in range(n - 1):
+        cost += D[tour[i], tour[i + 1]]
+    
+    # Return to start
+    cost += D[tour[n - 1], tour[0]]
+    
+    return cost
+
+def DOMINO_CentroidOperator(Pos: np.ndarray, D: np.ndarray, removeRate: float) -> Tuple[np.ndarray, float]:
+    """
+    DOMINO Centroid Operator for TSP optimization.
+    
+    Removes a fraction of nodes from the tour and reinserts them
+    in random order to create a new solution.
+    
+    Args:
+        Pos: Current position (tour array)
+        D: Distance matrix
+        removeRate: Fraction of nodes to remove and reinsert (0.0 to 1.0)
+    
+    Returns:
+        Tuple of (new_position, new_cost)
+    """
+    n = len(Pos)
+    remove_num = max(1, round(removeRate * n))
+    
+    # Randomly select nodes to remove
+    remove_idx = np.sort(np.random.choice(n, remove_num, replace=False))
+    removed = [Pos[i] for i in remove_idx]
+    remaining = [Pos[i] for i in range(n) if i not in remove_idx]
+    
+    # Reinsert removed nodes randomly
+    newPos = np.zeros(n, dtype=int)
+    newPos[:len(remaining)] = remaining
+    
+    # Shuffle removed nodes and place at end
+    shuffled_removed = np.random.permutation(removed)
+    newPos[len(remaining):] = shuffled_removed
+    
+    newCost = Cost_tsp(newPos, D)
+    
+    return newPos, newCost
+
+def swap_route(route: np.ndarray) -> np.ndarray:
+    """
+    Swap two random positions in route.
+    
+    Args:
+        route: Current route
+    
+    Returns:
+        Route with two positions swapped
+    """
+    route_new = route.copy()
+    if len(route_new) < 2:
+        return route_new
+    
+    idx = np.random.choice(len(route_new), 2, replace=False)
+    route_new[idx[0]], route_new[idx[1]] = route_new[idx[1]], route_new[idx[0]]
+    
+    return route_new
+
+def reversion_route(route: np.ndarray) -> np.ndarray:
+    """
+    Reverse a random segment of route.
+    
+    Args:
+        route: Current route
+    
+    Returns:
+        Route with segment reversed
+    """
+    route_new = route.copy()
+    if len(route_new) < 2:
+        return route_new
+    
+    idx = np.sort(np.random.choice(len(route_new), 2, replace=False))
+    route_new[idx[0]:idx[1]+1] = route_new[idx[0]:idx[1]+1][::-1]
+    
+    return route_new
+
+def insertion_route(route: np.ndarray) -> np.ndarray:
+    """
+    Remove one element and insert at random position.
+    
+    Args:
+        route: Current route
+    
+    Returns:
+        Route with element moved
+    """
+    route_new = route.copy()
+    if len(route_new) < 2:
+        return route_new
+    
+    idx = np.random.choice(len(route_new), 2, replace=False)
+    i1, i2 = idx[0], idx[1]
+    
+    elem = route_new[i1]
+    route_new = np.delete(route_new, i1)
+    
+    if i2 > len(route_new):
+        route_new = np.append(route_new, elem)
+    else:
+        route_new = np.insert(route_new, i2, elem)
+    
+    return route_new
+
+def optimize_tsp_domino(D_tsp: np.ndarray, max_it: int = 50, rounds: int = 5, 
+                        removeRate: float = 0.2) -> Tuple[Tile, np.ndarray, List]:
+    """
+    Optimize TSP using DOMINO algorithm.
+    
+    The DOMINO algorithm maintains multiple parallel solutions (rounds) and
+    applies the centroid operator to explore the search space.
+    
+    Args:
+        D_tsp: Distance matrix (n x n)
+        max_it: Maximum iterations (default 50)
+        rounds: Number of parallel solutions (default 5)
+        removeRate: Fraction of tour to remove/reinsert (default 0.2)
+    
+    Returns:
+        Tuple of:
+        - BestSol: Best solution found (Tile object)
+        - BestCost: Array of best costs per iteration
+        - BestPos: List of best positions per iteration
+    """
+    n_tsp = D_tsp.shape[0]
+    
+    # Initialize tiles (parallel solutions)
+    tile = [Tile() for _ in range(rounds)]
+    for i in range(rounds):
+        tour = np.random.permutation(n_tsp)
+        tile[i].Position = tour
+        tile[i].Cost = Cost_tsp(tour, D_tsp)
+    
+    BestCost_tsp = np.zeros(max_it)
+    BestPos_tsp = [None] * max_it
+    
+    # Main optimization loop
+    for it in range(max_it):
+        # Update each solution
+        for i in range(rounds):
+            bestnew = Tile()
+            bestnew.Position = None
+            bestnew.Cost = np.inf
+            
+            # Try multiple neighborhood moves
+            for j in range(rounds):
+                newPos, newCost = DOMINO_CentroidOperator(tile[i].Position, D_tsp, removeRate)
+                if newCost < bestnew.Cost:
+                    bestnew.Position = newPos
+                    bestnew.Cost = newCost
+            
+            # Accept improvement
+            if bestnew.Cost < tile[i].Cost:
+                tile[i] = bestnew
+        
+        # Sort tiles by cost
+        tile.sort(key=lambda x: x.Cost)
+        BestSol_tsp = tile[0]
+        BestCost_tsp[it] = BestSol_tsp.Cost
+        BestPos_tsp[it] = BestSol_tsp.Position.copy()
+        
+        print(f'Iteration {it+1}: Best Cost = {BestCost_tsp[it]:.2f} units')
+    
+    return BestSol_tsp, BestCost_tsp, BestPos_tsp

utils.py

@@ -0,0 +1,94 @@
+"""
+Utility functions for data processing and conversion
+"""
+
+import numpy as np
+import pandas as pd
+import re
+
+def local_to_numeric_matrix(cell_mat):
+    """Convert cell array/DataFrame to numeric matrix"""
+    if isinstance(cell_mat, np.ndarray):
+        if len(cell_mat) == 0:
+            return np.array([])
+        if np.issubdtype(cell_mat.dtype, np.number):
+            return cell_mat.astype(float)
+    
+    # Convert to DataFrame if not already
+    if not isinstance(cell_mat, pd.DataFrame):
+        cell_mat = pd.DataFrame(cell_mat)
+    
+    mat = np.zeros(cell_mat.shape)
+    for i in range(cell_mat.shape[0]):
+        for j in range(cell_mat.shape[1]):
+            mat[i, j] = _coerce_to_double(cell_mat.iloc[i, j])
+    
+    return mat
+
+def local_to_numeric_vector(col):
+    """Convert column/row of labels to numeric vector"""
+    if isinstance(col, (list, np.ndarray, pd.Series)):
+        if len(col) == 0:
+            return np.array([])
+        
+        vec = np.zeros(len(col))
+        for i, val in enumerate(col):
+            vec[i] = _coerce_to_double(val)
+        return vec
+    
+    return np.array([_coerce_to_double(col)])
+
+def local_parse_route(route_str):
+    """Parse route string to list of integers"""
+    if isinstance(route_str, (list, np.ndarray)):
+        return list(route_str)
+    
+    if isinstance(route_str, (int, float)):
+        return [int(route_str)]
+    
+    if isinstance(route_str, str):
+        # Extract all numbers from string
+        numbers = re.findall(r'\d+', route_str)
+        return [int(n) for n in numbers]
+    
+    return []
+
+def local_find_coord_columns(T):
+    """Find longitude, latitude, and id column indices"""
+    cols = [c.lower() for c in T.columns]
+    
+    lonIdx = next((i for i, c in enumerate(cols) if any(x in c for x in ['lon', 'x', 'longitude'])), 0)
+    latIdx = next((i for i, c in enumerate(cols) if any(x in c for x in ['lat', 'y', 'latitude'])), 1)
+    idIdx = next((i for i, c in enumerate(cols) if any(x in c for x in ['id', 'node'])), 2)
+    
+    return lonIdx, latIdx, idIdx
+
+def _coerce_to_double(x):
+    """Convert single value to float with safe rules"""
+    if isinstance(x, (int, float, np.number)):
+        return float(x)
+    
+    if isinstance(x, str):
+        s = x.strip()
+        if s == "" or s == "-" or s == "—" or s.upper() in ["NA", "N/A"]:
+            return np.nan
+        # Extract numeric part
+        s = re.sub(r'[^\d\.\-eE]', '', s)
+        try:
+            return float(s)
+        except ValueError:
+            return np.nan
+    
+    if pd.isna(x):
+        return np.nan
+    
+    return np.nan
+
+def Cost_tsp(tour, D):
+    """Calculate TSP tour cost"""
+    n = len(tour)
+    cost = 0.0
+    for i in range(n - 1):
+        cost += D[tour[i], tour[i + 1]]
+    cost += D[tour[n - 1], tour[0]]
+    return cost

vehicle_routing.py

@@ -0,0 +1,545 @@
+"""
+Vehicle routing and cost calculation functions
+Complete implementation converted from MATLAB
+"""
+
+import numpy as np
+from typing import Dict, List, Tuple, Any
+
+def split_vehicle_routes(route: np.ndarray, vehicle_ids: List) -> List[List]:
+    """
+    Split route into segments by vehicle markers.
+    
+    A vehicle marker in the route indicates the start of a new segment
+    for that vehicle. Example: [150, 5, 7, 151, 9, 12] becomes two segments:
+    [150, 5, 7] and [151, 9, 12].
+    
+    Args:
+        route: Array of node/vehicle IDs
+        vehicle_ids: List of vehicle ID markers (e.g., [150, 151, 250])
+    
+    Returns:
+        List of route segments, each starting with a vehicle ID
+    """
+    vehset = np.isin(route, vehicle_ids)
+    routes = []
+    cur = []
+    
+    for k in range(len(route)):
+        node = route[k]
+        if vehset[k]:
+            # Start of new vehicle segment
+            if len(cur) > 1:
+                routes.append(cur)
+            cur = [node]
+        else:
+            # Customer node
+            if len(cur) == 0:
+                cur = [node]
+            else:
+                cur.append(node)
+    
+    # Add last segment if valid
+    if len(cur) > 1:
+        routes.append(cur)
+    
+    return routes
+
+def calculate_total_cost_mixed_fleet(depots: Dict, route: np.ndarray, 
+                                     DistMat_dict: Dict, DurMat_dict: Dict, 
+                                     demandMap: Dict, vmap: Dict, id2idx: Dict, 
+                                     service_time_min: float, penalty_fee: float, 
+                                     vehicle_ids: np.ndarray, weights: Dict, 
+                                     Max250: int) -> Tuple[float, float, np.ndarray, np.ndarray, np.ndarray, np.ndarray, float]:
+    """
+    Calculate total cost for mixed fleet routing.
+    
+    Computes weighted objective including fixed, variable, labour, emission costs
+    and penalties for time/capacity violations and unserved customers.
+    
+    Args:
+        depots: Dict mapping vehicle_id -> depot_label (e.g., {150: 101, 151: 102, 250: 101})
+        route: Array of route (vehicle IDs + customer labels)
+        DistMat_dict: Dict of distance matrices per vehicle {vid: matrix}
+        DurMat_dict: Dict of duration matrices per vehicle {vid: matrix}
+        demandMap: Dict mapping customer_label -> demand
+        vmap: Dict mapping vehicle_id -> vehicle params dict
+        id2idx: Dict mapping label -> matrix index
+        service_time_min: Service time per customer (minutes)
+        penalty_fee: Penalty coefficient (£)
+        vehicle_ids: Array of vehicle IDs
+        weights: Dict with 'fix', 'var', 'lab', 'emis' weights
+        Max250: Max number of vehicle 250 allowed
+    
+    Returns:
+        Tuple of (total_cost, total_time, travel_times, time_penalties, 
+                  cap_penalties, capacities, total_emissions)
+    """
+    total_variable_cost = 0.0
+    total_labour_cost = 0.0
+    total_emission_cost = 0.0
+    total_fixed_cost = 0.0
+    total_time_penalty = 0.0
+    total_capacity_penalty = 0.0
+    total_emissions = 0.0
+    total_time = 0.0
+    
+    travel_times = []
+    time_penalties = []
+    cap_penalties = []
+    capacities = []
+    
+    # Global 250-cap penalty
+    count250 = np.sum(route == 250)
+    if count250 > Max250:
+        over = count250 - Max250
+        total_time_penalty += penalty_fee * (5000 + 100 * over)
+    
+    # Split route into vehicle segments
+    routes = split_vehicle_routes(route, vehicle_ids)
+    
+    for vr in routes:
+        if not vr:
+            continue
+        
+        vid = int(vr[0])
+        if vid not in vmap:
+            continue
+        
+        params = vmap[vid]
+        base = depots[vid]
+        DM = DistMat_dict[vid]
+        TM = DurMat_dict[vid]
+        
+        # 250 single-customer constraint
+        if vid == 250:
+            num_customers_250 = sum(1 for x in vr[1:] if x not in vehicle_ids)
+            if num_customers_250 > 1:
+                over = num_customers_250 - 1
+                total_time_penalty += penalty_fee * (1000 + over)
+        
+        travel_time = 0.0
+        travel_dist = 0.0
+        cap = 0.0
+        
+        # Calculate travel along route
+        for i in range(len(vr) - 1):
+            u = int(vr[i])
+            v = int(vr[i + 1])
+            
+            if u not in id2idx or v not in id2idx:
+                continue
+            
+            u_idx = id2idx[u]
+            v_idx = id2idx[v]
+            dij = DM[u_idx, v_idx]
+            tij = TM[u_idx, v_idx]
+            
+            travel_dist += dij
+            travel_time += tij
+            
+            # Add service time if next node is customer
+            if v not in vehicle_ids:
+                travel_time += service_time_min
+                if v in demandMap:
+                    cap += demandMap[v]
+            
+            # Accumulate costs
+            total_variable_cost += params['var_cost'] * dij
+            total_labour_cost += params['time_cost'] * (tij / 60.0)
+            total_emission_cost += (params['emission_rate'] * params['emission_factor']) * dij
+            total_emissions += params['emission_factor'] * dij
+        
+        # Return to base if last node is customer
+        last = int(vr[-1])
+        if last not in vehicle_ids:
+            if last in id2idx and int(base) in id2idx:
+                last_idx = id2idx[last]
+                base_idx = id2idx[int(base)]
+                dij = DM[last_idx, base_idx]
+                tij = TM[last_idx, base_idx]
+                
+                travel_dist += dij
+                travel_time += tij
+                total_variable_cost += params['var_cost'] * dij
+                total_labour_cost += params['time_cost'] * (tij / 60.0)
+                total_emission_cost += (params['emission_rate'] * params['emission_factor']) * dij
+                total_emissions += params['emission_factor'] * dij
+        
+        # Fixed cost per vehicle
+        total_fixed_cost += params['fixed_cost']
+        
+        # Penalties for constraint violations
+        tpen = 0.0
+        cpen = 0.0
+        if travel_time > params['MaxTime']:
+            tpen = penalty_fee * (travel_time - params['MaxTime'])
+        if cap > params['capacity']:
+            cpen = penalty_fee * (cap - params['capacity'])
+        
+        travel_times.append(travel_time)
+        time_penalties.append(tpen)
+        cap_penalties.append(cpen)
+        capacities.append(cap)
+        
+        total_time += travel_time
+        total_time_penalty += tpen
+        total_capacity_penalty += cpen
+    
+    # Penalty for unserved customers
+    served = set()
+    for node in route:
+        nid = int(node)
+        if nid in demandMap and demandMap[nid] > 0:
+            served.add(nid)
+    
+    positive_cust = [k for k, v in demandMap.items() if v > 0]
+    missing = set(positive_cust) - served
+    if missing:
+        total_time_penalty += penalty_fee * len(missing)
+    
+    # Weighted objective
+    total_cost = (weights['fix'] * total_fixed_cost + 
+                  weights['var'] * total_variable_cost +
+                  weights['lab'] * total_labour_cost + 
+                  weights['emis'] * total_emission_cost +
+                  total_time_penalty + total_capacity_penalty)
+    
+    return (total_cost, total_time, np.array(travel_times), 
+            np.array(time_penalties), np.array(cap_penalties), 
+            np.array(capacities), total_emissions)
+
+def foraging_combi(route: np.ndarray, Vehicle_ids: List) -> np.ndarray:
+    """
+    Apply random operator from set of route operators.
+    
+    Randomly selects and applies one of: swap, reversion, insertion, or depot mutation.
+    
+    Args:
+        route: Current route
+        Vehicle_ids: List of vehicle IDs
+    
+    Returns:
+        Modified route
+    """
+    ops = [
+        lambda r: swap_route(r),
+        lambda r: reversion_route(r),
+        lambda r: insertion_route(r),
+        lambda r: depot_mutation(r, Vehicle_ids)
+    ]
+    op = np.random.choice(ops)
+    return op(route)
+
+def depot_mutation(route: np.ndarray, Vehicle_ids: List) -> np.ndarray:
+    """
+    Mutate depot/vehicle assignments.
+    
+    Randomly changes a vehicle marker to a different vehicle or removes it.
+    
+    Args:
+        route: Current route
+        Vehicle_ids: List of vehicle IDs
+    
+    Returns:
+        Modified route
+    """
+    route_new = route.copy()
+    depot_idx = np.where(np.isin(route_new, Vehicle_ids))[0]
+    
+    if len(depot_idx) > 0:
+        idx = np.random.choice(depot_idx)
+        if np.random.rand() < 0.5:
+            # Change to different vehicle
+            choices = [v for v in Vehicle_ids if v != route_new[idx]]
+            if choices:
+                route_new[idx] = np.random.choice(choices)
+        else:
+            # Remove depot marker (if not at boundaries)
+            if idx > 0 and idx < len(route_new) - 1:
+                route_new = np.delete(route_new, idx)
+    
+    return route_new
+
+def swap_route(route: np.ndarray) -> np.ndarray:
+    """
+    Swap two random positions in route.
+    
+    Args:
+        route: Current route
+    
+    Returns:
+        Route with two positions swapped
+    """
+    route_new = route.copy()
+    if len(route_new) < 2:
+        return route_new
+    
+    idx = np.random.choice(len(route_new), 2, replace=False)
+    route_new[idx[0]], route_new[idx[1]] = route_new[idx[1]], route_new[idx[0]]
+    
+    return route_new
+
+def reversion_route(route: np.ndarray) -> np.ndarray:
+    """
+    Reverse random segment of route.
+    
+    Args:
+        route: Current route
+    
+    Returns:
+        Route with segment reversed
+    """
+    route_new = route.copy()
+    if len(route_new) < 2:
+        return route_new
+    
+    idx = np.sort(np.random.choice(len(route_new), 2, replace=False))
+    route_new[idx[0]:idx[1]+1] = route_new[idx[0]:idx[1]+1][::-1]
+    
+    return route_new
+
+def insertion_route(route: np.ndarray) -> np.ndarray:
+    """
+    Remove and reinsert element at random position.
+    
+    Args:
+        route: Current route
+    
+    Returns:
+        Route with element moved
+    """
+    route_new = route.copy()
+    if len(route_new) < 2:
+        return route_new
+    
+    idx = np.random.choice(len(route_new), 2, replace=False)
+    i1, i2 = idx[0], idx[1]
+    
+    elem = route_new[i1]
+    route_new = np.delete(route_new, i1)
+    
+    if i2 > len(route_new):
+        route_new = np.append(route_new, elem)
+    else:
+        route_new = np.insert(route_new, i2, elem)
+    
+    return route_new
+
+def penalty_splitting_operator(route: np.ndarray, DurMat_dict: Dict, demandMap: Dict, 
+                               vmap: Dict, depots: Dict, DistMat_dict: Dict, 
+                               id2idx: Dict, vehicle_ids: np.ndarray, 
+                               service_time_min: float, repeat_split: bool) -> np.ndarray:
+    """
+    Split overlong vehicle segments by inserting additional vehicle marker.
+    
+    Identifies segments that exceed 1.2× their vehicle's time limit and splits
+    them by inserting a new vehicle marker near the midpoint customer.
+    
+    Args:
+        route: Current route
+        DurMat_dict: Duration matrices per vehicle
+        demandMap: Demand map
+        vmap: Vehicle parameters
+        depots: Depot assignments
+        DistMat_dict: Distance matrices per vehicle
+        id2idx: Label to index mapping
+        vehicle_ids: Vehicle IDs
+        service_time_min: Service time per customer
+        repeat_split: Whether to repeat splitting until all segments are valid
+    
+    Returns:
+        Modified route with split segments
+    """
+    vehs = vehicle_ids
+    new_route = route.copy()
+    
+    def segment_time_with_return(vr: List, vid: int) -> float:
+        """Calculate segment time including return to base."""
+        TM = DurMat_dict[vid]
+        base = depots[vid]
+        tmin = 0.0
+        
+        for i in range(len(vr) - 1):
+            u = int(vr[i])
+            v = int(vr[i + 1])
+            if u not in id2idx or v not in id2idx:
+                continue
+            ui = id2idx[u]
+            vi = id2idx[v]
+            tmin += TM[ui, vi]
+            
+            if v not in vehs:
+                tmin += service_time_min
+        
+        # Return to base
+        last = int(vr[-1])
+        if last not in vehs:
+            if last in id2idx and int(base) in id2idx:
+                li = id2idx[last]
+                bi = id2idx[int(base)]
+                tmin += TM[li, bi]
+        
+        return tmin
+    
+    def collapse_consecutive_vehicles(r1: np.ndarray, vehset: List) -> np.ndarray:
+        """Remove duplicate adjacent vehicle markers."""
+        if len(r1) == 0:
+            return r1
+        
+        keep = np.ones(len(r1), dtype=bool)
+        for k in range(1, len(r1)):
+            if r1[k] in vehset and r1[k-1] in vehset and r1[k] == r1[k-1]:
+                keep[k] = False
+        
+        return r1[keep]
+    
+    def do_one_pass(r_in: np.ndarray) -> np.ndarray:
+        """Perform one pass of splitting overlong segments."""
+        # Split into segments
+        segs = []
+        cur = []
+        for x in r_in:
+            if x in vehs:
+                if len(cur) > 1:
+                    segs.append(cur)
+                cur = [x]
+            else:
+                if len(cur) == 0:
+                    cur = [x]
+                else:
+                    cur.append(x)
+        if len(cur) > 1:
+            segs.append(cur)
+        
+        if not segs:
+            return r_in
+        
+        # Find overlong segments
+        is_long = []
+        for vr in segs:
+            vid = int(vr[0])
+            if vid not in vmap:
+                is_long.append(False)
+                continue
+            tmin = segment_time_with_return(vr, vid)
+            is_long.append(tmin > 1.2 * vmap[vid]['MaxTime'])
+        
+        if not any(is_long):
+            return r_in
+        
+        # Process long segments
+        for si, long in enumerate(is_long):
+            if not long:
+                continue
+            
+            vr = segs[si]
+            if len(vr) <= 3:
+                continue
+            
+            # Find midpoint customer
+            mid = len(vr) // 2
+            mid = max(2, min(mid, len(vr) - 1))
+            
+            if vr[mid] in vehs:
+                cust_idx = [i for i in range(2, len(vr)) if vr[i] not in vehs]
+                if not cust_idx:
+                    continue
+                mid = min(cust_idx, key=lambda i: abs(i - mid))
+            
+            cust_to_split = int(vr[mid])
+            if cust_to_split in vehs:
+                continue
+            
+            demand_c = demandMap.get(cust_to_split, 0)
+            
+            # Find feasible vehicles
+            feasible = [v for v in vehs if vmap[int(v)]['capacity'] >= demand_c]
+            if not feasible:
+                feasible = vehs
+            
+            # Pick closest depot
+            best_vid = int(vr[0])
+            best_d = np.inf
+            for dv in feasible:
+                dv = int(dv)
+                DM = DistMat_dict[dv]
+                if cust_to_split not in id2idx or depots[dv] not in id2idx:
+                    continue
+                cpos = id2idx[cust_to_split]
+                dpos = id2idx[depots[dv]]
+                dd = DM[dpos, cpos]
+                if dd < best_d:
+                    best_d = dd
+                    best_vid = dv
+            
+            # Insert new vehicle marker
+            vr_new = list(vr[:mid]) + [float(best_vid)] + list(vr[mid:])
+            segs[si] = collapse_consecutive_vehicles(np.array(vr_new), vehs).tolist()
+        
+        # Rebuild route
+        r_out = []
+        for seg in segs:
+            r_out.extend(seg)
+        
+        return collapse_consecutive_vehicles(np.array(r_out), vehs)
+    
+    # One pass
+    new_route = do_one_pass(new_route)
+    
+    # Repeat if requested
+    if repeat_split:
+        max_attempts = 10
+        attempt = 0
+        prev = None
+        while attempt < max_attempts and not np.array_equal(new_route, prev):
+            prev = new_route.copy() if new_route is not None else None
+            new_route = do_one_pass(new_route)
+            attempt += 1
+    
+    return new_route
+
+def route_cost_vehicle(route_idx: List, vid: int, DistMat_dict: Dict, 
+                       DurMat_dict: Dict, all_nodes: np.ndarray, 
+                       nodeLabel: np.ndarray, depots: Dict, vmap: Dict, 
+                       service_time_min: float, id2idx: Dict) -> Tuple[float, float, float]:
+    """
+    Calculate cost for a single vehicle route.
+    
+    Args:
+        route_idx: Route as indices
+        vid: Vehicle ID
+        DistMat_dict: Distance matrices
+        DurMat_dict: Duration matrices
+        all_nodes: All node labels
+        nodeLabel: Node label mapping
+        depots: Depot assignments
+        vmap: Vehicle parameters
+        service_time_min: Service time
+        id2idx: Label to index mapping
+    
+    Returns:
+        Tuple of (total_dist_km, total_time_min, total_cost_GBP)
+    """
+    DM = DistMat_dict[vid]
+    TM = DurMat_dict[vid]
+    labels = nodeLabel[route_idx]
+    pos = np.array([id2idx[int(lbl)] for lbl in labels])
+    
+    total_dist_km = 0.0
+    total_time_min = 0.0
+    
+    for i in range(len(pos) - 1):
+        dij = DM[pos[i], pos[i + 1]]
+        tij = TM[pos[i], pos[i + 1]]
+        total_dist_km += dij
+        total_time_min += tij
+    
+    if len(pos) > 2:
+        total_time_min += service_time_min * (len(pos) - 2)
+    
+    dist_cost = vmap[vid]['var_cost'] * total_dist_km
+    lab_cost = vmap[vid]['time_cost'] * (total_time_min / 60.0)
+    total_cost_GBP = vmap[vid]['fixed_cost'] + dist_cost + lab_cost
+    
+    return total_dist_km, total_time_min, total_cost_GBP