resolved data-validation issues

BENCHMARKING_GUIDE.md

@@ -0,0 +1,34 @@
+# Metro Schedule Generation - Benchmarking Guide
+
+This guide explains how to use the comprehensive benchmarking system to measure schedule generation performance for your research paper.
+
+## Overview
+
+The benchmark system measures:
+1. **Schedule Generation Time**: How long it takes to generate schedules for different fleet sizes
+2. **Computational Efficiency**: Performance comparison between different optimization methods
+
+## Data Generation
+
+The benchmark uses **EnhancedMetroDataGenerator** from DataService to create complete, realistic synthetic data including:
+- Trainset status and operational data
+- Fitness certificates
+- Job cards and maintenance records
+- Component health monitoring
+- IoT sensor data
+- Performance metrics
+
+This ensures that greedy optimizers are tested with realistic, complete datasets.
+
+## Components Tested
+
+### 1. MetroScheduleOptimizer (DataService)
+- Primary scheduling system
+- Fast, deterministic schedule generation
+- Uses route-based optimization
+
+### 2. Greedy Optimization Methods (greedyOptim)
+- **GA** (Genetic Algorithm): Evolutionary optimization
+- **CMA-ES**: Covariance Matrix Adaptation
+- **PSO** (Particle Swarm): Swarm intelligence
+- **SA** (Simulated Annealing): Probabilistic optimization

BENCHMARK_FIX_SUMMARY.md

@@ -0,0 +1,87 @@
+# Benchmark Fix Summary
+
+## Issue Fixed
+The greedyOptim methods (GA, PSO, CMA-ES, etc.) were failing with error: `'trainset_status'`
+
+## Root Cause
+The benchmark was creating incomplete synthetic data with only:
+```python
+synthetic_data = {
+    "trainsets": [...],  # Wrong key name!
+    "depot_layout": ...,
+    "date": ...
+}
+```
+
+But the `TrainsetSchedulingEvaluator` in greedyOptim expects a **complete dataset** with:
+- `trainset_status` (not "trainsets")
+- `fitness_certificates`
+- `job_cards`
+- `component_health`
+- `iot_sensors`
+- `branding_contracts`
+- `maintenance_schedule`
+- `performance_metrics`
+- And more...
+
+## Solution Applied
+✅ **Now using `EnhancedMetroDataGenerator` from DataService**
+
+The benchmark now properly generates complete synthetic data:
+
+```python
+from DataService.enhanced_generator import EnhancedMetroDataGenerator
+
+# Generate complete, realistic synthetic data
+generator = EnhancedMetroDataGenerator(num_trainsets=num_trains)
+synthetic_data = generator.generate_complete_enhanced_dataset()
+```
+
+This creates all required data structures that the greedyOptim evaluator needs.
+
+## Files Modified
+1. **benchmark_schedule_performance.py**
+   - Added import for `EnhancedMetroDataGenerator`
+   - Replaced manual data creation with proper generator call
+   - Added progress messages showing data generation stats
+
+2. **example_benchmark.py**
+   - Added note about data generation method
+   - Updated comments
+
+3. **BENCHMARKING_GUIDE.md**
+   - Added "Data Generation" section explaining the approach
+
+## Testing
+✅ Tested with command:
+```bash
+python benchmark_schedule_performance.py --fleet-sizes 10 --methods ga --runs 2
+```
+
+Result: **Successfully completed** - greedy optimizers now run without errors!
+
+## Benefits
+1. ✅ **Realistic Testing**: Greedy optimizers tested with complete, realistic data
+2. ✅ **Consistency**: Same data generation used across all benchmarks
+3. ✅ **Maintainability**: Leverages existing DataService infrastructure
+4. ✅ **Accuracy**: Results reflect real-world performance with full datasets
+
+## Next Steps for Research Paper
+You can now run the full benchmark:
+
+```bash
+# Full benchmark for research paper
+python benchmark_schedule_performance.py \
+  --fleet-sizes 10 15 20 25 30 40 \
+  --methods ga pso cmaes sa \
+  --runs 5
+```
+
+This will generate:
+- **JSON file**: Raw data with all metrics
+- **Text report**: Formatted summary with performance rankings
+- Data for your Results section on:
+  - Schedule generation time
+  - Computational efficiency comparisons
+  - Success rates
+  - Performance scaling with fleet size

DataService/enhanced_generator.py

@@ -256,7 +256,7 @@ class EnhancedMetroDataGenerator:
                     estimated_hours = random.randint(2, 24)
                 
                 job = {
-                    "job_card_id": f"JC-{random.randint(10000, 99999)}",
+                    "job_id": f"JC-{random.randint(10000, 99999)}",
                     "trainset_id": ts_id,
                     "work_order_number": f"WO-{random.randint(100000, 999999)}",
                     "job_type": random.choice(job_types),

README.md

@@ -1,191 +0,0 @@
-# Metro Train Scheduling Service
-
-This repository maintains two intelligent services that work together to optimize metro train scheduling:
-
-## 1. Optimization Engine (DataService)
-Traditional constraint-based optimization using OR-Tools for guaranteed valid schedules.
-
-## 2. Self-Training ML Engine (SelfTrainService)
-**Multi-Model Ensemble Learning** that continuously improves from real scheduling data.
-
-### ML Models Included:
-- **Gradient Boosting** (scikit-learn)
-- **Random Forest** (scikit-learn)
-- **XGBoost** - Extreme Gradient Boosting
-- **LightGBM** - Microsoft's high-performance gradient boosting
-- **CatBoost** - Yandex's categorical boosting
-
-### Ensemble Strategy:
-- Trains all 5 models simultaneously
-- Uses weighted ensemble voting for predictions
-- Weights based on individual model performance (R² score)
-- Automatically selects best single model as fallback
-- Higher prediction confidence when models agree
-
-## General Flow
-
-**Call a single endpoint** - the hybrid scheduler will internally decide:
-
-1. **ML First**: Try ensemble ML prediction
-   - If confidence > 75% → Use ML-generated schedule
-   - Models vote weighted by performance
-   
-2. **Optimization Fallback**: If ML confidence low
-   - Falls back to traditional OR-Tools optimization
-   - Guaranteed valid schedule
-
-3. **Continuous Learning**: Every 48 hours
-   - Automatically retrains all 5 models
-   - Uses accumulated real schedule data
-   - Updates ensemble weights
-   - Identifies new best model
-
-## Key Features
-
-✅ **Multi-Model Ensemble**: 5 state-of-the-art ML models working together  
-✅ **Auto-Retraining**: Retrains every 48 hours with new data  
-✅ **Confidence-Based**: Uses ML when confident, optimization as safety net  
-✅ **Performance Tracking**: Monitors each model's accuracy  
-✅ **Weighted Voting**: Better models have more influence  
-✅ **Best Model Selection**: Always knows which single model performs best  
-
-## Quick Start
-
-### 1. Install Dependencies
-```bash
-pip install -r requirements.txt
-```
-
-### 2. Generate Initial Training Data
-```bash
-python SelfTrainService/train_model.py
-```
-
-### 3. Start Auto-Retraining Service
-```bash
-python SelfTrainService/start_retraining.py
-```
-
-### 4. Start API Service
-```bash
-cd DataService
-python api.py
-```
-
-## Testing
-
-### Test Ensemble System
-```bash
-python SelfTrainService/test_ensemble.py
-```
-
-### Test API Endpoints
-```bash
-python test_api.py
-```
-
-## Model Performance
-
-After training, check model performance:
-- **Training summary**: `models/training_summary.json`
-- **Training history**: `models/training_history.json`
-- **Ensemble weights**: Shows contribution of each model
-
-Example output:
-```json
-{
-  "best_model": "xgboost",
-  "ensemble_weights": {
-    "gradient_boosting": 0.195,
-    "random_forest": 0.187,
-    "xgboost": 0.215,
-    "lightgbm": 0.208,
-    "catboost": 0.195
-  }
-}
-```
-
-## Configuration
-
-Edit `SelfTrainService/config.py`:
-
-```python
-RETRAIN_INTERVAL_HOURS = 48  # How often to retrain
-MODEL_TYPES = [              # Which models to use
-    "gradient_boosting",
-    "random_forest", 
-    "xgboost",
-    "lightgbm",
-    "catboost"
-]
-USE_ENSEMBLE = True          # Enable ensemble voting
-ML_CONFIDENCE_THRESHOLD = 0.75  # Min confidence to use ML
-```
-
-## Architecture
-
-```
-┌─────────────────┐
-│   API Request   │
-└────────┬────────┘
-         │
-         ▼
-┌─────────────────────┐
-│  Hybrid Scheduler   │
-└────────┬────────────┘
-         │
-    ┌────┴────┐
-    │         │
-    ▼         ▼
-┌────────┐  ┌──────────────┐
-│   ML   │  │ Optimization │
-│Ensemble│  │   (OR-Tools) │
-└───┬────┘  └──────┬───────┘
-    │              │
-    │ >75%    <75% │
-    │ confidence   │
-    │              │
-    └──────┬───────┘
-           │
-           ▼
-    ┌────────────┐
-    │  Schedule  │
-    └────────────┘
-```
-
-## Ensemble Advantages
-
-1. **Robustness**: Multiple models reduce overfitting risk
-2. **Accuracy**: Ensemble typically outperforms single models
-3. **Confidence**: Agreement between models indicates reliability
-4. **Adaptability**: Different models capture different patterns
-5. **Fault Tolerance**: If one model fails, others continue
-
-## Documentation
-
-- **Implementation Details**: See `docs/integrate.md`
-- **Multi-Objective Optimization**: See `multi_obj_optimize.md`
-- **API Reference**: See `DataService/api.py` docstrings
-
-## Project Structure
-
-```
-mlservice/
-├── DataService/           # Optimization & API
-│   ├── api.py            # FastAPI service
-│   ├── metro_models.py   # Data models
-│   ├── metro_data_generator.py
-│   └── schedule_optimizer.py
-├── SelfTrainService/      # ML ensemble
-│   ├── config.py         # Configuration
-│   ├── trainer.py        # Multi-model training
-│   ├── data_store.py     # Data persistence
-│   ├── feature_extractor.py
-│   ├── hybrid_scheduler.py
-│   ├── retraining_service.py
-│   ├── train_model.py    # Manual training
-│   ├── test_ensemble.py  # Test suite
-│   └── start_retraining.py
-└── requirements.txt
-```
-

api/greedyoptim_api.py

@@ -451,6 +451,13 @@ async def compare_methods(request: CompareMethodsRequest):
         best_method = None
         
         for method, result in results.items():
+            if result is None:
+                comparison["methods"][method] = {
+                    "success": False,
+                    "error": "Optimization failed for this method"
+                }
+                continue
+                
             comparison["methods"][method] = convert_result_to_response(
                 result, method
             ).dict()
@@ -460,7 +467,7 @@ async def compare_methods(request: CompareMethodsRequest):
                 best_method = method
         
         comparison["summary"]["best_method"] = best_method
-        comparison["summary"]["best_score"] = best_score
+        comparison["summary"]["best_score"] = best_score if best_method else None
         
         logger.info(f"Comparison completed, best: {best_method} ({best_score:.4f})")
         
@@ -488,14 +495,21 @@ async def generate_synthetic_data(request: SyntheticDataRequest):
         generator = EnhancedMetroDataGenerator(num_trainsets=request.num_trainsets)
         data = generator.generate_complete_enhanced_dataset()
         
-        # Filter to match request parameters
-        # (Optional: adjust availability based on request params)
+        # Remove trainset_profiles as it contains non-serializable datetime objects
+        # and is not needed for optimization
+        data_for_response = {
+            "trainset_status": data["trainset_status"],
+            "fitness_certificates": data["fitness_certificates"],
+            "job_cards": data["job_cards"],
+            "component_health": data["component_health"],
+            "metadata": data.get("metadata", {})
+        }
         
         logger.info(f"Generated synthetic data with {len(data['trainset_status'])} trainsets")
         
         return JSONResponse(content={
             "success": True,
-            "data": data,
+            "data": data_for_response,
             "metadata": {
                 "num_trainsets": len(data['trainset_status']),
                 "num_fitness_certificates": len(data['fitness_certificates']),

api/test_greedyoptim_api.py

@@ -205,11 +205,11 @@ def test_custom_data():
     print("Testing with Custom Minimal Data")
     print("="*70)
     
-    # Create minimal valid data
+    # Create minimal valid data with at least 15 available trainsets
     custom_data = {
         "trainset_status": [
-            {"trainset_id": f"KMRL-{i:02d}", "operational_status": "Available"}
-            for i in range(1, 11)
+            {"trainset_id": f"KMRL-{i:02d}", "operational_status": "Available", "total_mileage_km": 50000.0}
+            for i in range(1, 21)
         ],
         "fitness_certificates": [
             {
@@ -218,7 +218,7 @@ def test_custom_data():
                 "status": "Valid",
                 "expiry_date": (datetime.now() + timedelta(days=365)).isoformat()
             }
-            for i in range(1, 11)
+            for i in range(1, 21)
         ],
         "job_cards": [],  # No job cards
         "component_health": [
@@ -228,12 +228,12 @@ def test_custom_data():
                 "status": "Good",
                 "wear_level": 20.0
             }
-            for i in range(1, 11)
+            for i in range(1, 21)
         ],
         "method": "ga",
         "config": {
-            "required_service_trains": 8,
-            "min_standby": 1,
+            "required_service_trains": 15,
+            "min_standby": 2,
             "population_size": 20,
             "generations": 30
         }

benchmark_optimizers.py

@@ -0,0 +1,431 @@
+#!/usr/bin/env python3
+"""
+Benchmark script for comparing optimizer performance
+Measures schedule generation time and computational efficiency
+"""
+import time
+import json
+import statistics
+from datetime import datetime, date
+from typing import Dict, List, Any, Optional
+import sys
+import os
+
+# Add parent directory to path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from DataService.metro_data_generator import MetroDataGenerator
+from DataService.schedule_optimizer import MetroScheduleOptimizer
+from greedyOptim.scheduler import TrainsetSchedulingOptimizer
+from greedyOptim.genetic_algorithm import GeneticAlgorithmOptimizer
+from greedyOptim.ortools_optimizers import ORToolsOptimizer
+from greedyOptim.models import OptimizationConfig
+
+
+class OptimizerBenchmark:
+    """Benchmark different optimization algorithms"""
+    
+    def __init__(self, num_trains: int = 25, num_stations: int = 22):
+        self.results = {
+            "benchmark_info": {
+                "date": datetime.now().isoformat(),
+                "description": "Metro Schedule Optimization Performance Comparison"
+            },
+            "test_configurations": [],
+            "results": []
+        }
+        self.data_generator = MetroDataGenerator(num_trains=num_trains, num_stations=num_stations)
+    
+    def generate_test_data(self):
+        """Generate consistent test data for all optimizers"""
+        route = self.data_generator.generate_route(
+            route_name="Aluva-Pettah Line"
+        )
+        
+        trains = self.data_generator.generate_train_health_statuses()
+        # Limit to requested number
+        trains = trains[:num_trains]
+        
+        return route, trains
+    
+    def benchmark_optimizer(
+        self,
+        optimizer_name: str,
+        optimizer_class,
+        num_trains: int,
+        num_stations: int = 22,
+        num_runs: int = 3
+    ) -> Dict[str, Any]:
+        """Benchmark a single optimizer"""
+        print(f"\n{'='*70}")
+        print(f"Benchmarking: {optimizer_name}")
+        print(f"Fleet Size: {num_trains} trains | Stations: {num_stations}")
+        print(f"{'='*70}")
+        
+        run_times = []
+        success_count = 0
+        schedules_generated = []
+        
+        for run in range(num_runs):
+            print(f"\nRun {run + 1}/{num_runs}...", end=" ")
+            
+            try:
+                # Generate fresh data for each run
+                route, trains = self.generate_test_data(num_trains, num_stations)
+                
+                # Create request
+                request = ScheduleRequest(
+                    date=date.today(),
+                    num_trains=num_trains,
+                    route=route,
+                    trains=trains
+                )
+                
+                # Time the optimization
+                start_time = time.perf_counter()
+                
+                optimizer = optimizer_class()
+                schedule = optimizer.optimize(request)
+                
+                end_time = time.perf_counter()
+                elapsed = end_time - start_time
+                
+                run_times.append(elapsed)
+                success_count += 1
+                schedules_generated.append(schedule)
+                
+                print(f"✓ Completed in {elapsed:.4f}s")
+                
+            except Exception as e:
+                print(f"✗ Failed: {str(e)[:50]}")
+                continue
+        
+        # Calculate statistics
+        if run_times:
+            result = {
+                "optimizer": optimizer_name,
+                "fleet_size": num_trains,
+                "num_stations": num_stations,
+                "num_runs": num_runs,
+                "successful_runs": success_count,
+                "success_rate": f"{(success_count/num_runs)*100:.1f}%",
+                "execution_times": {
+                    "min_seconds": min(run_times),
+                    "max_seconds": max(run_times),
+                    "mean_seconds": statistics.mean(run_times),
+                    "median_seconds": statistics.median(run_times),
+                    "stdev_seconds": statistics.stdev(run_times) if len(run_times) > 1 else 0,
+                    "all_runs": run_times
+                },
+                "schedule_quality": self._analyze_schedules(schedules_generated) if schedules_generated else None
+            }
+        else:
+            result = {
+                "optimizer": optimizer_name,
+                "fleet_size": num_trains,
+                "num_stations": num_stations,
+                "num_runs": num_runs,
+                "successful_runs": 0,
+                "success_rate": "0%",
+                "error": "All runs failed"
+            }
+        
+        print(f"\nSummary:")
+        print(f"  Success Rate: {result['success_rate']}")
+        if run_times:
+            print(f"  Average Time: {result['execution_times']['mean_seconds']:.4f}s")
+            print(f"  Std Dev: {result['execution_times']['stdev_seconds']:.4f}s")
+        
+        return result
+    
+    def _analyze_schedules(self, schedules: List) -> Dict[str, Any]:
+        """Analyze quality metrics of generated schedules"""
+        if not schedules:
+            return None
+        
+        total_trips_list = []
+        trains_used_list = []
+        
+        for schedule in schedules:
+            if hasattr(schedule, 'trips'):
+                total_trips_list.append(len(schedule.trips))
+            if hasattr(schedule, 'train_schedules'):
+                trains_used_list.append(len(schedule.train_schedules))
+        
+        quality = {}
+        
+        if total_trips_list:
+            quality["trips"] = {
+                "mean": statistics.mean(total_trips_list),
+                "min": min(total_trips_list),
+                "max": max(total_trips_list)
+            }
+        
+        if trains_used_list:
+            quality["trains_utilized"] = {
+                "mean": statistics.mean(trains_used_list),
+                "min": min(trains_used_list),
+                "max": max(trains_used_list)
+            }
+        
+        return quality if quality else None
+    
+    def run_comprehensive_benchmark(
+        self,
+        fleet_sizes: List[int] = [5, 10, 15, 20, 25, 30],
+        num_runs: int = 3
+    ):
+        """Run comprehensive benchmark across all optimizers and fleet sizes"""
+        print("\n" + "="*70)
+        print("COMPREHENSIVE OPTIMIZER BENCHMARK")
+        print("="*70)
+        print(f"Fleet Sizes to Test: {fleet_sizes}")
+        print(f"Runs per Configuration: {num_runs}")
+        print("="*70)
+        
+        # Define optimizers to test
+        optimizers = [
+            ("Greedy Optimizer", GreedyScheduleOptimizer),
+            ("Genetic Algorithm", GeneticScheduleOptimizer),
+            ("OR-Tools CP-SAT", ORToolsScheduleOptimizer),
+        ]
+        
+        # Store test configurations
+        self.results["test_configurations"] = [
+            {
+                "fleet_sizes": fleet_sizes,
+                "num_stations": 22,
+                "runs_per_config": num_runs,
+                "optimizers": [name for name, _ in optimizers]
+            }
+        ]
+        
+        # Run benchmarks
+        for fleet_size in fleet_sizes:
+            print(f"\n{'#'*70}")
+            print(f"# FLEET SIZE: {fleet_size} TRAINS")
+            print(f"{'#'*70}")
+            
+            for optimizer_name, optimizer_class in optimizers:
+                result = self.benchmark_optimizer(
+                    optimizer_name,
+                    optimizer_class,
+                    fleet_size,
+                    num_runs=num_runs
+                )
+                self.results["results"].append(result)
+                
+                # Small delay between tests
+                time.sleep(0.5)
+        
+        # Generate comparison summary
+        self._generate_summary()
+    
+    def _generate_summary(self):
+        """Generate comparative summary of results"""
+        print("\n" + "="*70)
+        print("BENCHMARK SUMMARY")
+        print("="*70)
+        
+        # Group by fleet size
+        fleet_sizes = sorted(set(r["fleet_size"] for r in self.results["results"]))
+        
+        summary = {
+            "by_fleet_size": {},
+            "overall_rankings": {}
+        }
+        
+        for fleet_size in fleet_sizes:
+            fleet_results = [r for r in self.results["results"] if r["fleet_size"] == fleet_size]
+            
+            print(f"\nFleet Size: {fleet_size} trains")
+            print("-" * 70)
+            print(f"{'Optimizer':<25} {'Avg Time (s)':<15} {'Success Rate':<15}")
+            print("-" * 70)
+            
+            fleet_summary = []
+            for result in fleet_results:
+                optimizer = result["optimizer"]
+                avg_time = result["execution_times"]["mean_seconds"] if "execution_times" in result else "N/A"
+                success = result["success_rate"]
+                
+                if avg_time != "N/A":
+                    print(f"{optimizer:<25} {avg_time:<15.4f} {success:<15}")
+                    fleet_summary.append({
+                        "optimizer": optimizer,
+                        "avg_time": avg_time,
+                        "success_rate": success
+                    })
+                else:
+                    print(f"{optimizer:<25} {'FAILED':<15} {success:<15}")
+            
+            summary["by_fleet_size"][fleet_size] = fleet_summary
+        
+        # Overall performance ranking
+        print("\n" + "="*70)
+        print("OVERALL PERFORMANCE RANKING")
+        print("="*70)
+        
+        optimizer_avg_times = {}
+        for result in self.results["results"]:
+            if "execution_times" in result:
+                optimizer = result["optimizer"]
+                if optimizer not in optimizer_avg_times:
+                    optimizer_avg_times[optimizer] = []
+                optimizer_avg_times[optimizer].append(result["execution_times"]["mean_seconds"])
+        
+        rankings = []
+        for optimizer, times in optimizer_avg_times.items():
+            avg = statistics.mean(times)
+            rankings.append((optimizer, avg))
+        
+        rankings.sort(key=lambda x: x[1])
+        
+        print(f"\n{'Rank':<8} {'Optimizer':<25} {'Avg Time (s)':<15}")
+        print("-" * 70)
+        for rank, (optimizer, avg_time) in enumerate(rankings, 1):
+            print(f"{rank:<8} {optimizer:<25} {avg_time:<15.4f}")
+            summary["overall_rankings"][optimizer] = {
+                "rank": rank,
+                "avg_time_seconds": avg_time
+            }
+        
+        self.results["summary"] = summary
+    
+    def save_results(self, filename: str = None):
+        """Save benchmark results to JSON file"""
+        if filename is None:
+            filename = f"benchmark_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        
+        with open(filename, 'w') as f:
+            json.dump(self.results, f, indent=2, default=str)
+        
+        print(f"\n{'='*70}")
+        print(f"Results saved to: {filename}")
+        print(f"{'='*70}")
+        
+        return filename
+    
+    def generate_performance_report(self):
+        """Generate a formatted performance report"""
+        report_filename = f"performance_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
+        
+        with open(report_filename, 'w') as f:
+            f.write("="*80 + "\n")
+            f.write("METRO SCHEDULE OPTIMIZER PERFORMANCE REPORT\n")
+            f.write("="*80 + "\n\n")
+            f.write(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+            
+            # Executive Summary
+            f.write("EXECUTIVE SUMMARY\n")
+            f.write("-"*80 + "\n")
+            if "summary" in self.results and "overall_rankings" in self.results["summary"]:
+                f.write("\nOverall Performance Ranking:\n")
+                for optimizer, data in self.results["summary"]["overall_rankings"].items():
+                    f.write(f"  {data['rank']}. {optimizer}: {data['avg_time_seconds']:.4f}s average\n")
+            f.write("\n")
+            
+            # Detailed Results
+            f.write("\nDETAILED RESULTS BY FLEET SIZE\n")
+            f.write("-"*80 + "\n\n")
+            
+            for result in self.results["results"]:
+                f.write(f"Optimizer: {result['optimizer']}\n")
+                f.write(f"Fleet Size: {result['fleet_size']} trains\n")
+                f.write(f"Success Rate: {result['success_rate']}\n")
+                
+                if "execution_times" in result:
+                    f.write(f"Execution Time:\n")
+                    f.write(f"  Mean:   {result['execution_times']['mean_seconds']:.4f}s\n")
+                    f.write(f"  Median: {result['execution_times']['median_seconds']:.4f}s\n")
+                    f.write(f"  Min:    {result['execution_times']['min_seconds']:.4f}s\n")
+                    f.write(f"  Max:    {result['execution_times']['max_seconds']:.4f}s\n")
+                    f.write(f"  StdDev: {result['execution_times']['stdev_seconds']:.4f}s\n")
+                
+                if result.get("schedule_quality"):
+                    f.write(f"Schedule Quality:\n")
+                    if "trips" in result["schedule_quality"]:
+                        f.write(f"  Trips Generated (avg): {result['schedule_quality']['trips']['mean']:.1f}\n")
+                    if "trains_utilized" in result["schedule_quality"]:
+                        f.write(f"  Trains Utilized (avg): {result['schedule_quality']['trains_utilized']['mean']:.1f}\n")
+                
+                f.write("\n" + "-"*80 + "\n\n")
+            
+            # Recommendations
+            f.write("\nRECOMMENDATIONS\n")
+            f.write("-"*80 + "\n")
+            f.write("Based on the benchmark results:\n\n")
+            
+            if "summary" in self.results and "overall_rankings" in self.results["summary"]:
+                rankings = sorted(
+                    self.results["summary"]["overall_rankings"].items(),
+                    key=lambda x: x[1]["rank"]
+                )
+                if rankings:
+                    fastest = rankings[0]
+                    f.write(f"• {fastest[0]} showed the best overall performance\n")
+                    f.write(f"  with an average execution time of {fastest[1]['avg_time_seconds']:.4f}s\n\n")
+            
+            f.write("• Consider using faster optimizers for real-time scheduling\n")
+            f.write("• Slower optimizers may provide better solution quality for offline planning\n")
+            f.write("• Test with your specific constraints and requirements\n\n")
+        
+        print(f"Performance report saved to: {report_filename}")
+        return report_filename
+
+
+def main():
+    """Main execution function"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Benchmark metro schedule optimizers")
+    parser.add_argument(
+        "--fleet-sizes",
+        nargs="+",
+        type=int,
+        default=[5, 10, 15, 20, 25, 30],
+        help="Fleet sizes to test (default: 5 10 15 20 25 30)"
+    )
+    parser.add_argument(
+        "--runs",
+        type=int,
+        default=3,
+        help="Number of runs per configuration (default: 3)"
+    )
+    parser.add_argument(
+        "--quick",
+        action="store_true",
+        help="Quick test with fewer configurations"
+    )
+    
+    args = parser.parse_args()
+    
+    if args.quick:
+        fleet_sizes = [10, 20, 30]
+        num_runs = 2
+        print("\n*** QUICK BENCHMARK MODE ***")
+    else:
+        fleet_sizes = args.fleet_sizes
+        num_runs = args.runs
+    
+    # Run benchmark
+    benchmark = OptimizerBenchmark()
+    benchmark.run_comprehensive_benchmark(
+        fleet_sizes=fleet_sizes,
+        num_runs=num_runs
+    )
+    
+    # Save results
+    json_file = benchmark.save_results()
+    report_file = benchmark.generate_performance_report()
+    
+    print("\n" + "="*70)
+    print("BENCHMARK COMPLETE")
+    print("="*70)
+    print(f"JSON Results: {json_file}")
+    print(f"Text Report:  {report_file}")
+    print("="*70 + "\n")
+
+
+if __name__ == "__main__":
+    main()

benchmark_schedule_performance.py

@@ -0,0 +1,498 @@
+#!/usr/bin/env python3
+"""
+Comprehensive benchmark for schedule generation performance.
+Tests MetroScheduleOptimizer and greedyOptim methods across different fleet sizes.
+"""
+import time
+import statistics
+import json
+from datetime import datetime
+from typing import Dict, List, Any, Optional
+import sys
+import argparse
+
+# Import DataService components
+from DataService.schedule_optimizer import MetroScheduleOptimizer
+from DataService.metro_data_generator import MetroDataGenerator
+from DataService.enhanced_generator import EnhancedMetroDataGenerator
+
+# Import greedyOptim components
+from greedyOptim.scheduler import optimize_trainset_schedule
+from greedyOptim.models import OptimizationConfig
+
+
+class SchedulePerformanceBenchmark:
+    """Benchmark schedule generation performance"""
+    
+    def __init__(self):
+        self.results = {
+            "benchmark_info": {
+                "date": datetime.now().isoformat(),
+                "description": "Metro Schedule Generation Performance Analysis",
+                "test_type": "Schedule Generation Time & Computational Efficiency"
+            },
+            "configurations": [],
+            "detailed_results": [],
+            "summary": {}
+        }
+    
+    def benchmark_schedule_generation(
+        self,
+        num_trains: int,
+        num_stations: int = 22,
+        num_runs: int = 3
+    ) -> Dict[str, Any]:
+        """Benchmark the MetroScheduleOptimizer"""
+        print(f"\n{'='*70}")
+        print(f"Benchmarking Schedule Generation")
+        print(f"Fleet Size: {num_trains} trains | Stations: {num_stations}")
+        print(f"{'='*70}")
+        
+        run_times = []
+        success_count = 0
+        schedule_stats = []
+        
+        for run in range(num_runs):
+            print(f"\nRun {run + 1}/{num_runs}...", end=" ")
+            
+            try:
+                # Generate data
+                generator = MetroDataGenerator(num_trains=num_trains)
+                
+                route = generator.generate_route(route_name="Aluva-Pettah Line")
+                
+                train_health = generator.generate_train_health_statuses()
+                
+                # Time the schedule generation
+                start_time = time.perf_counter()
+                
+                optimizer = MetroScheduleOptimizer(
+                    date="2025-11-06",
+                    num_trains=num_trains,
+                    route=route,
+                    train_health=train_health
+                )
+                
+                schedule = optimizer.optimize_schedule()
+                
+                end_time = time.perf_counter()
+                elapsed = end_time - start_time
+                
+                run_times.append(elapsed)
+                success_count += 1
+                
+                # Collect schedule statistics
+                stats = {
+                    "num_trainsets": len(schedule.trainsets),
+                    "num_in_service": len([t for t in schedule.trainsets if t.status == "IN_SERVICE"]),
+                    "num_standby": len([t for t in schedule.trainsets if t.status == "STANDBY"]),
+                    "num_maintenance": len([t for t in schedule.trainsets if t.status == "UNDER_MAINTENANCE"]),
+                    "total_service_blocks": sum(len(t.service_blocks) for t in schedule.trainsets),
+                }
+                schedule_stats.append(stats)
+                
+                print(f"✓ {elapsed:.4f}s | In Service: {stats['num_in_service']}/{stats['num_trainsets']}")
+                
+            except Exception as e:
+                print(f"✗ Failed: {str(e)[:60]}")
+                continue
+        
+        # Calculate statistics
+        if run_times:
+            avg_stats = {}
+            if schedule_stats:
+                for key in schedule_stats[0].keys():
+                    values = [s[key] for s in schedule_stats]
+                    avg_stats[key] = {
+                        "mean": statistics.mean(values),
+                        "min": min(values),
+                        "max": max(values)
+                    }
+            
+            result = {
+                "optimizer": "MetroScheduleOptimizer",
+                "fleet_size": num_trains,
+                "num_stations": num_stations,
+                "num_runs": num_runs,
+                "successful_runs": success_count,
+                "success_rate": f"{(success_count/num_runs)*100:.1f}%",
+                "execution_time": {
+                    "min_seconds": min(run_times),
+                    "max_seconds": max(run_times),
+                    "mean_seconds": statistics.mean(run_times),
+                    "median_seconds": statistics.median(run_times),
+                    "stdev_seconds": statistics.stdev(run_times) if len(run_times) > 1 else 0,
+                    "all_runs_seconds": run_times
+                },
+                "schedule_statistics": avg_stats
+            }
+        else:
+            result = {
+                "optimizer": "MetroScheduleOptimizer",
+                "fleet_size": num_trains,
+                "num_stations": num_stations,
+                "num_runs": num_runs,
+                "successful_runs": 0,
+                "success_rate": "0%",
+                "error": "All runs failed"
+            }
+        
+        print(f"\nSummary:")
+        print(f"  Success Rate: {result['success_rate']}")
+        if run_times:
+            print(f"  Mean Time: {result['execution_time']['mean_seconds']:.4f}s")
+            print(f"  Std Dev: {result['execution_time']['stdev_seconds']:.4f}s")
+        
+        return result
+    
+    def benchmark_greedy_optimizers(
+        self,
+        num_trains: int,
+        methods: List[str] = ['ga', 'cmaes', 'pso'],
+        num_runs: int = 3
+    ) -> Dict[str, List[Dict[str, Any]]]:
+        """Benchmark greedyOptim methods"""
+        print(f"\n{'='*70}")
+        print(f"Benchmarking Greedy Optimization Methods")
+        print(f"Fleet Size: {num_trains} trains | Methods: {methods}")
+        print(f"{'='*70}")
+        
+        results_by_method = {}
+        
+        # Generate complete synthetic data using EnhancedMetroDataGenerator
+        print(f"Generating complete synthetic data for {num_trains} trains...")
+        try:
+            # Use EnhancedMetroDataGenerator for complete, realistic data
+            generator = EnhancedMetroDataGenerator(num_trainsets=num_trains)
+            synthetic_data = generator.generate_complete_enhanced_dataset()
+            
+            print(f"  ✓ Generated {len(synthetic_data['trainset_status'])} trainset statuses")
+            print(f"  ✓ Generated {len(synthetic_data['fitness_certificates'])} fitness certificates")
+            print(f"  ✓ Generated {len(synthetic_data['job_cards'])} job cards")
+            
+        except Exception as e:
+            print(f"✗ Failed to generate synthetic data: {e}")
+            import traceback
+            traceback.print_exc()
+            return results_by_method
+        
+        for method in methods:
+            print(f"\n--- Testing Method: {method.upper()} ---")
+            
+            run_times = []
+            success_count = 0
+            results = []
+            
+            for run in range(num_runs):
+                print(f"Run {run + 1}/{num_runs}...", end=" ")
+                
+                try:
+                    config = OptimizationConfig()
+                    
+                    start_time = time.perf_counter()
+                    result = optimize_trainset_schedule(synthetic_data, method, config)
+                    end_time = time.perf_counter()
+                    
+                    elapsed = end_time - start_time
+                    run_times.append(elapsed)
+                    success_count += 1
+                    results.append(result)
+                    
+                    print(f"✓ {elapsed:.4f}s | Score: {result.fitness_score:.4f}")
+                    
+                except Exception as e:
+                    print(f"✗ Failed: {str(e)[:50]}")
+                    continue
+            
+            if run_times:
+                method_result = {
+                    "method": method,
+                    "optimizer_family": "GreedyOptim",
+                    "fleet_size": num_trains,
+                    "num_runs": num_runs,
+                    "successful_runs": success_count,
+                    "success_rate": f"{(success_count/num_runs)*100:.1f}%",
+                    "execution_time": {
+                        "min_seconds": min(run_times),
+                        "max_seconds": max(run_times),
+                        "mean_seconds": statistics.mean(run_times),
+                        "median_seconds": statistics.median(run_times),
+                        "stdev_seconds": statistics.stdev(run_times) if len(run_times) > 1 else 0,
+                    },
+                    "optimization_scores": {
+                        "mean": statistics.mean([r.fitness_score for r in results]),
+                        "min": min([r.fitness_score for r in results]),
+                        "max": max([r.fitness_score for r in results]),
+                    }
+                }
+                results_by_method[method] = method_result
+            
+        return results_by_method
+    
+    def run_comprehensive_benchmark(
+        self,
+        fleet_sizes: List[int] = [10, 20, 30],
+        greedy_methods: List[str] = ['ga', 'cmaes', 'pso'],
+        num_runs: int = 3
+    ):
+        """Run comprehensive performance benchmark"""
+        print("\n" + "="*70)
+        print("COMPREHENSIVE SCHEDULE GENERATION PERFORMANCE BENCHMARK")
+        print("="*70)
+        print(f"Fleet Sizes: {fleet_sizes}")
+        print(f"Greedy Methods: {greedy_methods}")
+        print(f"Runs per Configuration: {num_runs}")
+        print("="*70)
+        
+        # Store configurations
+        self.results["configurations"].append({
+            "fleet_sizes": fleet_sizes,
+            "greedy_methods": greedy_methods,
+            "runs_per_config": num_runs,
+            "station_count": 22
+        })
+        
+        all_results = []
+        
+        for fleet_size in fleet_sizes:
+            print(f"\n{'#'*70}")
+            print(f"# FLEET SIZE: {fleet_size} TRAINS")
+            print(f"{'#'*70}")
+            
+            # Benchmark Schedule Generation
+            schedule_result = self.benchmark_schedule_generation(
+                num_trains=fleet_size,
+                num_runs=num_runs
+            )
+            all_results.append(schedule_result)
+            
+            # Benchmark Greedy Optimizers
+            greedy_results = self.benchmark_greedy_optimizers(
+                num_trains=fleet_size,
+                methods=greedy_methods,
+                num_runs=num_runs
+            )
+            
+            for method, result in greedy_results.items():
+                all_results.append(result)
+            
+            time.sleep(0.5)  # Brief pause between fleet sizes
+        
+        self.results["detailed_results"] = all_results
+        self._generate_performance_summary()
+    
+    def _generate_performance_summary(self):
+        """Generate comparative performance summary"""
+        print("\n" + "="*70)
+        print("PERFORMANCE SUMMARY")
+        print("="*70)
+        
+        # Group by fleet size
+        fleet_sizes = sorted(set(
+            r["fleet_size"] for r in self.results["detailed_results"]
+            if "fleet_size" in r
+        ))
+        
+        summary_by_fleet = {}
+        
+        for fleet_size in fleet_sizes:
+            fleet_results = [
+                r for r in self.results["detailed_results"]
+                if r.get("fleet_size") == fleet_size and "execution_time" in r
+            ]
+            
+            print(f"\n{'Fleet Size:':<20} {fleet_size} trains")
+            print("-" * 70)
+            print(f"{'Optimizer':<30} {'Mean Time (s)':<15} {'Success Rate':<15}")
+            print("-" * 70)
+            
+            fleet_summary = []
+            for result in fleet_results:
+                name = result.get("optimizer") or result.get("method", "Unknown")
+                mean_time = result["execution_time"]["mean_seconds"]
+                success = result["success_rate"]
+                
+                print(f"{name:<30} {mean_time:<15.4f} {success:<15}")
+                fleet_summary.append({
+                    "optimizer": name,
+                    "mean_time_seconds": mean_time,
+                    "success_rate": success
+                })
+            
+            summary_by_fleet[fleet_size] = fleet_summary
+        
+        # Overall rankings
+        print("\n" + "="*70)
+        print("OVERALL PERFORMANCE RANKINGS (by average time)")
+        print("="*70)
+        
+        optimizer_times = {}
+        for result in self.results["detailed_results"]:
+            if "execution_time" not in result:
+                continue
+            
+            name = result.get("optimizer") or result.get("method", "Unknown")
+            if name not in optimizer_times:
+                optimizer_times[name] = []
+            optimizer_times[name].append(result["execution_time"]["mean_seconds"])
+        
+        rankings = [
+            (name, statistics.mean(times))
+            for name, times in optimizer_times.items()
+        ]
+        rankings.sort(key=lambda x: x[1])
+        
+        print(f"\n{'Rank':<8} {'Optimizer/Method':<30} {'Avg Time (s)':<15}")
+        print("-" * 70)
+        for rank, (name, avg_time) in enumerate(rankings, 1):
+            print(f"{rank:<8} {name:<30} {avg_time:<15.4f}")
+        
+        self.results["summary"] = {
+            "by_fleet_size": summary_by_fleet,
+            "overall_rankings": {
+                name: {"rank": rank, "avg_time_seconds": avg_time}
+                for rank, (name, avg_time) in enumerate(rankings, 1)
+            },
+            "fastest_optimizer": rankings[0][0] if rankings else None,
+            "fastest_time_seconds": rankings[0][1] if rankings else None
+        }
+    
+    def save_results(self, filename: Optional[str] = None):
+        """Save benchmark results to JSON file"""
+        if filename is None:
+            filename = f"schedule_benchmark_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        
+        with open(filename, 'w') as f:
+            json.dump(self.results, f, indent=2, default=str)
+        
+        print(f"\n{'='*70}")
+        print(f"Results saved to: {filename}")
+        print(f"{'='*70}")
+        
+        return filename
+    
+    def generate_report(self):
+        """Generate formatted text report"""
+        report_filename = f"schedule_performance_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
+        
+        with open(report_filename, 'w') as f:
+            f.write("="*80 + "\n")
+            f.write("METRO SCHEDULE GENERATION PERFORMANCE REPORT\n")
+            f.write("="*80 + "\n\n")
+            f.write(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+            f.write(f"Test Type: Schedule Generation Time & Computational Efficiency\n\n")
+            
+            # Executive Summary
+            f.write("EXECUTIVE SUMMARY\n")
+            f.write("-"*80 + "\n\n")
+            
+            if "summary" in self.results and "fastest_optimizer" in self.results["summary"]:
+                f.write(f"Fastest Optimizer: {self.results['summary']['fastest_optimizer']}\n")
+                f.write(f"Best Average Time: {self.results['summary']['fastest_time_seconds']:.4f} seconds\n\n")
+            
+            # Rankings
+            if "summary" in self.results and "overall_rankings" in self.results["summary"]:
+                f.write("Overall Performance Rankings:\n")
+                for name, data in sorted(
+                    self.results["summary"]["overall_rankings"].items(),
+                    key=lambda x: x[1]["rank"]
+                ):
+                    f.write(f"  {data['rank']}. {name}: {data['avg_time_seconds']:.4f}s\n")
+                f.write("\n")
+            
+            # Detailed Results
+            f.write("\nDETAILED RESULTS\n")
+            f.write("-"*80 + "\n\n")
+            
+            for result in self.results["detailed_results"]:
+                name = result.get("optimizer") or result.get("method", "Unknown")
+                f.write(f"Optimizer/Method: {name}\n")
+                f.write(f"Fleet Size: {result.get('fleet_size', 'N/A')} trains\n")
+                f.write(f"Success Rate: {result.get('success_rate', 'N/A')}\n")
+                
+                if "execution_time" in result:
+                    f.write(f"Execution Time Statistics:\n")
+                    f.write(f"  Mean:   {result['execution_time']['mean_seconds']:.4f}s\n")
+                    f.write(f"  Median: {result['execution_time']['median_seconds']:.4f}s\n")
+                    f.write(f"  Min:    {result['execution_time']['min_seconds']:.4f}s\n")
+                    f.write(f"  Max:    {result['execution_time']['max_seconds']:.4f}s\n")
+                    f.write(f"  StdDev: {result['execution_time']['stdev_seconds']:.4f}s\n")
+                
+                if "optimization_scores" in result:
+                    f.write(f"Optimization Scores:\n")
+                    f.write(f"  Mean: {result['optimization_scores']['mean']:.4f}\n")
+                    f.write(f"  Min:  {result['optimization_scores']['min']:.4f}\n")
+                    f.write(f"  Max:  {result['optimization_scores']['max']:.4f}\n")
+                
+                f.write("\n" + "-"*80 + "\n\n")
+        
+        print(f"Performance report saved to: {report_filename}")
+        return report_filename
+
+
+def main():
+    """Main execution function"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(
+        description="Benchmark metro schedule generation performance"
+    )
+    parser.add_argument(
+        "--fleet-sizes",
+        nargs="+",
+        type=int,
+        default=[10, 20, 30],
+        help="Fleet sizes to test (default: 10 20 30)"
+    )
+    parser.add_argument(
+        "--methods",
+        nargs="+",
+        default=['ga', 'cmaes', 'pso'],
+        help="Greedy optimization methods to test (default: ga cmaes pso)"
+    )
+    parser.add_argument(
+        "--runs",
+        type=int,
+        default=3,
+        help="Number of runs per configuration (default: 3)"
+    )
+    parser.add_argument(
+        "--quick",
+        action="store_true",
+        help="Quick test with minimal configurations"
+    )
+    
+    args = parser.parse_args()
+    
+    if args.quick:
+        fleet_sizes = [10, 20]
+        methods = ['ga']
+        num_runs = 2
+        print("\n*** QUICK BENCHMARK MODE ***")
+    else:
+        fleet_sizes = args.fleet_sizes
+        methods = args.methods
+        num_runs = args.runs
+    
+    # Run benchmark
+    benchmark = SchedulePerformanceBenchmark()
+    benchmark.run_comprehensive_benchmark(
+        fleet_sizes=fleet_sizes,
+        greedy_methods=methods,
+        num_runs=num_runs
+    )
+    
+    # Save results
+    json_file = benchmark.save_results()
+    report_file = benchmark.generate_report()
+    
+    print("\n" + "="*70)
+    print("BENCHMARK COMPLETE")
+    print("="*70)
+    print(f"JSON Results: {json_file}")
+    print(f"Text Report:  {report_file}")
+    print("="*70 + "\n")
+
+
+if __name__ == "__main__":
+    main()

benchmarks/__init__.py

@@ -0,0 +1,10 @@
+"""
+Benchmarking Suite for Metro Train Scheduling System
+
+This package contains comprehensive benchmarking tools for:
+- Schedule generation performance
+- Fleet utilization analysis
+- Service quality metrics
+"""
+
+__version__ = '1.0.0'

benchmarks/fleet_utilization/README.md

@@ -0,0 +1,324 @@
+# Fleet Utilization Benchmarks
+
+This directory contains tools for analyzing fleet utilization metrics for the metro train scheduling system.
+
+## Overview
+
+Fleet utilization analysis provides critical data for the **Results** section of your research paper, specifically:
+
+1. **Minimum Fleet Size**: Calculate the minimum number of trains required to maintain service frequency
+2. **Coverage Efficiency**: Measure percentage of peak vs. off-peak demand covered
+3. **Train Utilization Rate**: Analyze average operational hours per train vs. idle time
+
+## Components
+
+### 1. `fleet_analyzer.py`
+Core analysis module with the `FleetUtilizationAnalyzer` class.
+
+**Key Features:**
+- Calculate minimum fleet size based on headway requirements
+- Analyze demand coverage (peak vs. off-peak)
+- Compute train utilization rates
+- Generate efficiency scores
+- Find optimal fleet configurations
+
+**Key Classes:**
+- `FleetUtilizationAnalyzer`: Main analysis engine
+- `FleetUtilizationMetrics`: Data class for results
+
+### 2. `benchmark_fleet_utilization.py`
+Comprehensive benchmarking script for research paper data collection.
+
+**Features:**
+- Test multiple fleet sizes
+- Comparative analysis
+- Statistical summaries
+- JSON and text report generation
+
+## Usage
+
+### Quick Start
+
+```bash
+# Run comprehensive benchmark
+python benchmark_fleet_utilization.py
+```
+
+This will:
+- Analyze fleet sizes from 10-40 trains
+- Calculate minimum requirements
+- Measure coverage efficiency
+- Compute utilization rates
+- Generate JSON data and text report
+
+### Custom Analysis
+
+```python
+from fleet_analyzer import FleetUtilizationAnalyzer
+
+analyzer = FleetUtilizationAnalyzer()
+
+# Analyze specific fleet size
+metrics = analyzer.analyze_fleet_configuration(
+    total_fleet=25,
+    trains_in_maintenance=2
+)
+
+print(f"Coverage: {metrics.overall_coverage_percent:.1f}%")
+print(f"Utilization: {metrics.utilization_rate_percent:.1f}%")
+
+# Find optimal fleet size
+optimal_size, optimal_metrics = analyzer.find_optimal_fleet_size(
+    min_coverage_required=95.0
+)
+print(f"Optimal Fleet: {optimal_size} trains")
+```
+
+### Programmatic Benchmark
+
+```python
+from benchmark_fleet_utilization import FleetUtilizationBenchmark
+
+benchmark = FleetUtilizationBenchmark()
+
+# Run custom analysis
+benchmark.run_comprehensive_analysis(
+    fleet_sizes=[15, 20, 25, 30, 35],
+    maintenance_rate=0.1
+)
+
+# Save results
+benchmark.save_results("my_results.json")
+benchmark.generate_report("my_report.txt")
+```
+
+## Kochi Metro Configuration
+
+The analyzer uses real Kochi Metro parameters:
+
+- **Route Length**: 25.612 km
+- **Average Speed**: 35 km/h (operating speed)
+- **Service Hours**: 5:00 AM - 11:00 PM (18 hours)
+- **Peak Hours**: 
+  - Morning: 7:00-10:00 AM
+  - Evening: 5:00-8:00 PM
+- **Target Headways**:
+  - Peak: 5 minutes
+  - Off-Peak: 10 minutes
+- **Turnaround Time**: 10 minutes
+
+## Output Files
+
+### JSON Results (`fleet_utilization_benchmark_*.json`)
+Complete data structure with:
+- Metadata and configuration
+- Detailed metrics for each fleet size
+- Comparative statistics
+- Optimal fleet configuration
+
+### Text Report (`fleet_utilization_report_*.txt`)
+Human-readable report with:
+- Executive summary
+- Optimal fleet configuration
+- Comparative analysis
+- Detailed results for each fleet size
+
+## Metrics Explained
+
+### 1. Minimum Fleet Size
+**Formula**: `(Round Trip Time / Headway) + Buffer + Maintenance Reserve`
+
+- Accounts for route travel time
+- Includes operational buffers
+- Considers maintenance requirements
+
+**Research Paper Usage:**
+> "Analysis revealed that a minimum fleet of 18 trains is required to maintain the target 5-minute headway during peak hours on the 25.612 km route."
+
+### 2. Coverage Efficiency
+
+**Metrics:**
+- Peak demand coverage (%)
+- Off-peak demand coverage (%)
+- Overall weighted coverage (%)
+
+**Research Paper Usage:**
+> "A fleet of 25 trains achieved 100% peak demand coverage and 98.5% overall coverage across the 18-hour service period."
+
+### 3. Train Utilization Rate
+
+**Metrics:**
+- Average operational hours per train
+- Average idle hours per train
+- Utilization rate percentage
+
+**Formula**: `Utilization % = (Operational Hours / 24) × 100`
+
+**Research Paper Usage:**
+> "Fleet utilization analysis demonstrated an average of 16.2 operational hours per train (67.5% utilization rate), with 7.8 hours of scheduled idle time for charging and maintenance."
+
+## Example Results
+
+### Minimum Fleet Size Analysis
+```
+Fleet Size: 25 trains
+Minimum Required: 18 trains
+Excess Capacity: 7 trains (38.9%)
+
+Peak Service: 15 trains
+Off-Peak Service: 8 trains
+Standby: 3 trains
+Maintenance: 2 trains
+```
+
+### Coverage Efficiency
+```
+Peak Demand Coverage: 100.0%
+Off-Peak Demand Coverage: 100.0%
+Overall Coverage: 100.0%
+```
+
+### Utilization Rates
+```
+Avg Operational Hours/Train: 16.20 hours/day
+Avg Idle Hours/Train: 7.80 hours/day
+Utilization Rate: 67.5%
+```
+
+## Visualization Tips for Paper
+
+### Suggested Graphs/Tables
+
+1. **Fleet Size vs. Coverage Graph**
+   - X-axis: Fleet Size (10-40 trains)
+   - Y-axis: Coverage Percentage
+   - Show peak and off-peak separately
+
+2. **Utilization Rate Table**
+   ```
+   Fleet Size | Operational Hours | Idle Hours | Utilization %
+   10         | 16.2             | 7.8        | 67.5%
+   15         | 16.2             | 7.8        | 67.5%
+   ...
+   ```
+
+3. **Efficiency Score Comparison**
+   - Bar chart showing fleet efficiency vs. cost efficiency
+   - Compare different fleet sizes
+
+4. **Optimal Fleet Configuration Diagram**
+   - Visual breakdown of train allocation
+   - Service / Standby / Maintenance distribution
+
+## Advanced Usage
+
+### Sensitivity Analysis
+
+```python
+analyzer = FleetUtilizationAnalyzer()
+
+# Test different maintenance rates
+for maintenance_rate in [0.05, 0.10, 0.15, 0.20]:
+    metrics = analyzer.analyze_fleet_configuration(
+        total_fleet=25,
+        trains_in_maintenance=int(25 * maintenance_rate)
+    )
+    print(f"Maintenance {maintenance_rate*100}%: Coverage {metrics.overall_coverage_percent:.1f}%")
+```
+
+### Peak Hour Variations
+
+```python
+# Modify peak hours
+analyzer.peak_periods = [
+    (time(6, 0), time(9, 0)),   # Earlier morning peak
+    (time(16, 0), time(19, 0)),  # Earlier evening peak
+]
+
+metrics = analyzer.analyze_fleet_configuration(25, 2)
+```
+
+## Integration with Other Benchmarks
+
+Combine with schedule generation benchmarks:
+
+```python
+from benchmark_schedule_performance import SchedulePerformanceBenchmark
+from benchmark_fleet_utilization import FleetUtilizationBenchmark
+
+# Performance benchmark
+perf_benchmark = SchedulePerformanceBenchmark()
+perf_results = perf_benchmark.run_comprehensive_benchmark(
+    fleet_sizes=[15, 20, 25, 30],
+    num_runs=5
+)
+
+# Fleet utilization benchmark
+fleet_benchmark = FleetUtilizationBenchmark()
+fleet_benchmark.run_comprehensive_analysis(
+    fleet_sizes=[15, 20, 25, 30]
+)
+
+# Cross-reference results for comprehensive analysis
+```
+
+## Research Paper Templates
+
+### Results Section Template
+
+```markdown
+### Fleet Utilization Results
+
+#### Minimum Fleet Size
+Analysis of the Kochi Metro route (25.612 km, 22 stations) revealed that a 
+minimum fleet of [X] trains is required to maintain target service frequencies. 
+This accounts for a [Y]-minute round-trip time, including [Z] minutes of 
+turnaround at terminal stations.
+
+#### Coverage Efficiency
+Fleet configuration testing demonstrated that:
+- Peak demand (7-10 AM, 5-8 PM) requires [N] trains for 5-minute headways
+- Off-peak periods require [M] trains for 10-minute headways
+- A fleet of [K] trains achieves [P]% overall coverage
+
+#### Train Utilization Rate
+Utilization analysis across fleet sizes from 10-40 trains showed:
+- Average operational hours: [H] hours per train per day
+- Average idle time: [I] hours per train per day  
+- Overall utilization rate: [U]%
+
+These metrics indicate [interpretation of efficiency/optimization].
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Import Errors**: Ensure you're running from the correct directory
+   ```bash
+   cd /path/to/mlservice
+   python benchmarks/fleet_utilization/benchmark_fleet_utilization.py
+   ```
+
+2. **Path Issues**: The benchmark automatically handles paths, but if needed:
+   ```python
+   sys.path.insert(0, '/path/to/mlservice')
+   ```
+
+## References
+
+- Kochi Metro operational parameters
+- Transit scheduling best practices
+- Fleet optimization literature
+
+## Future Enhancements
+
+- [ ] Integration with real-time passenger data
+- [ ] Dynamic headway adjustment
+- [ ] Multi-line analysis
+- [ ] Energy consumption correlation
+- [ ] Cost-benefit analysis with operational costs
+
+## Support
+
+For questions or issues, refer to the main project documentation or examine the example usage in `__main__` blocks of each module.

benchmarks/fleet_utilization/__init__.py

@@ -0,0 +1,25 @@
+"""
+Fleet Utilization Analysis Module
+
+Provides tools for analyzing metro train fleet utilization including:
+- Minimum fleet size calculations
+- Coverage efficiency metrics
+- Train utilization rate analysis
+"""
+
+from .fleet_analyzer import (
+    FleetUtilizationAnalyzer,
+    FleetUtilizationMetrics,
+    format_metrics_report
+)
+
+from .benchmark_fleet_utilization import FleetUtilizationBenchmark
+
+__all__ = [
+    'FleetUtilizationAnalyzer',
+    'FleetUtilizationMetrics',
+    'FleetUtilizationBenchmark',
+    'format_metrics_report'
+]
+
+__version__ = '1.0.0'

benchmarks/fleet_utilization/benchmark_fleet_utilization.py

@@ -0,0 +1,331 @@
+#!/usr/bin/env python3
+"""
+Comprehensive Fleet Utilization Benchmark
+Generates data for research paper Results section.
+"""
+import json
+import sys
+import os
+from datetime import datetime
+from typing import Dict, List, Any, Optional
+import statistics
+
+# Add parent directory to path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from benchmarks.fleet_utilization.fleet_analyzer import (
+    FleetUtilizationAnalyzer,
+    FleetUtilizationMetrics,
+    format_metrics_report
+)
+
+
+class FleetUtilizationBenchmark:
+    """Benchmark fleet utilization across different configurations"""
+    
+    def __init__(self):
+        self.analyzer = FleetUtilizationAnalyzer()
+        self.results = {
+            "metadata": {
+                "generated_at": datetime.now().isoformat(),
+                "system": "Kochi Metro Rail",
+                "analysis_type": "Fleet Utilization"
+            },
+            "configuration": {
+                "route_length_km": self.analyzer.route_length_km,
+                "avg_speed_kmh": self.analyzer.avg_speed_kmh,
+                "service_hours": self.analyzer.total_service_hours,
+                "peak_headway_minutes": self.analyzer.peak_headway_target,
+                "offpeak_headway_minutes": self.analyzer.offpeak_headway_target
+            },
+            "fleet_analyses": [],
+            "comparative_analysis": {},
+            "optimal_fleet": {}
+        }
+    
+    def run_comprehensive_analysis(
+        self,
+        fleet_sizes: Optional[List[int]] = None,
+        maintenance_rate: float = 0.1
+    ):
+        """
+        Run comprehensive fleet utilization analysis.
+        
+        Args:
+            fleet_sizes: List of fleet sizes to test (default: 10-40 by 5)
+            maintenance_rate: Percentage of fleet in maintenance
+        """
+        if fleet_sizes is None:
+            fleet_sizes = [10, 15, 20, 25, 30, 35, 40]
+        
+        print("="*70)
+        print("COMPREHENSIVE FLEET UTILIZATION BENCHMARK")
+        print("="*70)
+        print(f"Fleet Sizes to Test: {fleet_sizes}")
+        print(f"Maintenance Rate: {maintenance_rate*100:.0f}%")
+        print("="*70)
+        print()
+        
+        # Analyze each fleet size
+        for i, size in enumerate(fleet_sizes, 1):
+            print(f"[{i}/{len(fleet_sizes)}] Analyzing fleet size: {size} trains...")
+            
+            maintenance_trains = max(1, int(size * maintenance_rate))
+            metrics = self.analyzer.analyze_fleet_configuration(size, maintenance_trains)
+            
+            # Store results
+            result_dict = {
+                "fleet_size": metrics.fleet_size,
+                "minimum_required_trains": metrics.minimum_required_trains,
+                "trains_in_service_peak": metrics.trains_in_service_peak,
+                "trains_in_service_offpeak": metrics.trains_in_service_offpeak,
+                "trains_in_standby": metrics.trains_in_standby,
+                "trains_in_maintenance": metrics.trains_in_maintenance,
+                "peak_demand_coverage_percent": metrics.peak_demand_coverage_percent,
+                "offpeak_demand_coverage_percent": metrics.offpeak_demand_coverage_percent,
+                "overall_coverage_percent": metrics.overall_coverage_percent,
+                "avg_operational_hours_per_train": metrics.avg_operational_hours_per_train,
+                "avg_idle_hours_per_train": metrics.avg_idle_hours_per_train,
+                "utilization_rate_percent": metrics.utilization_rate_percent,
+                "fleet_efficiency_score": metrics.fleet_efficiency_score,
+                "cost_efficiency_score": metrics.cost_efficiency_score
+            }
+            
+            self.results["fleet_analyses"].append(result_dict)
+            
+            print(f"  ✓ Coverage: {metrics.overall_coverage_percent:.1f}%")
+            print(f"  ✓ Utilization: {metrics.utilization_rate_percent:.1f}%")
+            print(f"  ✓ Efficiency: {metrics.fleet_efficiency_score:.1f}/100")
+            print()
+        
+        # Comparative analysis
+        self._generate_comparative_analysis()
+        
+        # Find optimal fleet
+        self._find_optimal_configuration()
+        
+        print("="*70)
+        print("ANALYSIS COMPLETE")
+        print("="*70)
+    
+    def _generate_comparative_analysis(self):
+        """Generate comparative statistics across all fleet sizes"""
+        analyses = self.results["fleet_analyses"]
+        
+        if not analyses:
+            return
+        
+        # Extract metrics
+        coverage = [a["overall_coverage_percent"] for a in analyses]
+        utilization = [a["utilization_rate_percent"] for a in analyses]
+        efficiency = [a["fleet_efficiency_score"] for a in analyses]
+        
+        # Find best performers
+        best_coverage_idx = coverage.index(max(coverage))
+        best_utilization_idx = utilization.index(max(utilization))
+        best_efficiency_idx = efficiency.index(max(efficiency))
+        
+        self.results["comparative_analysis"] = {
+            "coverage_statistics": {
+                "min": min(coverage),
+                "max": max(coverage),
+                "mean": statistics.mean(coverage),
+                "median": statistics.median(coverage),
+                "stdev": statistics.stdev(coverage) if len(coverage) > 1 else 0
+            },
+            "utilization_statistics": {
+                "min": min(utilization),
+                "max": max(utilization),
+                "mean": statistics.mean(utilization),
+                "median": statistics.median(utilization),
+                "stdev": statistics.stdev(utilization) if len(utilization) > 1 else 0
+            },
+            "efficiency_statistics": {
+                "min": min(efficiency),
+                "max": max(efficiency),
+                "mean": statistics.mean(efficiency),
+                "median": statistics.median(efficiency),
+                "stdev": statistics.stdev(efficiency) if len(efficiency) > 1 else 0
+            },
+            "best_performers": {
+                "best_coverage": {
+                    "fleet_size": analyses[best_coverage_idx]["fleet_size"],
+                    "coverage_percent": analyses[best_coverage_idx]["overall_coverage_percent"]
+                },
+                "best_utilization": {
+                    "fleet_size": analyses[best_utilization_idx]["fleet_size"],
+                    "utilization_percent": analyses[best_utilization_idx]["utilization_rate_percent"]
+                },
+                "best_efficiency": {
+                    "fleet_size": analyses[best_efficiency_idx]["fleet_size"],
+                    "efficiency_score": analyses[best_efficiency_idx]["fleet_efficiency_score"]
+                }
+            }
+        }
+    
+    def _find_optimal_configuration(self):
+        """Find and store optimal fleet configuration"""
+        print("\nFinding optimal fleet configuration...")
+        
+        optimal_size, optimal_metrics = self.analyzer.find_optimal_fleet_size(
+            min_coverage_required=95.0
+        )
+        
+        self.results["optimal_fleet"] = {
+            "optimal_fleet_size": optimal_size,
+            "minimum_required_trains": optimal_metrics.minimum_required_trains,
+            "coverage_percent": optimal_metrics.overall_coverage_percent,
+            "utilization_percent": optimal_metrics.utilization_rate_percent,
+            "efficiency_score": optimal_metrics.fleet_efficiency_score,
+            "cost_efficiency_score": optimal_metrics.cost_efficiency_score,
+            "operational_hours_per_train": optimal_metrics.avg_operational_hours_per_train,
+            "idle_hours_per_train": optimal_metrics.avg_idle_hours_per_train
+        }
+        
+        print(f"  ✓ Optimal Fleet Size: {optimal_size} trains")
+        print(f"  ✓ Coverage: {optimal_metrics.overall_coverage_percent:.1f}%")
+        print(f"  ✓ Efficiency: {optimal_metrics.fleet_efficiency_score:.1f}/100")
+    
+    def save_results(self, filename: Optional[str] = None) -> str:
+        """Save results to JSON file"""
+        if filename is None:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"fleet_utilization_benchmark_{timestamp}.json"
+        
+        filepath = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)),
+            filename
+        )
+        
+        with open(filepath, 'w') as f:
+            json.dump(self.results, f, indent=2)
+        
+        print(f"\n✓ Results saved to: {filepath}")
+        return filepath
+    
+    def generate_report(self, filename: Optional[str] = None) -> str:
+        """Generate human-readable text report"""
+        if filename is None:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"fleet_utilization_report_{timestamp}.txt"
+        
+        filepath = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)),
+            filename
+        )
+        
+        with open(filepath, 'w') as f:
+            f.write("="*70 + "\n")
+            f.write("FLEET UTILIZATION BENCHMARK REPORT\n")
+            f.write("="*70 + "\n\n")
+            
+            # Metadata
+            f.write(f"Generated: {self.results['metadata']['generated_at']}\n")
+            f.write(f"System: {self.results['metadata']['system']}\n\n")
+            
+            # Configuration
+            f.write("Configuration:\n")
+            f.write("-"*70 + "\n")
+            config = self.results['configuration']
+            f.write(f"  Route Length: {config['route_length_km']} km\n")
+            f.write(f"  Average Speed: {config['avg_speed_kmh']} km/h\n")
+            f.write(f"  Service Hours: {config['service_hours']} hours/day\n")
+            f.write(f"  Peak Headway Target: {config['peak_headway_minutes']} minutes\n")
+            f.write(f"  Off-Peak Headway Target: {config['offpeak_headway_minutes']} minutes\n\n")
+            
+            # Optimal Fleet
+            f.write("OPTIMAL FLEET CONFIGURATION:\n")
+            f.write("-"*70 + "\n")
+            optimal = self.results['optimal_fleet']
+            f.write(f"  Optimal Fleet Size: {optimal['optimal_fleet_size']} trains\n")
+            f.write(f"  Minimum Required: {optimal['minimum_required_trains']} trains\n")
+            f.write(f"  Coverage: {optimal['coverage_percent']:.1f}%\n")
+            f.write(f"  Utilization Rate: {optimal['utilization_percent']:.1f}%\n")
+            f.write(f"  Fleet Efficiency: {optimal['efficiency_score']:.1f}/100\n")
+            f.write(f"  Operational Hours/Train: {optimal['operational_hours_per_train']:.2f} hrs/day\n")
+            f.write(f"  Idle Hours/Train: {optimal['idle_hours_per_train']:.2f} hrs/day\n\n")
+            
+            # Comparative Analysis
+            f.write("COMPARATIVE ANALYSIS:\n")
+            f.write("-"*70 + "\n")
+            comp = self.results['comparative_analysis']
+            
+            f.write("\nCoverage Statistics:\n")
+            stats = comp['coverage_statistics']
+            f.write(f"  Mean: {stats['mean']:.2f}%\n")
+            f.write(f"  Median: {stats['median']:.2f}%\n")
+            f.write(f"  Range: {stats['min']:.2f}% - {stats['max']:.2f}%\n")
+            f.write(f"  Std Dev: {stats['stdev']:.2f}\n")
+            
+            f.write("\nUtilization Statistics:\n")
+            stats = comp['utilization_statistics']
+            f.write(f"  Mean: {stats['mean']:.2f}%\n")
+            f.write(f"  Median: {stats['median']:.2f}%\n")
+            f.write(f"  Range: {stats['min']:.2f}% - {stats['max']:.2f}%\n")
+            f.write(f"  Std Dev: {stats['stdev']:.2f}\n")
+            
+            f.write("\nEfficiency Statistics:\n")
+            stats = comp['efficiency_statistics']
+            f.write(f"  Mean: {stats['mean']:.2f}/100\n")
+            f.write(f"  Median: {stats['median']:.2f}/100\n")
+            f.write(f"  Range: {stats['min']:.2f} - {stats['max']:.2f}\n")
+            f.write(f"  Std Dev: {stats['stdev']:.2f}\n")
+            
+            # Best Performers
+            f.write("\nBest Performers:\n")
+            best = comp['best_performers']
+            f.write(f"  Best Coverage: {best['best_coverage']['fleet_size']} trains ({best['best_coverage']['coverage_percent']:.1f}%)\n")
+            f.write(f"  Best Utilization: {best['best_utilization']['fleet_size']} trains ({best['best_utilization']['utilization_percent']:.1f}%)\n")
+            f.write(f"  Best Efficiency: {best['best_efficiency']['fleet_size']} trains ({best['best_efficiency']['efficiency_score']:.1f}/100)\n\n")
+            
+            # Detailed Results
+            f.write("DETAILED FLEET ANALYSES:\n")
+            f.write("="*70 + "\n\n")
+            
+            for analysis in self.results['fleet_analyses']:
+                f.write(f"Fleet Size: {analysis['fleet_size']} trains\n")
+                f.write("-"*70 + "\n")
+                f.write(f"  Minimum Required: {analysis['minimum_required_trains']} trains\n")
+                f.write(f"  Peak Service: {analysis['trains_in_service_peak']} trains\n")
+                f.write(f"  Off-Peak Service: {analysis['trains_in_service_offpeak']} trains\n")
+                f.write(f"  Standby: {analysis['trains_in_standby']} trains\n")
+                f.write(f"  Maintenance: {analysis['trains_in_maintenance']} trains\n")
+                f.write(f"  Peak Coverage: {analysis['peak_demand_coverage_percent']:.1f}%\n")
+                f.write(f"  Off-Peak Coverage: {analysis['offpeak_demand_coverage_percent']:.1f}%\n")
+                f.write(f"  Overall Coverage: {analysis['overall_coverage_percent']:.1f}%\n")
+                f.write(f"  Operational Hours/Train: {analysis['avg_operational_hours_per_train']:.2f} hrs\n")
+                f.write(f"  Idle Hours/Train: {analysis['avg_idle_hours_per_train']:.2f} hrs\n")
+                f.write(f"  Utilization Rate: {analysis['utilization_rate_percent']:.1f}%\n")
+                f.write(f"  Fleet Efficiency: {analysis['fleet_efficiency_score']:.1f}/100\n")
+                f.write(f"  Cost Efficiency: {analysis['cost_efficiency_score']:.1f}/100\n")
+                f.write("\n")
+        
+        print(f"✓ Report saved to: {filepath}")
+        return filepath
+
+
+def main():
+    """Run comprehensive fleet utilization benchmark"""
+    benchmark = FleetUtilizationBenchmark()
+    
+    # Run analysis for various fleet sizes
+    benchmark.run_comprehensive_analysis(
+        fleet_sizes=[10, 15, 20, 25, 30, 35, 40],
+        maintenance_rate=0.1
+    )
+    
+    # Save results
+    benchmark.save_results()
+    benchmark.generate_report()
+    
+    print("\n" + "="*70)
+    print("BENCHMARK COMPLETE")
+    print("="*70)
+    print("\nFiles generated:")
+    print("  - fleet_utilization_benchmark_TIMESTAMP.json")
+    print("  - fleet_utilization_report_TIMESTAMP.txt")
+    print("\nUse these results for your research paper Results section!")
+
+
+if __name__ == "__main__":
+    main()

benchmarks/fleet_utilization/fleet_analyzer.py

@@ -0,0 +1,401 @@
+#!/usr/bin/env python3
+"""
+Fleet Utilization Analysis for Metro Train Scheduling
+Analyzes minimum fleet size, coverage efficiency, and train utilization rates.
+"""
+from typing import Dict, List, Tuple, Any, Optional
+from datetime import datetime, time, timedelta
+import statistics
+from dataclasses import dataclass
+
+
+@dataclass
+class FleetUtilizationMetrics:
+    """Metrics for fleet utilization analysis"""
+    fleet_size: int
+    minimum_required_trains: int
+    trains_in_service_peak: int
+    trains_in_service_offpeak: int
+    trains_in_standby: int
+    trains_in_maintenance: int
+    
+    # Coverage metrics
+    peak_demand_coverage_percent: float
+    offpeak_demand_coverage_percent: float
+    overall_coverage_percent: float
+    
+    # Utilization metrics
+    avg_operational_hours_per_train: float
+    avg_idle_hours_per_train: float
+    utilization_rate_percent: float
+    
+    # Time distribution
+    total_service_hours: float
+    peak_hours_duration: float
+    offpeak_hours_duration: float
+    
+    # Efficiency scores
+    fleet_efficiency_score: float
+    cost_efficiency_score: float
+
+
+class FleetUtilizationAnalyzer:
+    """Analyzes fleet utilization for metro scheduling optimization"""
+    
+    def __init__(self):
+        # Kochi Metro operational parameters
+        self.service_start = time(5, 0)  # 5:00 AM
+        self.service_end = time(23, 0)   # 11:00 PM
+        self.total_service_hours = 18.0   # 18 hours per day
+        
+        # Peak hours definition
+        self.peak_periods = [
+            (time(7, 0), time(10, 0)),   # Morning peak: 7-10 AM
+            (time(17, 0), time(20, 0)),  # Evening peak: 5-8 PM
+        ]
+        
+        # Target headways (minutes between trains)
+        self.peak_headway_target = 5     # 5 minutes during peak
+        self.offpeak_headway_target = 10  # 10 minutes during off-peak
+        
+        # Route parameters (Kochi Metro)
+        self.route_length_km = 25.612
+        self.avg_speed_kmh = 35
+        self.turnaround_time_minutes = 10
+        
+        # Calculate round trip time
+        self.one_way_time = (self.route_length_km / self.avg_speed_kmh) * 60  # minutes
+        self.round_trip_time = (self.one_way_time * 2) + (self.turnaround_time_minutes * 2)
+        
+    def calculate_peak_hours_duration(self) -> float:
+        """Calculate total peak hours per day"""
+        total_peak_minutes = 0
+        for start, end in self.peak_periods:
+            start_minutes = start.hour * 60 + start.minute
+            end_minutes = end.hour * 60 + end.minute
+            total_peak_minutes += (end_minutes - start_minutes)
+        return total_peak_minutes / 60.0  # Convert to hours
+    
+    def calculate_minimum_fleet_size(
+        self,
+        headway_minutes: int,
+        round_trip_minutes: Optional[float] = None
+    ) -> int:
+        """
+        Calculate minimum number of trains needed to maintain headway.
+        
+        Formula: Minimum Fleet = (Round Trip Time / Headway) + Buffer
+        
+        Args:
+            headway_minutes: Desired minutes between trains
+            round_trip_minutes: Optional override for round trip time
+            
+        Returns:
+            Minimum number of trains required
+        """
+        rtt = round_trip_minutes if round_trip_minutes else self.round_trip_time
+        
+        # Calculate base requirement
+        base_trains = rtt / headway_minutes
+        
+        # Add buffer for operational flexibility (1 train) and maintenance (10%)
+        buffer_trains = 1
+        maintenance_buffer = max(1, int(base_trains * 0.1))
+        
+        minimum_fleet = int(base_trains) + buffer_trains + maintenance_buffer
+        
+        return minimum_fleet
+    
+    def calculate_demand_coverage(
+        self,
+        available_trains: int,
+        required_trains_peak: int,
+        required_trains_offpeak: int
+    ) -> Dict[str, float]:
+        """
+        Calculate what percentage of demand can be covered.
+        
+        Args:
+            available_trains: Number of trains available for service
+            required_trains_peak: Required trains during peak hours
+            required_trains_offpeak: Required trains during off-peak hours
+            
+        Returns:
+            Dictionary with coverage percentages
+        """
+        peak_coverage = min(100.0, (available_trains / required_trains_peak) * 100)
+        offpeak_coverage = min(100.0, (available_trains / required_trains_offpeak) * 100)
+        
+        # Weight by duration
+        peak_duration = self.calculate_peak_hours_duration()
+        offpeak_duration = self.total_service_hours - peak_duration
+        
+        overall_coverage = (
+            (peak_coverage * peak_duration + offpeak_coverage * offpeak_duration) 
+            / self.total_service_hours
+        )
+        
+        return {
+            "peak_coverage_percent": round(peak_coverage, 2),
+            "offpeak_coverage_percent": round(offpeak_coverage, 2),
+            "overall_coverage_percent": round(overall_coverage, 2)
+        }
+    
+    def calculate_train_utilization(
+        self,
+        trains_in_service: int,
+        service_hours: Optional[float] = None
+    ) -> Dict[str, float]:
+        """
+        Calculate average operational hours and utilization per train.
+        
+        Args:
+            trains_in_service: Number of trains actively in service
+            service_hours: Total service hours (default: full day)
+            
+        Returns:
+            Dictionary with utilization metrics
+        """
+        service_hours = service_hours or self.total_service_hours
+        
+        # Average operational hours per train
+        # Assumes trains operate in shifts to cover full service period
+        avg_operational_hours = service_hours * 0.9  # 90% active time assumption
+        
+        # Idle hours
+        avg_idle_hours = 24 - avg_operational_hours
+        
+        # Utilization rate
+        utilization_rate = (avg_operational_hours / 24) * 100
+        
+        return {
+            "avg_operational_hours": round(avg_operational_hours, 2),
+            "avg_idle_hours": round(avg_idle_hours, 2),
+            "utilization_rate_percent": round(utilization_rate, 2)
+        }
+    
+    def calculate_fleet_efficiency_score(
+        self,
+        fleet_size: int,
+        minimum_required: int,
+        coverage_percent: float
+    ) -> float:
+        """
+        Calculate overall fleet efficiency score (0-100).
+        
+        Higher score = better efficiency
+        Considers fleet size optimization and coverage
+        
+        Args:
+            fleet_size: Actual fleet size
+            minimum_required: Minimum required trains
+            coverage_percent: Overall demand coverage percentage
+            
+        Returns:
+            Efficiency score (0-100)
+        """
+        # Penalty for excess fleet (cost inefficiency)
+        excess_ratio = (fleet_size - minimum_required) / minimum_required
+        excess_penalty = min(30, excess_ratio * 20)  # Max 30 point penalty
+        
+        # Reward for coverage (service quality)
+        coverage_score = coverage_percent * 0.7  # 70% weight on coverage
+        
+        # Efficiency score
+        efficiency = coverage_score - excess_penalty
+        efficiency = max(0, min(100, efficiency))  # Clamp to 0-100
+        
+        return round(efficiency, 2)
+    
+    def analyze_fleet_configuration(
+        self,
+        total_fleet: int,
+        trains_in_maintenance: int = 0,
+        trains_reserved: int = 0
+    ) -> FleetUtilizationMetrics:
+        """
+        Comprehensive analysis of a fleet configuration.
+        
+        Args:
+            total_fleet: Total number of trains in fleet
+            trains_in_maintenance: Trains currently in maintenance
+            trains_reserved: Trains reserved/held back
+            
+        Returns:
+            FleetUtilizationMetrics object with complete analysis
+        """
+        # Calculate available trains
+        available_trains = total_fleet - trains_in_maintenance - trains_reserved
+        
+        # Calculate minimum requirements
+        min_fleet_peak = self.calculate_minimum_fleet_size(self.peak_headway_target)
+        min_fleet_offpeak = self.calculate_minimum_fleet_size(self.offpeak_headway_target)
+        min_fleet_overall = max(min_fleet_peak, min_fleet_offpeak)
+        
+        # Determine actual service allocation
+        trains_in_service_peak = min(available_trains, min_fleet_peak)
+        trains_in_service_offpeak = min(available_trains, min_fleet_offpeak)
+        trains_in_standby = max(0, available_trains - trains_in_service_peak)
+        
+        # Coverage analysis
+        coverage = self.calculate_demand_coverage(
+            available_trains,
+            min_fleet_peak,
+            min_fleet_offpeak
+        )
+        
+        # Utilization analysis
+        utilization = self.calculate_train_utilization(trains_in_service_peak)
+        
+        # Efficiency scores
+        peak_duration = self.calculate_peak_hours_duration()
+        offpeak_duration = self.total_service_hours - peak_duration
+        
+        fleet_efficiency = self.calculate_fleet_efficiency_score(
+            total_fleet,
+            min_fleet_overall,
+            coverage["overall_coverage_percent"]
+        )
+        
+        # Cost efficiency (fewer trains = better cost efficiency, but must meet demand)
+        cost_efficiency = (min_fleet_overall / total_fleet) * coverage["overall_coverage_percent"]
+        
+        return FleetUtilizationMetrics(
+            fleet_size=total_fleet,
+            minimum_required_trains=min_fleet_overall,
+            trains_in_service_peak=trains_in_service_peak,
+            trains_in_service_offpeak=trains_in_service_offpeak,
+            trains_in_standby=trains_in_standby,
+            trains_in_maintenance=trains_in_maintenance,
+            peak_demand_coverage_percent=coverage["peak_coverage_percent"],
+            offpeak_demand_coverage_percent=coverage["offpeak_coverage_percent"],
+            overall_coverage_percent=coverage["overall_coverage_percent"],
+            avg_operational_hours_per_train=utilization["avg_operational_hours"],
+            avg_idle_hours_per_train=utilization["avg_idle_hours"],
+            utilization_rate_percent=utilization["utilization_rate_percent"],
+            total_service_hours=self.total_service_hours,
+            peak_hours_duration=peak_duration,
+            offpeak_hours_duration=offpeak_duration,
+            fleet_efficiency_score=fleet_efficiency,
+            cost_efficiency_score=round(cost_efficiency, 2)
+        )
+    
+    def compare_fleet_sizes(
+        self,
+        fleet_sizes: List[int],
+        maintenance_rate: float = 0.1
+    ) -> Dict[int, FleetUtilizationMetrics]:
+        """
+        Compare different fleet size configurations.
+        
+        Args:
+            fleet_sizes: List of fleet sizes to analyze
+            maintenance_rate: Percentage of fleet in maintenance (default 10%)
+            
+        Returns:
+            Dictionary mapping fleet size to metrics
+        """
+        results = {}
+        
+        for size in fleet_sizes:
+            maintenance_trains = max(1, int(size * maintenance_rate))
+            metrics = self.analyze_fleet_configuration(size, maintenance_trains)
+            results[size] = metrics
+        
+        return results
+    
+    def find_optimal_fleet_size(
+        self,
+        min_coverage_required: float = 95.0,
+        max_fleet: int = 50
+    ) -> Tuple[int, FleetUtilizationMetrics]:
+        """
+        Find the optimal (smallest) fleet size that meets coverage requirements.
+        
+        Args:
+            min_coverage_required: Minimum acceptable coverage percentage
+            max_fleet: Maximum fleet size to consider
+            
+        Returns:
+            Tuple of (optimal_fleet_size, metrics)
+        """
+        # Start from minimum required and increment
+        min_theoretical = self.calculate_minimum_fleet_size(self.peak_headway_target)
+        
+        for fleet_size in range(min_theoretical, max_fleet + 1):
+            maintenance_trains = max(1, int(fleet_size * 0.1))
+            metrics = self.analyze_fleet_configuration(fleet_size, maintenance_trains)
+            
+            if metrics.overall_coverage_percent >= min_coverage_required:
+                return fleet_size, metrics
+        
+        # If no solution found, return largest tested
+        metrics = self.analyze_fleet_configuration(max_fleet, int(max_fleet * 0.1))
+        return max_fleet, metrics
+
+
+def format_metrics_report(metrics: FleetUtilizationMetrics) -> str:
+    """Format metrics into a readable report"""
+    report = f"""
+{'='*70}
+FLEET UTILIZATION ANALYSIS REPORT
+{'='*70}
+
+Fleet Configuration:
+  Total Fleet Size:              {metrics.fleet_size} trains
+  Minimum Required:              {metrics.minimum_required_trains} trains
+  Excess Capacity:               {metrics.fleet_size - metrics.minimum_required_trains} trains
+
+Service Allocation:
+  Peak Service:                  {metrics.trains_in_service_peak} trains
+  Off-Peak Service:              {metrics.trains_in_service_offpeak} trains
+  Standby:                       {metrics.trains_in_standby} trains
+  Maintenance:                   {metrics.trains_in_maintenance} trains
+
+Coverage Efficiency:
+  Peak Demand Coverage:          {metrics.peak_demand_coverage_percent:.1f}%
+  Off-Peak Demand Coverage:      {metrics.offpeak_demand_coverage_percent:.1f}%
+  Overall Coverage:              {metrics.overall_coverage_percent:.1f}%
+
+Train Utilization:
+  Avg Operational Hours/Train:   {metrics.avg_operational_hours_per_train:.2f} hours/day
+  Avg Idle Hours/Train:          {metrics.avg_idle_hours_per_train:.2f} hours/day
+  Utilization Rate:              {metrics.utilization_rate_percent:.1f}%
+
+Time Distribution:
+  Total Service Hours:           {metrics.total_service_hours:.1f} hours/day
+  Peak Hours:                    {metrics.peak_hours_duration:.1f} hours/day
+  Off-Peak Hours:                {metrics.offpeak_hours_duration:.1f} hours/day
+
+Efficiency Scores:
+  Fleet Efficiency:              {metrics.fleet_efficiency_score:.1f}/100
+  Cost Efficiency:               {metrics.cost_efficiency_score:.1f}/100
+
+{'='*70}
+"""
+    return report
+
+
+if __name__ == "__main__":
+    # Example usage
+    analyzer = FleetUtilizationAnalyzer()
+    
+    print("Kochi Metro Fleet Utilization Analysis")
+    print("=" * 70)
+    
+    # Analyze specific fleet size
+    metrics = analyzer.analyze_fleet_configuration(
+        total_fleet=25,
+        trains_in_maintenance=2
+    )
+    
+    print(format_metrics_report(metrics))
+    
+    # Find optimal fleet size
+    optimal_size, optimal_metrics = analyzer.find_optimal_fleet_size(
+        min_coverage_required=95.0
+    )
+    
+    print(f"\nOptimal Fleet Size: {optimal_size} trains")
+    print(f"Coverage: {optimal_metrics.overall_coverage_percent:.1f}%")
+    print(f"Efficiency Score: {optimal_metrics.fleet_efficiency_score:.1f}/100")

example_benchmark.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Simple example of running the benchmark
+This demonstrates how to collect performance data for a research paper
+
+NOTE: The benchmark uses EnhancedMetroDataGenerator from DataService
+to create complete, realistic synthetic data for testing greedy optimizers.
+"""
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from benchmark_schedule_performance import SchedulePerformanceBenchmark
+
+def run_simple_benchmark():
+    """Run a simple benchmark for demonstration"""
+    print("="*70)
+    print("SIMPLE BENCHMARK EXAMPLE")
+    print("="*70)
+    print("\nThis example demonstrates benchmarking for research paper results.")
+    print("It tests 3 fleet sizes with 2 runs each.")
+    print("\nNOTE: Synthetic data is generated using DataService/EnhancedMetroDataGenerator")
+    print("      This includes trainset status, fitness certificates, job cards, etc.\n")
+    
+    # Create benchmark instance
+    benchmark = SchedulePerformanceBenchmark()
+    
+    # Run benchmark with small configuration
+    benchmark.run_comprehensive_benchmark(
+        fleet_sizes=[10, 20, 30],  # Test with 10, 20, and 30 trains
+        greedy_methods=['ga', 'pso'],  # Test GA and PSO
+        num_runs=2  # 2 runs for quick results
+    )
+    
+    # Save results
+    json_file = benchmark.save_results()
+    report_file = benchmark.generate_report()
+    
+    print("\n" + "="*70)
+    print("RESULTS FOR YOUR PAPER")
+    print("="*70)
+    
+    if "summary" in benchmark.results and "fastest_optimizer" in benchmark.results["summary"]:
+        fastest = benchmark.results["summary"]["fastest_optimizer"]
+        fastest_time = benchmark.results["summary"]["fastest_time_seconds"]
+        print(f"\nFastest Method: {fastest}")
+        print(f"Average Time: {fastest_time:.4f} seconds")
+    
+    print("\nYou can use the following data in your Results section:")
+    print(f"- Detailed JSON data: {json_file}")
+    print(f"- Formatted report: {report_file}")
+    
+    print("\n" + "="*70)
+
+if __name__ == "__main__":
+    run_simple_benchmark()

greedyOptim/error_handling.py

@@ -125,7 +125,7 @@ class DataValidator:
                 
                 # Validate dates
                 for date_field in ['issue_date', 'expiry_date']:
-                    if date_field in record:
+                    if date_field in record and record[date_field] is not None:
                         try:
                             datetime.fromisoformat(record[date_field])
                         except ValueError:

schedule_benchmark_20251106_134014.json

@@ -0,0 +1,838 @@
+{
+  "benchmark_info": {
+    "date": "2025-11-06T13:37:15.527707",
+    "description": "Metro Schedule Generation Performance Analysis",
+    "test_type": "Schedule Generation Time & Computational Efficiency"
+  },
+  "configurations": [
+    {
+      "fleet_sizes": [
+        10,
+        15,
+        20,
+        25,
+        30,
+        40
+      ],
+      "greedy_methods": [
+        "ga",
+        "pso",
+        "cmaes"
+      ],
+      "runs_per_config": 5,
+      "station_count": 22
+    }
+  ],
+  "detailed_results": [
+    {
+      "optimizer": "MetroScheduleOptimizer",
+      "fleet_size": 10,
+      "num_stations": 22,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 0.000391669000237016,
+        "max_seconds": 0.0006529950001095131,
+        "mean_seconds": 0.0004975758000909991,
+        "median_seconds": 0.00047151700027825427,
+        "stdev_seconds": 0.00010852079857594056,
+        "all_runs_seconds": [
+          0.0006529950001095131,
+          0.0005592709999291401,
+          0.0004124269999010721,
+          0.000391669000237016,
+          0.00047151700027825427
+        ]
+      },
+      "schedule_statistics": {
+        "num_trainsets": {
+          "mean": 10,
+          "min": 10,
+          "max": 10
+        },
+        "num_in_service": {
+          "mean": 0,
+          "min": 0,
+          "max": 0
+        },
+        "num_standby": {
+          "mean": 1.2,
+          "min": 0,
+          "max": 2
+        },
+        "num_maintenance": {
+          "mean": 0,
+          "min": 0,
+          "max": 0
+        },
+        "total_service_blocks": {
+          "mean": 10.4,
+          "min": 8,
+          "max": 14
+        }
+      }
+    },
+    {
+      "method": "ga",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 10,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 1.3963521669998045,
+        "max_seconds": 1.4883098969999082,
+        "mean_seconds": 1.4260893835998103,
+        "median_seconds": 1.4124550050000835,
+        "stdev_seconds": 0.03676729298817419
+      },
+      "optimization_scores": {
+        "mean": 8259.5625,
+        "min": 8259.5625,
+        "max": 8259.5625
+      }
+    },
+    {
+      "method": "pso",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 10,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 1.1987209819999407,
+        "max_seconds": 1.317151922999983,
+        "mean_seconds": 1.277441866800018,
+        "median_seconds": 1.3014346370000567,
+        "stdev_seconds": 0.049406619627260874
+      },
+      "optimization_scores": {
+        "mean": 8259.5625,
+        "min": 8259.5625,
+        "max": 8259.5625
+      }
+    },
+    {
+      "method": "cmaes",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 10,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 0.25710203799962983,
+        "max_seconds": 0.2891434930002106,
+        "mean_seconds": 0.27034687799996393,
+        "median_seconds": 0.26708701600000495,
+        "stdev_seconds": 0.01252247810000051
+      },
+      "optimization_scores": {
+        "mean": 8351.9026,
+        "min": 8259.5625,
+        "max": 8721.263
+      }
+    },
+    {
+      "optimizer": "MetroScheduleOptimizer",
+      "fleet_size": 15,
+      "num_stations": 22,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 0.0005759119999311224,
+        "max_seconds": 0.0014056449999770848,
+        "mean_seconds": 0.0008308520000355202,
+        "median_seconds": 0.0006553590001203702,
+        "stdev_seconds": 0.00034941493942545516,
+        "all_runs_seconds": [
+          0.0014056449999770848,
+          0.0009195510001518414,
+          0.0006553590001203702,
+          0.000597792999997182,
+          0.0005759119999311224
+        ]
+      },
+      "schedule_statistics": {
+        "num_trainsets": {
+          "mean": 15,
+          "min": 15,
+          "max": 15
+        },
+        "num_in_service": {
+          "mean": 0,
+          "min": 0,
+          "max": 0
+        },
+        "num_standby": {
+          "mean": 3.2,
+          "min": 0,
+          "max": 8
+        },
+        "num_maintenance": {
+          "mean": 0,
+          "min": 0,
+          "max": 0
+        },
+        "total_service_blocks": {
+          "mean": 14,
+          "min": 0,
+          "max": 24
+        }
+      }
+    },
+    {
+      "method": "ga",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 15,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 1.9778195669996421,
+        "max_seconds": 2.078312783000001,
+        "mean_seconds": 2.0281235989999913,
+        "median_seconds": 2.0414660280002863,
+        "stdev_seconds": 0.039198657499124455
+      },
+      "optimization_scores": {
+        "mean": 7221.458333333333,
+        "min": 7221.458333333333,
+        "max": 7221.458333333333
+      }
+    },
+    {
+      "method": "pso",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 15,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 1.3621163789998718,
+        "max_seconds": 1.4680279270000938,
+        "mean_seconds": 1.422008500999982,
+        "median_seconds": 1.43765709399986,
+        "stdev_seconds": 0.04642705859741245
+      },
+      "optimization_scores": {
+        "mean": 7718.583333333333,
+        "min": 7710.0,
+        "max": 7731.458333333333
+      }
+    },
+    {
+      "method": "cmaes",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 15,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 0.30759359300009237,
+        "max_seconds": 0.3274225889999798,
+        "mean_seconds": 0.31530408800008447,
+        "median_seconds": 0.31438662600021416,
+        "stdev_seconds": 0.0074082538027132995
+      },
+      "optimization_scores": {
+        "mean": 7471.166666666666,
+        "min": 7221.458333333333,
+        "max": 7731.458333333333
+      }
+    },
+    {
+      "optimizer": "MetroScheduleOptimizer",
+      "fleet_size": 20,
+      "num_stations": 22,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 0.0010652710002432286,
+        "max_seconds": 0.0018792339997162344,
+        "mean_seconds": 0.0013811987999361008,
+        "median_seconds": 0.001251426999715477,
+        "stdev_seconds": 0.0003213910444020275,
+        "all_runs_seconds": [
+          0.0018792339997162344,
+          0.0010652710002432286,
+          0.001201556000069104,
+          0.001251426999715477,
+          0.0015085059999364603
+        ]
+      },
+      "schedule_statistics": {
+        "num_trainsets": {
+          "mean": 20,
+          "min": 20,
+          "max": 20
+        },
+        "num_in_service": {
+          "mean": 0,
+          "min": 0,
+          "max": 0
+        },
+        "num_standby": {
+          "mean": 2.2,
+          "min": 1,
+          "max": 3
+        },
+        "num_maintenance": {
+          "mean": 0,
+          "min": 0,
+          "max": 0
+        },
+        "total_service_blocks": {
+          "mean": 18,
+          "min": 14,
+          "max": 20
+        }
+      }
+    },
+    {
+      "method": "ga",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 20,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 3.5978478239999276,
+        "max_seconds": 4.359904547000042,
+        "mean_seconds": 4.0308690387999375,
+        "median_seconds": 4.197869660999913,
+        "stdev_seconds": 0.3802696270167743
+      },
+      "optimization_scores": {
+        "mean": 7849.458531746031,
+        "min": 7316.736111111111,
+        "max": 8235.763888888889
+      }
+    },
+    {
+      "method": "pso",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 20,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 1.816424952000034,
+        "max_seconds": 2.2484812339998825,
+        "mean_seconds": 1.995718881799985,
+        "median_seconds": 1.963324914000168,
+        "stdev_seconds": 0.1625126481012335
+      },
+      "optimization_scores": {
+        "mean": 6039.215773809524,
+        "min": 5273.050595238095,
+        "max": 6704.523809523809
+      }
+    },
+    {
+      "method": "cmaes",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 20,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 0.3713683390001279,
+        "max_seconds": 0.42148448099987945,
+        "mean_seconds": 0.3929031652000958,
+        "median_seconds": 0.3885927700002867,
+        "stdev_seconds": 0.019848359739041352
+      },
+      "optimization_scores": {
+        "mean": 5718.677721088436,
+        "min": 5523.050595238095,
+        "max": 6013.050595238095
+      }
+    },
+    {
+      "optimizer": "MetroScheduleOptimizer",
+      "fleet_size": 25,
+      "num_stations": 22,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 0.0011885819999406522,
+        "max_seconds": 0.006939703000170994,
+        "mean_seconds": 0.002958188200045697,
+        "median_seconds": 0.002493990999937523,
+        "stdev_seconds": 0.002311739115790229,
+        "all_runs_seconds": [
+          0.0026543580001998635,
+          0.006939703000170994,
+          0.002493990999937523,
+          0.0011885819999406522,
+          0.0015143069999794534
+        ]
+      },
+      "schedule_statistics": {
+        "num_trainsets": {
+          "mean": 25,
+          "min": 25,
+          "max": 25
+        },
+        "num_in_service": {
+          "mean": 0,
+          "min": 0,
+          "max": 0
+        },
+        "num_standby": {
+          "mean": 4,
+          "min": 2,
+          "max": 5
+        },
+        "num_maintenance": {
+          "mean": 0,
+          "min": 0,
+          "max": 0
+        },
+        "total_service_blocks": {
+          "mean": 23.6,
+          "min": 18,
+          "max": 28
+        }
+      }
+    },
+    {
+      "method": "ga",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 25,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 4.450258830999701,
+        "max_seconds": 4.6299859079999806,
+        "mean_seconds": 4.527360460599903,
+        "median_seconds": 4.496251064999797,
+        "stdev_seconds": 0.07250204628025216
+      },
+      "optimization_scores": {
+        "mean": 7805.723412698413,
+        "min": 7205.519841269841,
+        "max": 8231.770833333334
+      }
+    },
+    {
+      "method": "pso",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 25,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 1.6021809260000737,
+        "max_seconds": 2.0892670769999313,
+        "mean_seconds": 1.9182770816000811,
+        "median_seconds": 1.934989805999976,
+        "stdev_seconds": 0.20000945840353515
+      },
+      "optimization_scores": {
+        "mean": 5416.512881562881,
+        "min": 4714.148148148148,
+        "max": 6194.027777777777
+      }
+    },
+    {
+      "method": "cmaes",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 25,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 0.37672309399977166,
+        "max_seconds": 0.4467183430001569,
+        "mean_seconds": 0.42155395619993213,
+        "median_seconds": 0.42633110800034046,
+        "stdev_seconds": 0.02678553643100765
+      },
+      "optimization_scores": {
+        "mean": 4805.237202380952,
+        "min": 4706.9484126984125,
+        "max": 5188.392361111111
+      }
+    },
+    {
+      "optimizer": "MetroScheduleOptimizer",
+      "fleet_size": 30,
+      "num_stations": 22,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 0.0014640639997196558,
+        "max_seconds": 0.0024185390002458007,
+        "mean_seconds": 0.0020176196000647904,
+        "median_seconds": 0.002053440000054252,
+        "stdev_seconds": 0.0003518474507731157,
+        "all_runs_seconds": [
+          0.0024185390002458007,
+          0.0019762269998864213,
+          0.0014640639997196558,
+          0.002175828000417823,
+          0.002053440000054252
+        ]
+      },
+      "schedule_statistics": {
+        "num_trainsets": {
+          "mean": 30,
+          "min": 30,
+          "max": 30
+        },
+        "num_in_service": {
+          "mean": 0,
+          "min": 0,
+          "max": 0
+        },
+        "num_standby": {
+          "mean": 3.4,
+          "min": 1,
+          "max": 6
+        },
+        "num_maintenance": {
+          "mean": 0,
+          "min": 0,
+          "max": 0
+        },
+        "total_service_blocks": {
+          "mean": 26,
+          "min": 22,
+          "max": 32
+        }
+      }
+    },
+    {
+      "method": "ga",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 30,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 3.656059525999808,
+        "max_seconds": 3.9020974959998966,
+        "mean_seconds": 3.7467717739999897,
+        "median_seconds": 3.702346977000161,
+        "stdev_seconds": 0.10654896202242645
+      },
+      "optimization_scores": {
+        "mean": 5565.882416194916,
+        "min": 5565.882416194916,
+        "max": 5565.882416194916
+      }
+    },
+    {
+      "method": "pso",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 30,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 1.9881061810001484,
+        "max_seconds": 2.4008741109996663,
+        "mean_seconds": 2.1433096785999624,
+        "median_seconds": 2.1254254129999026,
+        "stdev_seconds": 0.16246516059375193
+      },
+      "optimization_scores": {
+        "mean": 4656.59065934066,
+        "min": 4138.327838827839,
+        "max": 5162.010073260073
+      }
+    },
+    {
+      "method": "cmaes",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 30,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 0.5601028310002221,
+        "max_seconds": 0.5995334710000861,
+        "mean_seconds": 0.5794001551999827,
+        "median_seconds": 0.5759605129996999,
+        "stdev_seconds": 0.017854577483330164
+      },
+      "optimization_scores": {
+        "mean": 3226.4587468087466,
+        "min": 3128.286172161172,
+        "max": 3619.1490453990455
+      }
+    },
+    {
+      "optimizer": "MetroScheduleOptimizer",
+      "fleet_size": 40,
+      "num_stations": 22,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 0.001798295999833499,
+        "max_seconds": 0.004733248999855277,
+        "mean_seconds": 0.003044102399962867,
+        "median_seconds": 0.0031079119999049,
+        "stdev_seconds": 0.0012054221276706066,
+        "all_runs_seconds": [
+          0.0031079119999049,
+          0.001992327000152727,
+          0.001798295999833499,
+          0.003588728000067931,
+          0.004733248999855277
+        ]
+      },
+      "schedule_statistics": {
+        "num_trainsets": {
+          "mean": 40,
+          "min": 40,
+          "max": 40
+        },
+        "num_in_service": {
+          "mean": 0,
+          "min": 0,
+          "max": 0
+        },
+        "num_standby": {
+          "mean": 5.6,
+          "min": 4,
+          "max": 7
+        },
+        "num_maintenance": {
+          "mean": 0,
+          "min": 0,
+          "max": 0
+        },
+        "total_service_blocks": {
+          "mean": 27.6,
+          "min": 20,
+          "max": 30
+        }
+      }
+    },
+    {
+      "method": "ga",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 40,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 4.770303608999711,
+        "max_seconds": 4.999881856000229,
+        "mean_seconds": 4.887823572599973,
+        "median_seconds": 4.915720539000176,
+        "stdev_seconds": 0.10805978619659268
+      },
+      "optimization_scores": {
+        "mean": 4668.188604324968,
+        "min": 4668.188604324968,
+        "max": 4668.188604324968
+      }
+    },
+    {
+      "method": "pso",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 40,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 2.324307186999704,
+        "max_seconds": 3.1814292060003027,
+        "mean_seconds": 2.920363885200004,
+        "median_seconds": 3.0396999100003086,
+        "stdev_seconds": 0.3411733712592887
+      },
+      "optimization_scores": {
+        "mean": 4206.6411169518315,
+        "min": 3223.605957534529,
+        "max": 5240.704365079365
+      }
+    },
+    {
+      "method": "cmaes",
+      "optimizer_family": "GreedyOptim",
+      "fleet_size": 40,
+      "num_runs": 5,
+      "successful_runs": 5,
+      "success_rate": "100.0%",
+      "execution_time": {
+        "min_seconds": 0.8600020419999055,
+        "max_seconds": 1.1148396250000587,
+        "mean_seconds": 0.9417086120000022,
+        "median_seconds": 0.9037215389998892,
+        "stdev_seconds": 0.10007564261354274
+      },
+      "optimization_scores": {
+        "mean": 2723.605957534529,
+        "min": 2723.605957534529,
+        "max": 2723.605957534529
+      }
+    }
+  ],
+  "summary": {
+    "by_fleet_size": {
+      "10": [
+        {
+          "optimizer": "MetroScheduleOptimizer",
+          "mean_time_seconds": 0.0004975758000909991,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "ga",
+          "mean_time_seconds": 1.4260893835998103,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "pso",
+          "mean_time_seconds": 1.277441866800018,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "cmaes",
+          "mean_time_seconds": 0.27034687799996393,
+          "success_rate": "100.0%"
+        }
+      ],
+      "15": [
+        {
+          "optimizer": "MetroScheduleOptimizer",
+          "mean_time_seconds": 0.0008308520000355202,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "ga",
+          "mean_time_seconds": 2.0281235989999913,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "pso",
+          "mean_time_seconds": 1.422008500999982,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "cmaes",
+          "mean_time_seconds": 0.31530408800008447,
+          "success_rate": "100.0%"
+        }
+      ],
+      "20": [
+        {
+          "optimizer": "MetroScheduleOptimizer",
+          "mean_time_seconds": 0.0013811987999361008,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "ga",
+          "mean_time_seconds": 4.0308690387999375,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "pso",
+          "mean_time_seconds": 1.995718881799985,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "cmaes",
+          "mean_time_seconds": 0.3929031652000958,
+          "success_rate": "100.0%"
+        }
+      ],
+      "25": [
+        {
+          "optimizer": "MetroScheduleOptimizer",
+          "mean_time_seconds": 0.002958188200045697,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "ga",
+          "mean_time_seconds": 4.527360460599903,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "pso",
+          "mean_time_seconds": 1.9182770816000811,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "cmaes",
+          "mean_time_seconds": 0.42155395619993213,
+          "success_rate": "100.0%"
+        }
+      ],
+      "30": [
+        {
+          "optimizer": "MetroScheduleOptimizer",
+          "mean_time_seconds": 0.0020176196000647904,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "ga",
+          "mean_time_seconds": 3.7467717739999897,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "pso",
+          "mean_time_seconds": 2.1433096785999624,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "cmaes",
+          "mean_time_seconds": 0.5794001551999827,
+          "success_rate": "100.0%"
+        }
+      ],
+      "40": [
+        {
+          "optimizer": "MetroScheduleOptimizer",
+          "mean_time_seconds": 0.003044102399962867,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "ga",
+          "mean_time_seconds": 4.887823572599973,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "pso",
+          "mean_time_seconds": 2.920363885200004,
+          "success_rate": "100.0%"
+        },
+        {
+          "optimizer": "cmaes",
+          "mean_time_seconds": 0.9417086120000022,
+          "success_rate": "100.0%"
+        }
+      ]
+    },
+    "overall_rankings": {
+      "MetroScheduleOptimizer": {
+        "rank": 1,
+        "avg_time_seconds": 0.0017882561333559957
+      },
+      "cmaes": {
+        "rank": 2,
+        "avg_time_seconds": 0.4868694757666769
+      },
+      "pso": {
+        "rank": 3,
+        "avg_time_seconds": 1.9461866491666722
+      },
+      "ga": {
+        "rank": 4,
+        "avg_time_seconds": 3.4411729714332675
+      }
+    },
+    "fastest_optimizer": "MetroScheduleOptimizer",
+    "fastest_time_seconds": 0.0017882561333559957
+  }
+}

schedule_performance_report_20251106_134014.txt

@@ -0,0 +1,383 @@
+================================================================================
+METRO SCHEDULE GENERATION PERFORMANCE REPORT
+================================================================================
+
+Generated: 2025-11-06 13:40:14
+Test Type: Schedule Generation Time & Computational Efficiency
+
+EXECUTIVE SUMMARY
+--------------------------------------------------------------------------------
+
+Fastest Optimizer: MetroScheduleOptimizer
+Best Average Time: 0.0018 seconds
+
+Overall Performance Rankings:
+  1. MetroScheduleOptimizer: 0.0018s
+  2. cmaes: 0.4869s
+  3. pso: 1.9462s
+  4. ga: 3.4412s
+
+
+DETAILED RESULTS
+--------------------------------------------------------------------------------
+
+Optimizer/Method: MetroScheduleOptimizer
+Fleet Size: 10 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   0.0005s
+  Median: 0.0005s
+  Min:    0.0004s
+  Max:    0.0007s
+  StdDev: 0.0001s
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: ga
+Fleet Size: 10 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   1.4261s
+  Median: 1.4125s
+  Min:    1.3964s
+  Max:    1.4883s
+  StdDev: 0.0368s
+Optimization Scores:
+  Mean: 8259.5625
+  Min:  8259.5625
+  Max:  8259.5625
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: pso
+Fleet Size: 10 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   1.2774s
+  Median: 1.3014s
+  Min:    1.1987s
+  Max:    1.3172s
+  StdDev: 0.0494s
+Optimization Scores:
+  Mean: 8259.5625
+  Min:  8259.5625
+  Max:  8259.5625
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: cmaes
+Fleet Size: 10 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   0.2703s
+  Median: 0.2671s
+  Min:    0.2571s
+  Max:    0.2891s
+  StdDev: 0.0125s
+Optimization Scores:
+  Mean: 8351.9026
+  Min:  8259.5625
+  Max:  8721.2630
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: MetroScheduleOptimizer
+Fleet Size: 15 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   0.0008s
+  Median: 0.0007s
+  Min:    0.0006s
+  Max:    0.0014s
+  StdDev: 0.0003s
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: ga
+Fleet Size: 15 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   2.0281s
+  Median: 2.0415s
+  Min:    1.9778s
+  Max:    2.0783s
+  StdDev: 0.0392s
+Optimization Scores:
+  Mean: 7221.4583
+  Min:  7221.4583
+  Max:  7221.4583
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: pso
+Fleet Size: 15 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   1.4220s
+  Median: 1.4377s
+  Min:    1.3621s
+  Max:    1.4680s
+  StdDev: 0.0464s
+Optimization Scores:
+  Mean: 7718.5833
+  Min:  7710.0000
+  Max:  7731.4583
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: cmaes
+Fleet Size: 15 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   0.3153s
+  Median: 0.3144s
+  Min:    0.3076s
+  Max:    0.3274s
+  StdDev: 0.0074s
+Optimization Scores:
+  Mean: 7471.1667
+  Min:  7221.4583
+  Max:  7731.4583
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: MetroScheduleOptimizer
+Fleet Size: 20 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   0.0014s
+  Median: 0.0013s
+  Min:    0.0011s
+  Max:    0.0019s
+  StdDev: 0.0003s
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: ga
+Fleet Size: 20 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   4.0309s
+  Median: 4.1979s
+  Min:    3.5978s
+  Max:    4.3599s
+  StdDev: 0.3803s
+Optimization Scores:
+  Mean: 7849.4585
+  Min:  7316.7361
+  Max:  8235.7639
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: pso
+Fleet Size: 20 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   1.9957s
+  Median: 1.9633s
+  Min:    1.8164s
+  Max:    2.2485s
+  StdDev: 0.1625s
+Optimization Scores:
+  Mean: 6039.2158
+  Min:  5273.0506
+  Max:  6704.5238
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: cmaes
+Fleet Size: 20 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   0.3929s
+  Median: 0.3886s
+  Min:    0.3714s
+  Max:    0.4215s
+  StdDev: 0.0198s
+Optimization Scores:
+  Mean: 5718.6777
+  Min:  5523.0506
+  Max:  6013.0506
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: MetroScheduleOptimizer
+Fleet Size: 25 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   0.0030s
+  Median: 0.0025s
+  Min:    0.0012s
+  Max:    0.0069s
+  StdDev: 0.0023s
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: ga
+Fleet Size: 25 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   4.5274s
+  Median: 4.4963s
+  Min:    4.4503s
+  Max:    4.6300s
+  StdDev: 0.0725s
+Optimization Scores:
+  Mean: 7805.7234
+  Min:  7205.5198
+  Max:  8231.7708
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: pso
+Fleet Size: 25 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   1.9183s
+  Median: 1.9350s
+  Min:    1.6022s
+  Max:    2.0893s
+  StdDev: 0.2000s
+Optimization Scores:
+  Mean: 5416.5129
+  Min:  4714.1481
+  Max:  6194.0278
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: cmaes
+Fleet Size: 25 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   0.4216s
+  Median: 0.4263s
+  Min:    0.3767s
+  Max:    0.4467s
+  StdDev: 0.0268s
+Optimization Scores:
+  Mean: 4805.2372
+  Min:  4706.9484
+  Max:  5188.3924
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: MetroScheduleOptimizer
+Fleet Size: 30 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   0.0020s
+  Median: 0.0021s
+  Min:    0.0015s
+  Max:    0.0024s
+  StdDev: 0.0004s
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: ga
+Fleet Size: 30 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   3.7468s
+  Median: 3.7023s
+  Min:    3.6561s
+  Max:    3.9021s
+  StdDev: 0.1065s
+Optimization Scores:
+  Mean: 5565.8824
+  Min:  5565.8824
+  Max:  5565.8824
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: pso
+Fleet Size: 30 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   2.1433s
+  Median: 2.1254s
+  Min:    1.9881s
+  Max:    2.4009s
+  StdDev: 0.1625s
+Optimization Scores:
+  Mean: 4656.5907
+  Min:  4138.3278
+  Max:  5162.0101
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: cmaes
+Fleet Size: 30 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   0.5794s
+  Median: 0.5760s
+  Min:    0.5601s
+  Max:    0.5995s
+  StdDev: 0.0179s
+Optimization Scores:
+  Mean: 3226.4587
+  Min:  3128.2862
+  Max:  3619.1490
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: MetroScheduleOptimizer
+Fleet Size: 40 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   0.0030s
+  Median: 0.0031s
+  Min:    0.0018s
+  Max:    0.0047s
+  StdDev: 0.0012s
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: ga
+Fleet Size: 40 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   4.8878s
+  Median: 4.9157s
+  Min:    4.7703s
+  Max:    4.9999s
+  StdDev: 0.1081s
+Optimization Scores:
+  Mean: 4668.1886
+  Min:  4668.1886
+  Max:  4668.1886
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: pso
+Fleet Size: 40 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   2.9204s
+  Median: 3.0397s
+  Min:    2.3243s
+  Max:    3.1814s
+  StdDev: 0.3412s
+Optimization Scores:
+  Mean: 4206.6411
+  Min:  3223.6060
+  Max:  5240.7044
+
+--------------------------------------------------------------------------------
+
+Optimizer/Method: cmaes
+Fleet Size: 40 trains
+Success Rate: 100.0%
+Execution Time Statistics:
+  Mean:   0.9417s
+  Median: 0.9037s
+  Min:    0.8600s
+  Max:    1.1148s
+  StdDev: 0.1001s
+Optimization Scores:
+  Mean: 2723.6060
+  Min:  2723.6060
+  Max:  2723.6060
+
+--------------------------------------------------------------------------------
+