pyconvexity 0.3.8.post7__py3-none-any.whl → 0.4.1__py3-none-any.whl

pyconvexity/solvers/pypsa/storage.py

@@ -12,7 +12,9 @@ from typing import Dict, Any, Optional, Callable
 
 from pyconvexity.core.types import StaticValue
 from pyconvexity.models import (
-    list_components_by_type, set_static_attribute, set_timeseries_attribute
+    list_components_by_type,
+    set_static_attribute,
+    set_timeseries_attribute,
 )
 from pyconvexity.validation import get_validation_rule
 
@@ -22,83 +24,125 @@ logger = logging.getLogger(__name__)
 class ResultStorage:
     """
     Handles storing PyPSA solve results back to the database.
-    
+
     This class manages the complex process of extracting results from PyPSA networks
     and storing them back to the database with proper validation and error handling.
     """
-    
+
     def store_results(
         self,
         conn,
-        network_id: int,
-        network: 'pypsa.Network',
+        network: "pypsa.Network",
         solve_result: Dict[str, Any],
-        scenario_id: Optional[int] = None
+        scenario_id: Optional[int] = None,
     ) -> Dict[str, Any]:
         """
-        Store complete solve results back to database.
-        
+        Store complete solve results back to database (single network per database).
+
         Args:
             conn: Database connection
-            network_id: ID of the network
             network: Solved PyPSA Network object
             solve_result: Solve result metadata
-            scenario_id: Optional scenario ID
-            
+            scenario_id: Optional scenario ID (NULL for base network)
+
         Returns:
             Dictionary with storage statistics
         """
-        run_id = solve_result.get('run_id', str(uuid.uuid4()))
-        
+        run_id = solve_result.get("run_id", str(uuid.uuid4()))
+
         try:
+            logger.info("=" * 80)
+            logger.info("📊 STARTING RESULT STORAGE")
+            logger.info("=" * 80)
+
             # Store component results
-            component_stats = self._store_component_results(
-                conn, network_id, network, scenario_id
-            )
-            
+            logger.info("📝 Step 1: Storing component results (timeseries data)...")
+            component_stats = self._store_component_results(conn, network, scenario_id)
+            logger.info(f"✅ Component results stored: {component_stats}")
+
             # Calculate network statistics first
+            logger.info("📊 Step 2: Calculating network statistics...")
             network_stats = self._calculate_network_statistics(
-                conn, network_id, network, solve_result
+                conn, network, solve_result
             )
-            
+            logger.info(f"✅ Network statistics calculated")
+            logger.info(
+                f"   - Total generation: {network_stats.get('core_summary', {}).get('total_generation_mwh', 0):.2f} MWh"
+            )
+            logger.info(
+                f"   - Total cost: {network_stats.get('core_summary', {}).get('total_cost', 0):.2f}"
+            )
+
             # Store solve summary with network statistics
-            self._store_solve_summary(
-                conn, network_id, solve_result, scenario_id, network_stats
+            logger.info(
+                "💾 Step 3: Storing solve summary to network_solve_results table..."
             )
-            
+            self._store_solve_summary(conn, solve_result, scenario_id, network_stats)
+            # Explicit commit after storing summary
+            conn.commit()
+            logger.info("✅ Solve summary stored and committed successfully")
+
             # Store year-based statistics if available
             year_stats_stored = 0
-            if solve_result.get('year_statistics'):
+            if solve_result.get("year_statistics"):
+                logger.info(
+                    f"📅 Step 4: Storing year-based statistics ({len(solve_result['year_statistics'])} years)..."
+                )
                 year_stats_stored = self._store_year_based_statistics(
-                    conn, network_id, network, solve_result['year_statistics'], scenario_id
+                    conn, network, solve_result["year_statistics"], scenario_id
                 )
-            
+                # Explicit commit after storing year statistics
+                conn.commit()
+                logger.info(
+                    f"✅ Year-based statistics stored and committed: {year_stats_stored} years"
+                )
+            else:
+                logger.warning(
+                    "⚠️ No year_statistics in solve_result - skipping year-based storage"
+                )
+                logger.info(
+                    f"   Available solve_result keys: {list(solve_result.keys())}"
+                )
+
+            logger.info("=" * 80)
+            logger.info("✅ RESULT STORAGE COMPLETED SUCCESSFULLY")
+            logger.info("=" * 80)
+
+            # Final verification - check if data was actually stored
+            cursor = conn.execute(
+                "SELECT COUNT(*) FROM network_solve_results WHERE scenario_id IS ? ",
+                (scenario_id,) if scenario_id is not None else (None,),
+            )
+            count = cursor.fetchone()[0]
+            logger.info(
+                f"🔍 Verification: {count} solve result(s) found in network_solve_results table"
+            )
+
             return {
                 "component_stats": component_stats,
                 "network_stats": network_stats,
                 "year_stats_stored": year_stats_stored,
                 "run_id": run_id,
-                "success": True
+                "success": True,
             }
-            
+
         except Exception as e:
-            logger.error(f"Failed to store solve results: {e}", exc_info=True)
+            logger.error("=" * 80)
+            logger.error(f"❌ RESULT STORAGE FAILED: {e}")
+            logger.error("=" * 80)
+            logger.exception("Full traceback:")
             return {
                 "component_stats": {},
                 "network_stats": {},
                 "run_id": run_id,
                 "success": False,
-                "error": str(e)
+                "error": str(e),
             }
-    
+
     def _store_component_results(
-        self,
-        conn,
-        network_id: int,
-        network: 'pypsa.Network',
-        scenario_id: Optional[int]
+        self, conn, network: "pypsa.Network", scenario_id: Optional[int]
     ) -> Dict[str, int]:
-        """Store results for all component types."""
+        """Store results for all component types (single network per database)."""
         results_stats = {
             "stored_bus_results": 0,
             "stored_generator_results": 0,
@@ -109,86 +153,113 @@ class ResultStorage:
             "stored_storage_unit_results": 0,
             "stored_store_results": 0,
             "skipped_attributes": 0,
-            "errors": 0
+            "errors": 0,
         }
-        
+
         try:
             # Store bus results
-            if hasattr(network, 'buses_t') and network.buses_t:
-                results_stats["stored_bus_results"] = self._store_component_type_results(
-                    conn, network_id, 'BUS', network.buses, network.buses_t, scenario_id
+            if hasattr(network, "buses_t") and network.buses_t:
+                results_stats["stored_bus_results"] = (
+                    self._store_component_type_results(
+                        conn, "BUS", network.buses, network.buses_t, scenario_id
+                    )
                 )
-            
+
             # Store generator results (includes regular generators)
-            if hasattr(network, 'generators_t') and network.generators_t:
-                results_stats["stored_generator_results"] = self._store_component_type_results(
-                    conn, network_id, 'GENERATOR', network.generators, network.generators_t, scenario_id
+            if hasattr(network, "generators_t") and network.generators_t:
+                results_stats["stored_generator_results"] = (
+                    self._store_component_type_results(
+                        conn,
+                        "GENERATOR",
+                        network.generators,
+                        network.generators_t,
+                        scenario_id,
+                    )
                 )
-                
+
                 # Store UNMET_LOAD results (these are also stored as generators in PyPSA)
-                results_stats["stored_unmet_load_results"] = self._store_component_type_results(
-                    conn, network_id, 'UNMET_LOAD', network.generators, network.generators_t, scenario_id
+                results_stats["stored_unmet_load_results"] = (
+                    self._store_component_type_results(
+                        conn,
+                        "UNMET_LOAD",
+                        network.generators,
+                        network.generators_t,
+                        scenario_id,
+                    )
                 )
-            
+
             # Store load results
-            if hasattr(network, 'loads_t') and network.loads_t:
-                results_stats["stored_load_results"] = self._store_component_type_results(
-                    conn, network_id, 'LOAD', network.loads, network.loads_t, scenario_id
+            if hasattr(network, "loads_t") and network.loads_t:
+                results_stats["stored_load_results"] = (
+                    self._store_component_type_results(
+                        conn, "LOAD", network.loads, network.loads_t, scenario_id
+                    )
                 )
-            
+
             # Store line results
-            if hasattr(network, 'lines_t') and network.lines_t:
-                results_stats["stored_line_results"] = self._store_component_type_results(
-                    conn, network_id, 'LINE', network.lines, network.lines_t, scenario_id
+            if hasattr(network, "lines_t") and network.lines_t:
+                results_stats["stored_line_results"] = (
+                    self._store_component_type_results(
+                        conn, "LINE", network.lines, network.lines_t, scenario_id
+                    )
                 )
-            
+
             # Store link results
-            if hasattr(network, 'links_t') and network.links_t:
-                results_stats["stored_link_results"] = self._store_component_type_results(
-                    conn, network_id, 'LINK', network.links, network.links_t, scenario_id
+            if hasattr(network, "links_t") and network.links_t:
+                results_stats["stored_link_results"] = (
+                    self._store_component_type_results(
+                        conn, "LINK", network.links, network.links_t, scenario_id
+                    )
                 )
-            
+
             # Store storage unit results
-            if hasattr(network, 'storage_units_t') and network.storage_units_t:
-                results_stats["stored_storage_unit_results"] = self._store_component_type_results(
-                    conn, network_id, 'STORAGE_UNIT', network.storage_units, network.storage_units_t, scenario_id
+            if hasattr(network, "storage_units_t") and network.storage_units_t:
+                results_stats["stored_storage_unit_results"] = (
+                    self._store_component_type_results(
+                        conn,
+                        "STORAGE_UNIT",
+                        network.storage_units,
+                        network.storage_units_t,
+                        scenario_id,
+                    )
                 )
-            
+
             # Store store results
-            if hasattr(network, 'stores_t') and network.stores_t:
-                results_stats["stored_store_results"] = self._store_component_type_results(
-                    conn, network_id, 'STORE', network.stores, network.stores_t, scenario_id
+            if hasattr(network, "stores_t") and network.stores_t:
+                results_stats["stored_store_results"] = (
+                    self._store_component_type_results(
+                        conn, "STORE", network.stores, network.stores_t, scenario_id
+                    )
                 )
-            
+
             return results_stats
-            
+
         except Exception as e:
             logger.error(f"Error storing solve results: {e}", exc_info=True)
             results_stats["errors"] += 1
             return results_stats
-    
+
     def _store_component_type_results(
         self,
         conn,
-        network_id: int,
         component_type: str,
         static_df: pd.DataFrame,
         timeseries_dict: Dict[str, pd.DataFrame],
-        scenario_id: Optional[int]
+        scenario_id: Optional[int],
     ) -> int:
-        """Store results for a specific component type - only store OUTPUT attributes."""
+        """Store results for a specific component type - only store OUTPUT attributes (single network per database)."""
         stored_count = 0
-        
+
         try:
             # Get component name to ID mapping
-            components = list_components_by_type(conn, network_id, component_type)
+            components = list_components_by_type(conn, component_type)
             name_to_id = {comp.name: comp.id for comp in components}
-            
+
             # Store timeseries results - ONLY OUTPUT ATTRIBUTES (is_input=FALSE)
             for attr_name, timeseries_df in timeseries_dict.items():
                 if timeseries_df.empty:
                     continue
-                
+
                 # Check if this attribute is an output attribute (not an input)
                 try:
                     rule = get_validation_rule(conn, component_type, attr_name)
@@ -198,18 +269,18 @@ class ResultStorage:
                 except Exception:
                     # If no validation rule found, skip to be safe
                     continue
-                
+
                 for component_name in timeseries_df.columns:
                     if component_name not in name_to_id:
                         continue
-                    
+
                     component_id = name_to_id[component_name]
                     component_series = timeseries_df[component_name]
-                    
+
                     # Skip if all values are NaN
                     if component_series.isna().all():
                         continue
-                    
+
                     # Convert to efficient values array
                     values = []
                     for value in component_series.values:
@@ -217,24 +288,30 @@ class ResultStorage:
                             values.append(0.0)  # Fill NaN with 0.0
                         else:
                             values.append(float(value))
-                    
+
                     if not values:
                         continue
-                    
+
                     # Store using efficient format
                     try:
-                        set_timeseries_attribute(conn, component_id, attr_name, values, scenario_id)
+                        set_timeseries_attribute(
+                            conn, component_id, attr_name, values, scenario_id
+                        )
                         stored_count += 1
                     except Exception as e:
                         # Handle validation errors gracefully
-                        if ("No validation rule found" in str(e) or 
-                            "does not allow" in str(e) or
-                            "ValidationError" in str(type(e).__name__)):
+                        if (
+                            "No validation rule found" in str(e)
+                            or "does not allow" in str(e)
+                            or "ValidationError" in str(type(e).__name__)
+                        ):
                             continue
                         else:
-                            logger.warning(f"Error storing timeseries {attr_name} for {component_type} '{component_name}': {e}")
+                            logger.warning(
+                                f"Error storing timeseries {attr_name} for {component_type} '{component_name}': {e}"
+                            )
                             continue
-            
+
             # Store static optimization results - ONLY OUTPUT ATTRIBUTES (is_input=FALSE)
             if not static_df.empty:
                 for attr_name in static_df.columns:
@@ -247,13 +324,13 @@ class ResultStorage:
                     except Exception:
                         # If no validation rule found, skip to be safe
                         continue
-                    
+
                     for component_name, value in static_df[attr_name].items():
                         if component_name not in name_to_id or pd.isna(value):
                             continue
-                        
+
                         component_id = name_to_id[component_name]
-                        
+
                         try:
                             # Convert value to StaticValue
                             if isinstance(value, (int, np.integer)):
@@ -267,110 +344,176 @@ class ResultStorage:
                                 static_value = StaticValue(bool(value))
                             else:
                                 static_value = StaticValue(str(value))
-                            
+
                             # Store using atomic utility
-                            set_static_attribute(conn, component_id, attr_name, static_value, scenario_id)
+                            set_static_attribute(
+                                conn, component_id, attr_name, static_value, scenario_id
+                            )
                             stored_count += 1
-                            
+
                         except Exception as e:
                             # Handle validation errors gracefully
-                            if ("No validation rule found" in str(e) or 
-                                "does not allow" in str(e) or
-                                "ValidationError" in str(type(e).__name__)):
+                            if (
+                                "No validation rule found" in str(e)
+                                or "does not allow" in str(e)
+                                or "ValidationError" in str(type(e).__name__)
+                            ):
                                 continue
                             else:
-                                logger.warning(f"Error storing static {attr_name} for {component_type} '{component_name}': {e}")
+                                logger.warning(
+                                    f"Error storing static {attr_name} for {component_type} '{component_name}': {e}"
+                                )
                                 continue
-            
+
             return stored_count
-            
+
         except Exception as e:
-            logger.error(f"Error storing results for {component_type}: {e}", exc_info=True)
+            logger.error(
+                f"Error storing results for {component_type}: {e}", exc_info=True
+            )
             return stored_count
-    
+
     def _store_solve_summary(
         self,
         conn,
-        network_id: int,
         solve_result: Dict[str, Any],
         scenario_id: Optional[int],
-        network_stats: Optional[Dict[str, Any]] = None
+        network_stats: Optional[Dict[str, Any]] = None,
     ):
-        """Store solve summary to network_solve_results table."""
+        """Store solve summary to network_solve_results table (single network per database)."""
         try:
+            # Debug logging
+            logger.info(
+                f"📝 _store_solve_summary called with scenario_id={scenario_id} (type={type(scenario_id)})"
+            )
+
             # Prepare solve summary data
-            solver_name = solve_result.get('solver_name', 'unknown')
-            solve_status = solve_result.get('status', 'unknown')
-            objective_value = solve_result.get('objective_value')
-            solve_time = solve_result.get('solve_time', 0.0)
-            
-            # Use master scenario if no scenario specified
-            if scenario_id is None:
-                from pyconvexity.models import get_master_scenario_id
-                scenario_id = get_master_scenario_id(conn, network_id)
-            
+            solver_name = solve_result.get("solver_name", "unknown")
+            solve_status = solve_result.get("status", "unknown")
+            objective_value = solve_result.get("objective_value")
+            solve_time = solve_result.get("solve_time", 0.0)
+
+            logger.info(f"   solver_name: {solver_name}")
+            logger.info(f"   solve_status: {solve_status}")
+            logger.info(f"   objective_value: {objective_value}")
+            logger.info(f"   solve_time: {solve_time}")
+
             # Create enhanced solve result with network statistics for serialization
             enhanced_solve_result = {
                 **solve_result,
-                "network_statistics": network_stats or {}
+                "network_statistics": network_stats or {},
             }
-            
-            # Store solve results summary
-            conn.execute("""
-                INSERT OR REPLACE INTO network_solve_results (
-                    network_id, scenario_id, solver_name, solve_type, solve_status,
+
+            # Delete existing result for this scenario first (handles NULL scenario_id correctly)
+            if scenario_id is None:
+                logger.info("🗑️ Deleting existing base scenario (NULL) results")
+                delete_result = conn.execute(
+                    "DELETE FROM network_solve_results WHERE scenario_id IS NULL"
+                )
+                logger.info(f"   Deleted {delete_result.rowcount} existing rows")
+            else:
+                logger.info(
+                    f"🗑️ Deleting existing results for scenario_id={scenario_id}"
+                )
+                delete_result = conn.execute(
+                    "DELETE FROM network_solve_results WHERE scenario_id = ?",
+                    (scenario_id,),
+                )
+                logger.info(f"   Deleted {delete_result.rowcount} existing rows")
+
+            logger.info(f"💾 Inserting solve results for scenario_id={scenario_id}")
+            logger.info(
+                f"   Serializing results_json ({len(str(enhanced_solve_result))} chars)..."
+            )
+            results_json = self._serialize_results_json(enhanced_solve_result)
+            logger.info(f"   Serializing metadata_json...")
+            metadata_json = self._serialize_metadata_json(enhanced_solve_result)
+
+            # Insert new solve results summary
+            insert_result = conn.execute(
+                """
+                INSERT INTO network_solve_results (
+                    scenario_id, solver_name, solve_type, solve_status,
                     objective_value, solve_time_seconds, results_json, metadata_json
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-            """, (
-                network_id,
-                scenario_id,
-                solver_name,
-                'pypsa_optimization',
-                solve_status,
-                objective_value,
-                solve_time,
-                self._serialize_results_json(enhanced_solve_result),
-                self._serialize_metadata_json(enhanced_solve_result)
-            ))
-            
-            logger.info(f"Stored solve summary for network {network_id}, scenario {scenario_id}")
-            
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+                (
+                    scenario_id,
+                    solver_name,
+                    "pypsa_optimization",
+                    solve_status,
+                    objective_value,
+                    solve_time,
+                    results_json,
+                    metadata_json,
+                ),
+            )
+
+            logger.info(f"✅ Inserted solve summary (rowid={insert_result.lastrowid})")
+
+            # Verify insertion
+            verify_cursor = conn.execute(
+                "SELECT COUNT(*), solver_name, solve_status FROM network_solve_results WHERE scenario_id IS ?",
+                (scenario_id,) if scenario_id is not None else (None,),
+            )
+            verify_result = verify_cursor.fetchone()
+            logger.info(
+                f"🔍 Verification: {verify_result[0]} row(s) with solver={verify_result[1]}, status={verify_result[2]}"
+            )
+
         except Exception as e:
-            logger.error(f"Failed to store solve summary: {e}", exc_info=True)
-    
+            logger.error(f"❌ FAILED to store solve summary: {e}", exc_info=True)
+            raise  # Re-raise to trigger rollback
+
     def _calculate_network_statistics(
-        self,
-        conn,
-        network_id: int,
-        network: 'pypsa.Network',
-        solve_result: Dict[str, Any]
+        self, conn, network: "pypsa.Network", solve_result: Dict[str, Any]
     ) -> Dict[str, Any]:
-        """Calculate network statistics - focusing only on capacity for now."""
+        """Calculate network statistics - focusing only on capacity for now (single network per database)."""
         try:
             # Calculate carrier-specific statistics
-            carrier_stats = self._calculate_carrier_statistics(conn, network_id, network)
-            
+            carrier_stats = self._calculate_carrier_statistics(conn, network)
+
             # Calculate basic network statistics
-            total_cost = solve_result.get('objective_value', 0.0)
-            total_generation_mwh = sum(carrier_stats.get("dispatch_by_carrier", {}).values())
-            total_emissions_tonnes = sum(carrier_stats.get("emissions_by_carrier", {}).values())
-            total_capital_cost = sum(carrier_stats.get("capital_cost_by_carrier", {}).values())
-            total_operational_cost = sum(carrier_stats.get("operational_cost_by_carrier", {}).values())
-            total_system_cost = sum(carrier_stats.get("total_system_cost_by_carrier", {}).values())
-            
+            total_cost = solve_result.get("objective_value", 0.0)
+            total_generation_mwh = sum(
+                carrier_stats.get("dispatch_by_carrier", {}).values()
+            )
+            total_emissions_tonnes = sum(
+                carrier_stats.get("emissions_by_carrier", {}).values()
+            )
+            total_capital_cost = sum(
+                carrier_stats.get("capital_cost_by_carrier", {}).values()
+            )
+            total_operational_cost = sum(
+                carrier_stats.get("operational_cost_by_carrier", {}).values()
+            )
+            total_system_cost = sum(
+                carrier_stats.get("total_system_cost_by_carrier", {}).values()
+            )
+
             # Calculate unmet load statistics
-            unmet_load_mwh = carrier_stats.get("dispatch_by_carrier", {}).get("Unmet Load", 0.0)
+            unmet_load_mwh = carrier_stats.get("dispatch_by_carrier", {}).get(
+                "Unmet Load", 0.0
+            )
             total_demand_mwh = self._calculate_total_demand(network)
-            unmet_load_percentage = (unmet_load_mwh / (total_demand_mwh + 1e-6)) * 100 if total_demand_mwh > 0 else 0.0
-            
+            unmet_load_percentage = (
+                (unmet_load_mwh / (total_demand_mwh + 1e-6)) * 100
+                if total_demand_mwh > 0
+                else 0.0
+            )
+
             # Create nested structure expected by frontend
             network_statistics = {
                 "core_summary": {
                     "total_generation_mwh": total_generation_mwh,
                     "total_demand_mwh": total_demand_mwh,
                     "total_cost": total_cost,
-                    "load_factor": (total_demand_mwh / (total_generation_mwh + 1e-6)) if total_generation_mwh > 0 else 0.0,
-                    "unserved_energy_mwh": unmet_load_mwh
+                    "load_factor": (
+                        (total_demand_mwh / (total_generation_mwh + 1e-6))
+                        if total_generation_mwh > 0
+                        else 0.0
+                    ),
+                    "unserved_energy_mwh": unmet_load_mwh,
                 },
                 "custom_statistics": {
                     # Include carrier-specific statistics (capacity, dispatch, emissions, costs)
@@ -379,25 +522,44 @@ class ResultStorage:
                     "total_operational_cost": total_operational_cost,
                     "total_currency_cost": total_system_cost,  # Use calculated system cost instead of PyPSA objective
                     "total_emissions_tons_co2": total_emissions_tonnes,
-                    "average_price_per_mwh": (total_system_cost / (total_generation_mwh + 1e-6)) if total_generation_mwh > 0 else 0.0,
+                    "average_price_per_mwh": (
+                        (total_system_cost / (total_generation_mwh + 1e-6))
+                        if total_generation_mwh > 0
+                        else 0.0
+                    ),
                     "unmet_load_percentage": unmet_load_percentage,
-                    "max_unmet_load_hour_mw": 0.0       # TODO: Calculate max hourly unmet load later
+                    "max_unmet_load_hour_mw": 0.0,  # TODO: Calculate max hourly unmet load later
                 },
                 "runtime_info": {
                     "component_count": (
-                        len(network.buses) + len(network.generators) + len(network.loads) + 
-                        len(network.lines) + len(network.links)
-                    ) if hasattr(network, 'buses') else 0,
-                    "bus_count": len(network.buses) if hasattr(network, 'buses') else 0,
-                    "generator_count": len(network.generators) if hasattr(network, 'generators') else 0,
-                    "load_count": len(network.loads) if hasattr(network, 'loads') else 0,
-                    "snapshot_count": len(network.snapshots) if hasattr(network, 'snapshots') else 0
-                }
+                        (
+                            len(network.buses)
+                            + len(network.generators)
+                            + len(network.loads)
+                            + len(network.lines)
+                            + len(network.links)
+                        )
+                        if hasattr(network, "buses")
+                        else 0
+                    ),
+                    "bus_count": len(network.buses) if hasattr(network, "buses") else 0,
+                    "generator_count": (
+                        len(network.generators) if hasattr(network, "generators") else 0
+                    ),
+                    "load_count": (
+                        len(network.loads) if hasattr(network, "loads") else 0
+                    ),
+                    "snapshot_count": (
+                        len(network.snapshots) if hasattr(network, "snapshots") else 0
+                    ),
+                },
             }
-            
-            logger.info(f"Calculated network statistics: core_summary={network_statistics['core_summary']}")
+
+            logger.info(
+                f"Calculated network statistics: core_summary={network_statistics['core_summary']}"
+            )
             return network_statistics
-            
+
         except Exception as e:
             logger.error(f"Failed to calculate network statistics: {e}", exc_info=True)
             # Return empty structure matching expected format
@@ -405,9 +567,9 @@ class ResultStorage:
                 "core_summary": {
                     "total_generation_mwh": 0.0,
                     "total_demand_mwh": 0.0,
-                    "total_cost": solve_result.get('objective_value', 0.0),
+                    "total_cost": solve_result.get("objective_value", 0.0),
                     "load_factor": 0.0,
-                    "unserved_energy_mwh": 0.0
+                    "unserved_energy_mwh": 0.0,
                 },
                 "custom_statistics": {
                     "dispatch_by_carrier": {},
@@ -423,39 +585,51 @@ class ResultStorage:
                     "total_emissions_tons_co2": 0.0,
                     "average_price_per_mwh": 0.0,
                     "unmet_load_percentage": 0.0,
-                    "max_unmet_load_hour_mw": 0.0
+                    "max_unmet_load_hour_mw": 0.0,
                 },
                 "runtime_info": {
                     "component_count": 0,
                     "bus_count": 0,
                     "generator_count": 0,
                     "load_count": 0,
-                    "snapshot_count": 0
+                    "snapshot_count": 0,
                 },
-                "error": str(e)
+                "error": str(e),
             }
-    
-    def _calculate_carrier_statistics(self, conn, network_id: int, network: 'pypsa.Network') -> Dict[str, Any]:
+
+    def _calculate_carrier_statistics(
+        self, conn, network: "pypsa.Network"
+    ) -> Dict[str, Any]:
         """
-        Calculate carrier-specific statistics directly from the network.
+        Calculate carrier-specific statistics directly from the network (single network per database).
         This is the primary calculation - per-year stats will be calculated separately.
         """
         try:
+            logger.info("🔍 _calculate_carrier_statistics: Starting calculation...")
+
             # Calculate all-year statistics directly from the network
             # Extract years from network snapshots
-            if hasattr(network.snapshots, 'levels'):
+            if hasattr(network.snapshots, "levels"):
                 # Multi-period optimization - get years from period level
                 period_values = network.snapshots.get_level_values(0)
                 years = sorted(period_values.unique())
-            elif hasattr(network.snapshots, 'year'):
+                logger.info(
+                    f"   Detected multi-period optimization with years: {years}"
+                )
+            elif hasattr(network.snapshots, "year"):
                 years = sorted(network.snapshots.year.unique())
-            elif hasattr(network, '_available_years'):
+                logger.info(f"   Detected DatetimeIndex with years: {years}")
+            elif hasattr(network, "_available_years"):
                 years = network._available_years
+                logger.info(f"   Using _available_years: {years}")
             else:
                 years = [2020]  # Fallback
-            
-            logger.info(f"Calculating all-year carrier statistics for years: {years}")
-            
+                logger.warning(f"   No year information found, using fallback: {years}")
+
+            logger.info(
+                f"📅 Calculating all-year carrier statistics for {len(years)} years: {years}"
+            )
+
             # Calculate per-year statistics first
             all_year_stats = {
                 "dispatch_by_carrier": {},
@@ -464,17 +638,19 @@ class ResultStorage:
                 "emissions_by_carrier": {},
                 "capital_cost_by_carrier": {},
                 "operational_cost_by_carrier": {},
-                "total_system_cost_by_carrier": {}
+                "total_system_cost_by_carrier": {},
             }
-            
+
             # Initialize all carriers with zero values
-            cursor = conn.execute("""
-                SELECT DISTINCT name FROM carriers WHERE network_id = ?
-            """, (network_id,))
+            cursor = conn.execute(
+                """
+                SELECT DISTINCT name FROM carriers
+            """
+            )
             all_carriers = [row[0] for row in cursor.fetchall()]
-            
+
             # Initialize all carriers with zero values (including special "Unmet Load" carrier)
-            all_carriers_with_unmet = all_carriers + ['Unmet Load']
+            all_carriers_with_unmet = all_carriers + ["Unmet Load"]
             for carrier in all_carriers_with_unmet:
                 all_year_stats["dispatch_by_carrier"][carrier] = 0.0
                 all_year_stats["power_capacity_by_carrier"][carrier] = 0.0
@@ -483,34 +659,84 @@ class ResultStorage:
                 all_year_stats["capital_cost_by_carrier"][carrier] = 0.0
                 all_year_stats["operational_cost_by_carrier"][carrier] = 0.0
                 all_year_stats["total_system_cost_by_carrier"][carrier] = 0.0
-            
+
             # Calculate statistics for each year and sum them up
             for year in years:
-                year_stats = self._calculate_year_carrier_statistics(conn, network_id, network, year)
-                
+                year_stats = self._calculate_year_carrier_statistics(
+                    conn, network, year
+                )
+
                 # Sum up all the statistics (including "Unmet Load")
                 for carrier in all_carriers_with_unmet:
                     # Sum dispatch, emissions, and costs across years
-                    all_year_stats["dispatch_by_carrier"][carrier] += year_stats["dispatch_by_carrier"].get(carrier, 0.0)
-                    all_year_stats["emissions_by_carrier"][carrier] += year_stats["emissions_by_carrier"].get(carrier, 0.0)
-                    all_year_stats["capital_cost_by_carrier"][carrier] += year_stats["capital_cost_by_carrier"].get(carrier, 0.0)
-                    all_year_stats["operational_cost_by_carrier"][carrier] += year_stats["operational_cost_by_carrier"].get(carrier, 0.0)
-                    all_year_stats["total_system_cost_by_carrier"][carrier] += year_stats["total_system_cost_by_carrier"].get(carrier, 0.0)
-                    
+                    all_year_stats["dispatch_by_carrier"][carrier] += year_stats[
+                        "dispatch_by_carrier"
+                    ].get(carrier, 0.0)
+                    all_year_stats["emissions_by_carrier"][carrier] += year_stats[
+                        "emissions_by_carrier"
+                    ].get(carrier, 0.0)
+                    all_year_stats["capital_cost_by_carrier"][carrier] += year_stats[
+                        "capital_cost_by_carrier"
+                    ].get(carrier, 0.0)
+                    all_year_stats["operational_cost_by_carrier"][
+                        carrier
+                    ] += year_stats["operational_cost_by_carrier"].get(carrier, 0.0)
+                    all_year_stats["total_system_cost_by_carrier"][
+                        carrier
+                    ] += year_stats["total_system_cost_by_carrier"].get(carrier, 0.0)
+
                     # For capacity: use the last year (final capacity state)
                     if year == years[-1]:
-                        all_year_stats["power_capacity_by_carrier"][carrier] = year_stats["power_capacity_by_carrier"].get(carrier, 0.0)
-                        all_year_stats["energy_capacity_by_carrier"][carrier] = year_stats["energy_capacity_by_carrier"].get(carrier, 0.0)
-            
+                        all_year_stats["power_capacity_by_carrier"][carrier] = (
+                            year_stats["power_capacity_by_carrier"].get(carrier, 0.0)
+                        )
+                        all_year_stats["energy_capacity_by_carrier"][carrier] = (
+                            year_stats["energy_capacity_by_carrier"].get(carrier, 0.0)
+                        )
+
             logger.info(f"Calculated all-year carrier statistics:")
-            logger.info(f"  Total dispatch: {sum(all_year_stats['dispatch_by_carrier'].values()):.2f} MWh")
-            logger.info(f"  Total emissions: {sum(all_year_stats['emissions_by_carrier'].values()):.2f} tonnes CO2")
-            logger.info(f"  Total capital cost: {sum(all_year_stats['capital_cost_by_carrier'].values()):.2f} USD")
-            logger.info(f"  Total operational cost: {sum(all_year_stats['operational_cost_by_carrier'].values()):.2f} USD")
-            logger.info(f"  Final power capacity: {sum(all_year_stats['power_capacity_by_carrier'].values()):.2f} MW")
+            logger.info(
+                f"  Total dispatch: {sum(all_year_stats['dispatch_by_carrier'].values()):.2f} MWh"
+            )
+            logger.info(
+                f"  Total emissions: {sum(all_year_stats['emissions_by_carrier'].values()):.2f} tonnes CO2"
+            )
+            logger.info(
+                f"  Total capital cost: {sum(all_year_stats['capital_cost_by_carrier'].values()):.2f} USD"
+            )
+            logger.info(
+                f"  Total operational cost: {sum(all_year_stats['operational_cost_by_carrier'].values()):.2f} USD"
+            )
+            logger.info(
+                f"  Final power capacity: {sum(all_year_stats['power_capacity_by_carrier'].values()):.2f} MW"
+            )
             
+            # Detailed logging for cost and emission statistics by carrier
+            logger.info("=" * 80)
+            logger.info("📊 DETAILED CARRIER STATISTICS (RAW VALUES FROM MODEL):")
+            logger.info("=" * 80)
+            for carrier in sorted(all_carriers_with_unmet):
+                dispatch = all_year_stats['dispatch_by_carrier'].get(carrier, 0.0)
+                emissions = all_year_stats['emissions_by_carrier'].get(carrier, 0.0)
+                capital_cost = all_year_stats['capital_cost_by_carrier'].get(carrier, 0.0)
+                operational_cost = all_year_stats['operational_cost_by_carrier'].get(carrier, 0.0)
+                total_cost = all_year_stats['total_system_cost_by_carrier'].get(carrier, 0.0)
+                power_cap = all_year_stats['power_capacity_by_carrier'].get(carrier, 0.0)
+                energy_cap = all_year_stats['energy_capacity_by_carrier'].get(carrier, 0.0)
+                
+                if dispatch > 0.001 or emissions > 0.001 or capital_cost > 0.001 or operational_cost > 0.001:
+                    logger.info(f"  {carrier}:")
+                    logger.info(f"    - Dispatch: {dispatch:.2f} MWh")
+                    logger.info(f"    - Emissions: {emissions:.2f} tonnes CO2")
+                    logger.info(f"    - Capital Cost: {capital_cost:.2f} USD")
+                    logger.info(f"    - Operational Cost: {operational_cost:.2f} USD")
+                    logger.info(f"    - Total System Cost: {total_cost:.2f} USD")
+                    logger.info(f"    - Power Capacity: {power_cap:.2f} MW")
+                    logger.info(f"    - Energy Capacity: {energy_cap:.2f} MWh")
+            logger.info("=" * 80)
+
             return all_year_stats
-            
+
         except Exception as e:
             logger.error(f"Failed to calculate carrier statistics: {e}", exc_info=True)
             return {
@@ -520,99 +746,120 @@ class ResultStorage:
                 "emissions_by_carrier": {},
                 "capital_cost_by_carrier": {},
                 "operational_cost_by_carrier": {},
-                "total_system_cost_by_carrier": {}
+                "total_system_cost_by_carrier": {},
             }
-    
+
     def _store_year_based_statistics(
         self,
         conn,
-        network_id: int,
-        network: 'pypsa.Network',
+        network: "pypsa.Network",
         year_statistics: Dict[int, Dict[str, Any]],
-        scenario_id: Optional[int]
+        scenario_id: Optional[int],
     ) -> int:
-        """Store year-based statistics to database"""
+        """Store year-based statistics to database (single network per database)"""
         try:
             import json
+
             stored_count = 0
-            
-            # Use master scenario if no scenario specified
-            if scenario_id is None:
-                from pyconvexity.models import get_master_scenario_id
-                scenario_id = get_master_scenario_id(conn, network_id)
-            
+
             # Check if network_solve_results_by_year table exists, create if not
-            conn.execute("""
+            conn.execute(
+                """
                 CREATE TABLE IF NOT EXISTS network_solve_results_by_year (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    network_id INTEGER NOT NULL,
-                    scenario_id INTEGER NOT NULL,
+                    scenario_id INTEGER,
                     year INTEGER NOT NULL,
                     results_json TEXT,
                     metadata_json TEXT,
                     created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                    FOREIGN KEY (network_id) REFERENCES networks(id),
                     FOREIGN KEY (scenario_id) REFERENCES scenarios(id),
-                    UNIQUE(network_id, scenario_id, year)
+                    UNIQUE(scenario_id, year)
                 )
-            """)
-            
+            """
+            )
+
             for year, stats in year_statistics.items():
                 try:
                     # Calculate proper year-specific carrier statistics
-                    year_carrier_stats = self._calculate_year_carrier_statistics(conn, network_id, network, year)
-                    
+                    year_carrier_stats = self._calculate_year_carrier_statistics(
+                        conn, network, year
+                    )
+
                     # Merge year-specific carrier stats into the statistics
                     if "custom_statistics" in stats:
                         stats["custom_statistics"].update(year_carrier_stats)
                     else:
                         stats["custom_statistics"] = year_carrier_stats
-                    
+
                     # Wrap the year statistics in the same structure as overall results for consistency
                     year_result_wrapper = {
                         "success": True,
                         "year": year,
-                        "network_statistics": stats
-                    }
-                    
-                    metadata = {
-                        "year": year,
-                        "network_id": network_id,
-                        "scenario_id": scenario_id
+                        "network_statistics": stats,
                     }
-                    
-                    conn.execute("""
-                        INSERT OR REPLACE INTO network_solve_results_by_year 
-                        (network_id, scenario_id, year, results_json, metadata_json)
-                        VALUES (?, ?, ?, ?, ?)
-                    """, (
-                        network_id,
-                        scenario_id,
-                        year,
-                        json.dumps(year_result_wrapper, default=self._json_serializer),
-                        json.dumps(metadata, default=self._json_serializer)
-                    ))
-                    
+
+                    metadata = {"year": year, "scenario_id": scenario_id}
+
+                    # Delete existing result for this scenario+year first (handles NULL scenario_id correctly)
+                    if scenario_id is None:
+                        conn.execute(
+                            """
+                            DELETE FROM network_solve_results_by_year 
+                            WHERE scenario_id IS NULL AND year = ?
+                        """,
+                            (year,),
+                        )
+                    else:
+                        conn.execute(
+                            """
+                            DELETE FROM network_solve_results_by_year 
+                            WHERE scenario_id = ? AND year = ?
+                        """,
+                            (scenario_id, year),
+                        )
+
+                    # Insert new year-based results
+                    conn.execute(
+                        """
+                        INSERT INTO network_solve_results_by_year 
+                        (scenario_id, year, results_json, metadata_json)
+                        VALUES (?, ?, ?, ?)
+                    """,
+                        (
+                            scenario_id,
+                            year,
+                            json.dumps(
+                                year_result_wrapper, default=self._json_serializer
+                            ),
+                            json.dumps(metadata, default=self._json_serializer),
+                        ),
+                    )
+
                     stored_count += 1
                     logger.info(f"Stored year-based statistics for year {year}")
-                    
+
                 except Exception as e:
                     logger.error(f"Failed to store statistics for year {year}: {e}")
                     continue
-            
-            logger.info(f"Successfully stored year-based statistics for {stored_count} years")
+
+            logger.info(
+                f"Successfully stored year-based statistics for {stored_count} years"
+            )
             return stored_count
-            
+
         except Exception as e:
             logger.error(f"Failed to store year-based statistics: {e}", exc_info=True)
             return 0
-    
-    def _calculate_year_carrier_statistics(self, conn, network_id: int, network: 'pypsa.Network', year: int) -> Dict[str, Any]:
+
+    def _calculate_year_carrier_statistics(
+        self, conn, network: "pypsa.Network", year: int
+    ) -> Dict[str, Any]:
         """
         Calculate carrier-specific statistics for a specific year.
         For now, only calculate capacity statistics.
         """
         try:
+            logger.info(f"   🔍 Calculating statistics for year {year}...")
             # Initialize carrier statistics
             carrier_stats = {
                 "dispatch_by_carrier": {},
@@ -621,17 +868,19 @@ class ResultStorage:
                 "emissions_by_carrier": {},
                 "capital_cost_by_carrier": {},
                 "operational_cost_by_carrier": {},
-                "total_system_cost_by_carrier": {}
+                "total_system_cost_by_carrier": {},
             }
-            
+
             # Get all carriers from database
-            cursor = conn.execute("""
-                SELECT DISTINCT name FROM carriers WHERE network_id = ?
-            """, (network_id,))
+            cursor = conn.execute(
+                """
+                SELECT DISTINCT name FROM carriers
+            """
+            )
             all_carriers = [row[0] for row in cursor.fetchall()]
-            
+
             # Initialize all carriers with zero values (including special "Unmet Load" carrier)
-            all_carriers_with_unmet = all_carriers + ['Unmet Load']
+            all_carriers_with_unmet = all_carriers + ["Unmet Load"]
             for carrier in all_carriers_with_unmet:
                 carrier_stats["dispatch_by_carrier"][carrier] = 0.0
                 carrier_stats["power_capacity_by_carrier"][carrier] = 0.0
@@ -640,13 +889,14 @@ class ResultStorage:
                 carrier_stats["capital_cost_by_carrier"][carrier] = 0.0
                 carrier_stats["operational_cost_by_carrier"][carrier] = 0.0
                 carrier_stats["total_system_cost_by_carrier"][carrier] = 0.0
-            
+
             # Calculate dispatch (generation) by carrier for this specific year
-            
+
             # 1. GENERATORS - Generation dispatch (including UNMET_LOAD)
-            if hasattr(network, 'generators_t') and hasattr(network.generators_t, 'p'):
+            if hasattr(network, "generators_t") and hasattr(network.generators_t, "p"):
                 # Get generator-carrier mapping (include both GENERATOR and UNMET_LOAD)
-                cursor = conn.execute("""
+                cursor = conn.execute(
+                    """
                 SELECT c.name as component_name, 
                        CASE 
                            WHEN c.component_type = 'UNMET_LOAD' THEN 'Unmet Load'
@@ -654,135 +904,188 @@ class ResultStorage:
                        END as carrier_name
                 FROM components c
                 JOIN carriers carr ON c.carrier_id = carr.id
-                WHERE c.network_id = ? AND c.component_type IN ('GENERATOR', 'UNMET_LOAD')
-            """, (network_id,))
+                WHERE c.component_type IN ('GENERATOR', 'UNMET_LOAD')
+            """
+                )
                 generator_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
+
                 # Filter generation data for this specific year
-                year_generation = self._filter_timeseries_by_year(network.generators_t.p, network.snapshots, year)
+                year_generation = self._filter_timeseries_by_year(
+                    network.generators_t.p, network.snapshots, year
+                )
                 if year_generation is not None and not year_generation.empty:
                     for gen_name in year_generation.columns:
                         if gen_name in generator_carriers:
                             carrier_name = generator_carriers[gen_name]
-                            
+
                             # Calculate generation for this year (ALWAYS apply snapshot weightings to convert MW to MWh)
                             year_weightings = self._get_year_weightings(network, year)
                             if year_weightings is not None:
-                                generation_mwh = float((year_generation[gen_name].values * year_weightings).sum())
+                                generation_mwh = float(
+                                    (
+                                        year_generation[gen_name].values
+                                        * year_weightings
+                                    ).sum()
+                                )
                             else:
                                 # Fallback: simple sum (will be incorrect for non-1H models)
                                 generation_mwh = float(year_generation[gen_name].sum())
-                                logger.warning(f"Could not apply snapshot weightings for {gen_name} in year {year} - energy may be incorrect")
-                            
+                                logger.warning(
+                                    f"Could not apply snapshot weightings for {gen_name} in year {year} - energy may be incorrect"
+                                )
+
                             if carrier_name in carrier_stats["dispatch_by_carrier"]:
-                                carrier_stats["dispatch_by_carrier"][carrier_name] += generation_mwh
-            
+                                carrier_stats["dispatch_by_carrier"][
+                                    carrier_name
+                                ] += generation_mwh
+
             # 2. STORAGE_UNITS - Discharge only (positive values)
-            if hasattr(network, 'storage_units_t') and hasattr(network.storage_units_t, 'p'):
+            if hasattr(network, "storage_units_t") and hasattr(
+                network.storage_units_t, "p"
+            ):
                 # Get storage unit-carrier mapping
-                cursor = conn.execute("""
+                cursor = conn.execute(
+                    """
                     SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
                     JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.network_id = ? AND c.component_type = 'STORAGE_UNIT'
-                """, (network_id,))
+                    WHERE c.component_type = 'STORAGE_UNIT'
+                """
+                )
                 storage_unit_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
+
                 # Filter storage unit data for this specific year
-                year_storage = self._filter_timeseries_by_year(network.storage_units_t.p, network.snapshots, year)
+                year_storage = self._filter_timeseries_by_year(
+                    network.storage_units_t.p, network.snapshots, year
+                )
                 if year_storage is not None and not year_storage.empty:
                     for su_name in year_storage.columns:
                         if su_name in storage_unit_carriers:
                             carrier_name = storage_unit_carriers[su_name]
-                            
+
                             # Calculate discharge for this year (positive values only, ALWAYS apply snapshot weightings)
                             year_weightings = self._get_year_weightings(network, year)
                             if year_weightings is not None:
-                                discharge_mwh = float((year_storage[su_name].clip(lower=0).values * year_weightings).sum())
+                                discharge_mwh = float(
+                                    (
+                                        year_storage[su_name].clip(lower=0).values
+                                        * year_weightings
+                                    ).sum()
+                                )
                             else:
                                 # Fallback: simple sum (will be incorrect for non-1H models)
-                                discharge_mwh = float(year_storage[su_name].clip(lower=0).sum())
-                                logger.warning(f"Could not apply snapshot weightings for storage unit {su_name} in year {year} - energy may be incorrect")
-                            
+                                discharge_mwh = float(
+                                    year_storage[su_name].clip(lower=0).sum()
+                                )
+                                logger.warning(
+                                    f"Could not apply snapshot weightings for storage unit {su_name} in year {year} - energy may be incorrect"
+                                )
+
                             if carrier_name in carrier_stats["dispatch_by_carrier"]:
-                                carrier_stats["dispatch_by_carrier"][carrier_name] += discharge_mwh
-            
+                                carrier_stats["dispatch_by_carrier"][
+                                    carrier_name
+                                ] += discharge_mwh
+
             # 3. STORES - Discharge only (positive values)
-            if hasattr(network, 'stores_t') and hasattr(network.stores_t, 'p'):
+            if hasattr(network, "stores_t") and hasattr(network.stores_t, "p"):
                 # Get store-carrier mapping
-                cursor = conn.execute("""
+                cursor = conn.execute(
+                    """
                     SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
                     JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.network_id = ? AND c.component_type = 'STORE'
-                """, (network_id,))
+                    WHERE c.component_type = 'STORE'
+                """
+                )
                 store_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
+
                 # Filter store data for this specific year
-                year_stores = self._filter_timeseries_by_year(network.stores_t.p, network.snapshots, year)
+                year_stores = self._filter_timeseries_by_year(
+                    network.stores_t.p, network.snapshots, year
+                )
                 if year_stores is not None and not year_stores.empty:
                     for store_name in year_stores.columns:
                         if store_name in store_carriers:
                             carrier_name = store_carriers[store_name]
-                            
+
                             # Calculate discharge for this year (positive values only, ALWAYS apply snapshot weightings)
                             year_weightings = self._get_year_weightings(network, year)
                             if year_weightings is not None:
-                                discharge_mwh = float((year_stores[store_name].clip(lower=0).values * year_weightings).sum())
+                                discharge_mwh = float(
+                                    (
+                                        year_stores[store_name].clip(lower=0).values
+                                        * year_weightings
+                                    ).sum()
+                                )
                             else:
                                 # Fallback: simple sum (will be incorrect for non-1H models)
-                                discharge_mwh = float(year_stores[store_name].clip(lower=0).sum())
-                                logger.warning(f"Could not apply snapshot weightings for store {store_name} in year {year} - energy may be incorrect")
-                            
+                                discharge_mwh = float(
+                                    year_stores[store_name].clip(lower=0).sum()
+                                )
+                                logger.warning(
+                                    f"Could not apply snapshot weightings for store {store_name} in year {year} - energy may be incorrect"
+                                )
+
                             if carrier_name in carrier_stats["dispatch_by_carrier"]:
-                                carrier_stats["dispatch_by_carrier"][carrier_name] += discharge_mwh
-            
+                                carrier_stats["dispatch_by_carrier"][
+                                    carrier_name
+                                ] += discharge_mwh
+
             # Calculate emissions by carrier for this specific year
             # Get emission factors for all carriers
-            cursor = conn.execute("""
-                SELECT name, co2_emissions FROM carriers WHERE network_id = ?
-            """, (network_id,))
+            cursor = conn.execute(
+                """
+                SELECT name, co2_emissions FROM carriers
+            """
+            )
             emission_factors = {row[0]: row[1] for row in cursor.fetchall()}
-            
+
             # Calculate emissions: dispatch (MWh) × emission factor (tonnes CO2/MWh) = tonnes CO2
-            for carrier_name, dispatch_mwh in carrier_stats["dispatch_by_carrier"].items():
+            for carrier_name, dispatch_mwh in carrier_stats[
+                "dispatch_by_carrier"
+            ].items():
                 # Handle None values safely
                 if dispatch_mwh is None:
                     dispatch_mwh = 0.0
-                
-                emission_factor = emission_factors.get(carrier_name, 0.0)  # Default to 0 if no emission factor
+
+                emission_factor = emission_factors.get(
+                    carrier_name, 0.0
+                )  # Default to 0 if no emission factor
                 if emission_factor is None:
                     emission_factor = 0.0
-                
+
                 emissions_tonnes = dispatch_mwh * emission_factor
-                
+
                 if carrier_name in carrier_stats["emissions_by_carrier"]:
-                    carrier_stats["emissions_by_carrier"][carrier_name] += emissions_tonnes
-            
+                    carrier_stats["emissions_by_carrier"][
+                        carrier_name
+                    ] += emissions_tonnes
+
             # Calculate capital costs by carrier for this specific year
             # Capital costs are annualized and counted every year the component is active
-            
+
             # Helper function to check if component is active in this year
             def is_component_active(build_year, lifetime, current_year):
                 """Check if component is active in the current year based on build_year and lifetime"""
                 if pd.isna(build_year):
                     return True  # No build year constraint
-                
+
                 build_year = int(build_year)
                 if build_year > current_year:
                     return False  # Not built yet
-                
-                if pd.isna(lifetime) or lifetime == float('inf'):
+
+                if pd.isna(lifetime) or lifetime == float("inf"):
                     return True  # Infinite lifetime
-                
+
                 lifetime = int(lifetime)
                 end_year = build_year + lifetime - 1
                 return current_year <= end_year
-            
+
             # 1. GENERATORS - Capital costs (including UNMET_LOAD)
-            if hasattr(network, 'generators') and not network.generators.empty:
+            if hasattr(network, "generators") and not network.generators.empty:
                 # Get generator info: carrier, capital_cost, build_year, lifetime (include UNMET_LOAD)
-                cursor = conn.execute("""
+                cursor = conn.execute(
+                    """
                     SELECT c.name as component_name, 
                            CASE 
                                WHEN c.component_type = 'UNMET_LOAD' THEN 'Unmet Load'
@@ -790,178 +1093,308 @@ class ResultStorage:
                            END as carrier_name
                     FROM components c
                     JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.network_id = ? AND c.component_type IN ('GENERATOR', 'UNMET_LOAD')
-                """, (network_id,))
+                    WHERE c.component_type IN ('GENERATOR', 'UNMET_LOAD')
+                """
+                )
                 generator_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
+
                 for gen_name in network.generators.index:
                     if gen_name in generator_carriers:
                         carrier_name = generator_carriers[gen_name]
-                        
+
                         # Get build year and lifetime
-                        build_year = network.generators.loc[gen_name, 'build_year'] if 'build_year' in network.generators.columns else None
-                        lifetime = network.generators.loc[gen_name, 'lifetime'] if 'lifetime' in network.generators.columns else None
-                        
+                        build_year = (
+                            network.generators.loc[gen_name, "build_year"]
+                            if "build_year" in network.generators.columns
+                            else None
+                        )
+                        lifetime = (
+                            network.generators.loc[gen_name, "lifetime"]
+                            if "lifetime" in network.generators.columns
+                            else None
+                        )
+
                         # Check if component is active in this year
                         if is_component_active(build_year, lifetime, year):
                             # Get capacity and capital cost
-                            if 'p_nom_opt' in network.generators.columns:
-                                capacity_mw = float(network.generators.loc[gen_name, 'p_nom_opt'])
+                            if "p_nom_opt" in network.generators.columns:
+                                capacity_mw = float(
+                                    network.generators.loc[gen_name, "p_nom_opt"]
+                                )
                             else:
-                                capacity_mw = float(network.generators.loc[gen_name, 'p_nom']) if 'p_nom' in network.generators.columns else 0.0
-                            
-                            capital_cost_per_mw = float(network.generators.loc[gen_name, 'capital_cost']) if 'capital_cost' in network.generators.columns else 0.0
-                            
+                                capacity_mw = (
+                                    float(network.generators.loc[gen_name, "p_nom"])
+                                    if "p_nom" in network.generators.columns
+                                    else 0.0
+                                )
+
+                            capital_cost_per_mw = (
+                                float(network.generators.loc[gen_name, "capital_cost"])
+                                if "capital_cost" in network.generators.columns
+                                else 0.0
+                            )
+
                             # Calculate annualized capital cost for this year
                             annual_capital_cost = capacity_mw * capital_cost_per_mw
                             
+                            # Log capital cost calculation details with unit check
+                            if annual_capital_cost > 0.001:
+                                logger.info(
+                                    f"    💰 Capital cost calc for {gen_name} ({carrier_name}) in year {year}: "
+                                    f"{capacity_mw:.2f} MW × {capital_cost_per_mw:.2f} currency/MW = {annual_capital_cost:.2f} currency"
+                                )
+                                # Check if values seem too small (might be in kUSD instead of USD)
+                                if capital_cost_per_mw > 0 and capital_cost_per_mw < 1:
+                                    logger.warning(
+                                        f"      ⚠️ WARNING: capital_cost_per_mw ({capital_cost_per_mw:.2f}) seems very small. "
+                                        f"Expected USD/MW but might be in kUSD/MW (thousands)?"
+                                    )
+                                if annual_capital_cost > 0 and annual_capital_cost < 1000:
+                                    logger.warning(
+                                        f"      ⚠️ WARNING: annual_capital_cost ({annual_capital_cost:.2f}) seems very small. "
+                                        f"Expected USD but might be in kUSD (thousands)?"
+                                    )
+
                             if carrier_name in carrier_stats["capital_cost_by_carrier"]:
-                                carrier_stats["capital_cost_by_carrier"][carrier_name] += annual_capital_cost
-            
+                                carrier_stats["capital_cost_by_carrier"][
+                                    carrier_name
+                                ] += annual_capital_cost
+
             # 2. STORAGE_UNITS - Capital costs
-            if hasattr(network, 'storage_units') and not network.storage_units.empty:
-                cursor = conn.execute("""
+            if hasattr(network, "storage_units") and not network.storage_units.empty:
+                cursor = conn.execute(
+                    """
                     SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
                     JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.network_id = ? AND c.component_type = 'STORAGE_UNIT'
-                """, (network_id,))
+                    WHERE c.component_type = 'STORAGE_UNIT'
+                """
+                )
                 storage_unit_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
+
                 for su_name in network.storage_units.index:
                     if su_name in storage_unit_carriers:
                         carrier_name = storage_unit_carriers[su_name]
-                        
+
                         # Get build year and lifetime
-                        build_year = network.storage_units.loc[su_name, 'build_year'] if 'build_year' in network.storage_units.columns else None
-                        lifetime = network.storage_units.loc[su_name, 'lifetime'] if 'lifetime' in network.storage_units.columns else None
-                        
+                        build_year = (
+                            network.storage_units.loc[su_name, "build_year"]
+                            if "build_year" in network.storage_units.columns
+                            else None
+                        )
+                        lifetime = (
+                            network.storage_units.loc[su_name, "lifetime"]
+                            if "lifetime" in network.storage_units.columns
+                            else None
+                        )
+
                         # Check if component is active in this year
                         if is_component_active(build_year, lifetime, year):
                             # Get power capacity and capital cost (per MW)
-                            if 'p_nom_opt' in network.storage_units.columns:
-                                capacity_mw = float(network.storage_units.loc[su_name, 'p_nom_opt'])
+                            if "p_nom_opt" in network.storage_units.columns:
+                                capacity_mw = float(
+                                    network.storage_units.loc[su_name, "p_nom_opt"]
+                                )
                             else:
-                                capacity_mw = float(network.storage_units.loc[su_name, 'p_nom']) if 'p_nom' in network.storage_units.columns else 0.0
-                            
-                            capital_cost_per_mw = float(network.storage_units.loc[su_name, 'capital_cost']) if 'capital_cost' in network.storage_units.columns else 0.0
-                            
+                                capacity_mw = (
+                                    float(network.storage_units.loc[su_name, "p_nom"])
+                                    if "p_nom" in network.storage_units.columns
+                                    else 0.0
+                                )
+
+                            capital_cost_per_mw = (
+                                float(
+                                    network.storage_units.loc[su_name, "capital_cost"]
+                                )
+                                if "capital_cost" in network.storage_units.columns
+                                else 0.0
+                            )
+
                             # Calculate annualized capital cost for this year
                             annual_capital_cost = capacity_mw * capital_cost_per_mw
-                            
+
                             if carrier_name in carrier_stats["capital_cost_by_carrier"]:
-                                carrier_stats["capital_cost_by_carrier"][carrier_name] += annual_capital_cost
-            
+                                carrier_stats["capital_cost_by_carrier"][
+                                    carrier_name
+                                ] += annual_capital_cost
+
             # 3. STORES - Capital costs (per MWh)
-            if hasattr(network, 'stores') and not network.stores.empty:
-                cursor = conn.execute("""
+            if hasattr(network, "stores") and not network.stores.empty:
+                cursor = conn.execute(
+                    """
                     SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
                     JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.network_id = ? AND c.component_type = 'STORE'
-                """, (network_id,))
+                    WHERE c.component_type = 'STORE'
+                """
+                )
                 store_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
+
                 for store_name in network.stores.index:
                     if store_name in store_carriers:
                         carrier_name = store_carriers[store_name]
-                        
+
                         # Get build year and lifetime
-                        build_year = network.stores.loc[store_name, 'build_year'] if 'build_year' in network.stores.columns else None
-                        lifetime = network.stores.loc[store_name, 'lifetime'] if 'lifetime' in network.stores.columns else None
-                        
+                        build_year = (
+                            network.stores.loc[store_name, "build_year"]
+                            if "build_year" in network.stores.columns
+                            else None
+                        )
+                        lifetime = (
+                            network.stores.loc[store_name, "lifetime"]
+                            if "lifetime" in network.stores.columns
+                            else None
+                        )
+
                         # Check if component is active in this year
                         if is_component_active(build_year, lifetime, year):
                             # Get energy capacity and capital cost (per MWh)
-                            if 'e_nom_opt' in network.stores.columns:
-                                capacity_mwh = float(network.stores.loc[store_name, 'e_nom_opt'])
+                            if "e_nom_opt" in network.stores.columns:
+                                capacity_mwh = float(
+                                    network.stores.loc[store_name, "e_nom_opt"]
+                                )
                             else:
-                                capacity_mwh = float(network.stores.loc[store_name, 'e_nom']) if 'e_nom' in network.stores.columns else 0.0
-                            
-                            capital_cost_per_mwh = float(network.stores.loc[store_name, 'capital_cost']) if 'capital_cost' in network.stores.columns else 0.0
-                            
+                                capacity_mwh = (
+                                    float(network.stores.loc[store_name, "e_nom"])
+                                    if "e_nom" in network.stores.columns
+                                    else 0.0
+                                )
+
+                            capital_cost_per_mwh = (
+                                float(network.stores.loc[store_name, "capital_cost"])
+                                if "capital_cost" in network.stores.columns
+                                else 0.0
+                            )
+
                             # Calculate annualized capital cost for this year
                             annual_capital_cost = capacity_mwh * capital_cost_per_mwh
-                            
+
                             if carrier_name in carrier_stats["capital_cost_by_carrier"]:
-                                carrier_stats["capital_cost_by_carrier"][carrier_name] += annual_capital_cost
-            
+                                carrier_stats["capital_cost_by_carrier"][
+                                    carrier_name
+                                ] += annual_capital_cost
+
             # 4. LINES - Capital costs (per MVA)
-            if hasattr(network, 'lines') and not network.lines.empty:
-                cursor = conn.execute("""
+            if hasattr(network, "lines") and not network.lines.empty:
+                cursor = conn.execute(
+                    """
                     SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
                     JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.network_id = ? AND c.component_type = 'LINE'
-                """, (network_id,))
+                    WHERE c.component_type = 'LINE'
+                """
+                )
                 line_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
+
                 for line_name in network.lines.index:
                     if line_name in line_carriers:
                         carrier_name = line_carriers[line_name]
-                        
+
                         # Get build year and lifetime
-                        build_year = network.lines.loc[line_name, 'build_year'] if 'build_year' in network.lines.columns else None
-                        lifetime = network.lines.loc[line_name, 'lifetime'] if 'lifetime' in network.lines.columns else None
-                        
+                        build_year = (
+                            network.lines.loc[line_name, "build_year"]
+                            if "build_year" in network.lines.columns
+                            else None
+                        )
+                        lifetime = (
+                            network.lines.loc[line_name, "lifetime"]
+                            if "lifetime" in network.lines.columns
+                            else None
+                        )
+
                         # Check if component is active in this year
                         if is_component_active(build_year, lifetime, year):
                             # Get apparent power capacity and capital cost (per MVA)
-                            if 's_nom_opt' in network.lines.columns:
-                                capacity_mva = float(network.lines.loc[line_name, 's_nom_opt'])
+                            if "s_nom_opt" in network.lines.columns:
+                                capacity_mva = float(
+                                    network.lines.loc[line_name, "s_nom_opt"]
+                                )
                             else:
-                                capacity_mva = float(network.lines.loc[line_name, 's_nom']) if 's_nom' in network.lines.columns else 0.0
-                            
-                            capital_cost_per_mva = float(network.lines.loc[line_name, 'capital_cost']) if 'capital_cost' in network.lines.columns else 0.0
-                            
+                                capacity_mva = (
+                                    float(network.lines.loc[line_name, "s_nom"])
+                                    if "s_nom" in network.lines.columns
+                                    else 0.0
+                                )
+
+                            capital_cost_per_mva = (
+                                float(network.lines.loc[line_name, "capital_cost"])
+                                if "capital_cost" in network.lines.columns
+                                else 0.0
+                            )
+
                             # Calculate annualized capital cost for this year
                             annual_capital_cost = capacity_mva * capital_cost_per_mva
-            
+
                             if carrier_name in carrier_stats["capital_cost_by_carrier"]:
-                                carrier_stats["capital_cost_by_carrier"][carrier_name] += annual_capital_cost
-            
+                                carrier_stats["capital_cost_by_carrier"][
+                                    carrier_name
+                                ] += annual_capital_cost
+
             # 5. LINKS - Capital costs (per MW)
-            if hasattr(network, 'links') and not network.links.empty:
-                cursor = conn.execute("""
+            if hasattr(network, "links") and not network.links.empty:
+                cursor = conn.execute(
+                    """
                     SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
                     JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.network_id = ? AND c.component_type = 'LINK'
-                """, (network_id,))
+                    WHERE c.component_type = 'LINK'
+                """
+                )
                 link_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
+
                 for link_name in network.links.index:
                     if link_name in link_carriers:
                         carrier_name = link_carriers[link_name]
-                        
+
                         # Get build year and lifetime
-                        build_year = network.links.loc[link_name, 'build_year'] if 'build_year' in network.links.columns else None
-                        lifetime = network.links.loc[link_name, 'lifetime'] if 'lifetime' in network.links.columns else None
-                        
+                        build_year = (
+                            network.links.loc[link_name, "build_year"]
+                            if "build_year" in network.links.columns
+                            else None
+                        )
+                        lifetime = (
+                            network.links.loc[link_name, "lifetime"]
+                            if "lifetime" in network.links.columns
+                            else None
+                        )
+
                         # Check if component is active in this year
                         if is_component_active(build_year, lifetime, year):
                             # Get power capacity and capital cost (per MW)
-                            if 'p_nom_opt' in network.links.columns:
-                                capacity_mw = float(network.links.loc[link_name, 'p_nom_opt'])
+                            if "p_nom_opt" in network.links.columns:
+                                capacity_mw = float(
+                                    network.links.loc[link_name, "p_nom_opt"]
+                                )
                             else:
-                                capacity_mw = float(network.links.loc[link_name, 'p_nom']) if 'p_nom' in network.links.columns else 0.0
-                            
-                            capital_cost_per_mw = float(network.links.loc[link_name, 'capital_cost']) if 'capital_cost' in network.links.columns else 0.0
-                            
+                                capacity_mw = (
+                                    float(network.links.loc[link_name, "p_nom"])
+                                    if "p_nom" in network.links.columns
+                                    else 0.0
+                                )
+
+                            capital_cost_per_mw = (
+                                float(network.links.loc[link_name, "capital_cost"])
+                                if "capital_cost" in network.links.columns
+                                else 0.0
+                            )
+
                             # Calculate annualized capital cost for this year
                             annual_capital_cost = capacity_mw * capital_cost_per_mw
-                            
+
                             if carrier_name in carrier_stats["capital_cost_by_carrier"]:
-                                carrier_stats["capital_cost_by_carrier"][carrier_name] += annual_capital_cost
-            
+                                carrier_stats["capital_cost_by_carrier"][
+                                    carrier_name
+                                ] += annual_capital_cost
+
             # Calculate operational costs by carrier for this specific year
             # Operational costs = dispatch (MWh) × marginal_cost (currency/MWh)
             # Only for components that are active in this year
-            
+
             # 1. GENERATORS - Operational costs (including UNMET_LOAD)
-            if hasattr(network, 'generators_t') and hasattr(network.generators_t, 'p'):
+            if hasattr(network, "generators_t") and hasattr(network.generators_t, "p"):
                 # Get generator info: carrier, marginal_cost, build_year, lifetime (include UNMET_LOAD)
-                cursor = conn.execute("""
+                cursor = conn.execute(
+                    """
                     SELECT c.name as component_name, 
                            CASE 
                                WHEN c.component_type = 'UNMET_LOAD' THEN 'Unmet Load'
@@ -969,135 +1402,259 @@ class ResultStorage:
                            END as carrier_name
                     FROM components c
                     JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.network_id = ? AND c.component_type IN ('GENERATOR', 'UNMET_LOAD')
-                """, (network_id,))
+                    WHERE c.component_type IN ('GENERATOR', 'UNMET_LOAD')
+                """
+                )
                 generator_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
+
                 # Filter generation data for this specific year
-                year_generation = self._filter_timeseries_by_year(network.generators_t.p, network.snapshots, year)
+                year_generation = self._filter_timeseries_by_year(
+                    network.generators_t.p, network.snapshots, year
+                )
                 if year_generation is not None and not year_generation.empty:
                     for gen_name in year_generation.columns:
                         if gen_name in generator_carriers:
                             carrier_name = generator_carriers[gen_name]
-                            
+
                             # Get build year and lifetime
-                            build_year = network.generators.loc[gen_name, 'build_year'] if 'build_year' in network.generators.columns else None
-                            lifetime = network.generators.loc[gen_name, 'lifetime'] if 'lifetime' in network.generators.columns else None
-                            
+                            build_year = (
+                                network.generators.loc[gen_name, "build_year"]
+                                if "build_year" in network.generators.columns
+                                else None
+                            )
+                            lifetime = (
+                                network.generators.loc[gen_name, "lifetime"]
+                                if "lifetime" in network.generators.columns
+                                else None
+                            )
+
                             # Check if component is active in this year
                             if is_component_active(build_year, lifetime, year):
                                 # Calculate generation for this year (already calculated above, but need to recalculate for operational costs)
-                                year_weightings = self._get_year_weightings(network, year)
+                                year_weightings = self._get_year_weightings(
+                                    network, year
+                                )
                                 if year_weightings is not None:
-                                    generation_mwh = float((year_generation[gen_name].values * year_weightings).sum())
+                                    generation_mwh = float(
+                                        (
+                                            year_generation[gen_name].values
+                                            * year_weightings
+                                        ).sum()
+                                    )
                                 else:
-                                    generation_mwh = float(year_generation[gen_name].sum())
-                                
+                                    generation_mwh = float(
+                                        year_generation[gen_name].sum()
+                                    )
+
                                 # Get marginal cost
-                                marginal_cost = float(network.generators.loc[gen_name, 'marginal_cost']) if 'marginal_cost' in network.generators.columns else 0.0
-                                
+                                marginal_cost = (
+                                    float(
+                                        network.generators.loc[
+                                            gen_name, "marginal_cost"
+                                        ]
+                                    )
+                                    if "marginal_cost" in network.generators.columns
+                                    else 0.0
+                                )
+
                                 # Calculate operational cost for this year
                                 operational_cost = generation_mwh * marginal_cost
                                 
-                                if carrier_name in carrier_stats["operational_cost_by_carrier"]:
-                                    carrier_stats["operational_cost_by_carrier"][carrier_name] += operational_cost
-            
+                                # Log operational cost calculation details with unit check
+                                if operational_cost > 0.001:
+                                    logger.info(
+                                        f"    💰 Operational cost calc for {gen_name} ({carrier_name}) in year {year}: "
+                                        f"{generation_mwh:.2f} MWh × {marginal_cost:.2f} currency/MWh = {operational_cost:.2f} currency"
+                                    )
+                                    # Check if values seem too small (might be in kUSD instead of USD)
+                                    if marginal_cost > 0 and marginal_cost < 1:
+                                        logger.warning(
+                                            f"      ⚠️ WARNING: marginal_cost ({marginal_cost:.2f}) seems very small. "
+                                            f"Expected USD/MWh but might be in kUSD/MWh (thousands)?"
+                                        )
+                                    if operational_cost > 0 and operational_cost < 1000:
+                                        logger.warning(
+                                            f"      ⚠️ WARNING: operational_cost ({operational_cost:.2f}) seems very small. "
+                                            f"Expected USD but might be in kUSD (thousands)?"
+                                        )
+
+                                if (
+                                    carrier_name
+                                    in carrier_stats["operational_cost_by_carrier"]
+                                ):
+                                    carrier_stats["operational_cost_by_carrier"][
+                                        carrier_name
+                                    ] += operational_cost
+
             # 2. STORAGE_UNITS - Operational costs (discharge only)
-            if hasattr(network, 'storage_units_t') and hasattr(network.storage_units_t, 'p'):
+            if hasattr(network, "storage_units_t") and hasattr(
+                network.storage_units_t, "p"
+            ):
                 # Get storage unit info: carrier, marginal_cost, build_year, lifetime
-                cursor = conn.execute("""
+                cursor = conn.execute(
+                    """
                     SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
                     JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.network_id = ? AND c.component_type = 'STORAGE_UNIT'
-                """, (network_id,))
+                    WHERE c.component_type = 'STORAGE_UNIT'
+                """
+                )
                 storage_unit_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
+
                 # Filter storage unit data for this specific year
-                year_storage = self._filter_timeseries_by_year(network.storage_units_t.p, network.snapshots, year)
+                year_storage = self._filter_timeseries_by_year(
+                    network.storage_units_t.p, network.snapshots, year
+                )
                 if year_storage is not None and not year_storage.empty:
                     for su_name in year_storage.columns:
                         if su_name in storage_unit_carriers:
                             carrier_name = storage_unit_carriers[su_name]
-                            
+
                             # Get build year and lifetime
-                            build_year = network.storage_units.loc[su_name, 'build_year'] if 'build_year' in network.storage_units.columns else None
-                            lifetime = network.storage_units.loc[su_name, 'lifetime'] if 'lifetime' in network.storage_units.columns else None
-                            
+                            build_year = (
+                                network.storage_units.loc[su_name, "build_year"]
+                                if "build_year" in network.storage_units.columns
+                                else None
+                            )
+                            lifetime = (
+                                network.storage_units.loc[su_name, "lifetime"]
+                                if "lifetime" in network.storage_units.columns
+                                else None
+                            )
+
                             # Check if component is active in this year
                             if is_component_active(build_year, lifetime, year):
                                 # Calculate discharge for this year (positive values only)
-                                year_weightings = self._get_year_weightings(network, year)
+                                year_weightings = self._get_year_weightings(
+                                    network, year
+                                )
                                 if year_weightings is not None:
-                                    discharge_mwh = float((year_storage[su_name].clip(lower=0).values * year_weightings).sum())
+                                    discharge_mwh = float(
+                                        (
+                                            year_storage[su_name].clip(lower=0).values
+                                            * year_weightings
+                                        ).sum()
+                                    )
                                 else:
-                                    discharge_mwh = float(year_storage[su_name].clip(lower=0).sum())
-                                
+                                    discharge_mwh = float(
+                                        year_storage[su_name].clip(lower=0).sum()
+                                    )
+
                                 # Get marginal cost
-                                marginal_cost = float(network.storage_units.loc[su_name, 'marginal_cost']) if 'marginal_cost' in network.storage_units.columns else 0.0
-                                
+                                marginal_cost = (
+                                    float(
+                                        network.storage_units.loc[
+                                            su_name, "marginal_cost"
+                                        ]
+                                    )
+                                    if "marginal_cost" in network.storage_units.columns
+                                    else 0.0
+                                )
+
                                 # Calculate operational cost for this year
                                 operational_cost = discharge_mwh * marginal_cost
-                                
-                                if carrier_name in carrier_stats["operational_cost_by_carrier"]:
-                                    carrier_stats["operational_cost_by_carrier"][carrier_name] += operational_cost
-            
+
+                                if (
+                                    carrier_name
+                                    in carrier_stats["operational_cost_by_carrier"]
+                                ):
+                                    carrier_stats["operational_cost_by_carrier"][
+                                        carrier_name
+                                    ] += operational_cost
+
             # 3. STORES - Operational costs (discharge only)
-            if hasattr(network, 'stores_t') and hasattr(network.stores_t, 'p'):
+            if hasattr(network, "stores_t") and hasattr(network.stores_t, "p"):
                 # Get store info: carrier, marginal_cost, build_year, lifetime
-                cursor = conn.execute("""
+                cursor = conn.execute(
+                    """
                     SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
                     JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.network_id = ? AND c.component_type = 'STORE'
-                """, (network_id,))
+                    WHERE c.component_type = 'STORE'
+                """
+                )
                 store_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
+
                 # Filter store data for this specific year
-                year_stores = self._filter_timeseries_by_year(network.stores_t.p, network.snapshots, year)
+                year_stores = self._filter_timeseries_by_year(
+                    network.stores_t.p, network.snapshots, year
+                )
                 if year_stores is not None and not year_stores.empty:
                     for store_name in year_stores.columns:
                         if store_name in store_carriers:
                             carrier_name = store_carriers[store_name]
-                            
+
                             # Get build year and lifetime
-                            build_year = network.stores.loc[store_name, 'build_year'] if 'build_year' in network.stores.columns else None
-                            lifetime = network.stores.loc[store_name, 'lifetime'] if 'lifetime' in network.stores.columns else None
-                            
+                            build_year = (
+                                network.stores.loc[store_name, "build_year"]
+                                if "build_year" in network.stores.columns
+                                else None
+                            )
+                            lifetime = (
+                                network.stores.loc[store_name, "lifetime"]
+                                if "lifetime" in network.stores.columns
+                                else None
+                            )
+
                             # Check if component is active in this year
                             if is_component_active(build_year, lifetime, year):
                                 # Calculate discharge for this year (positive values only)
-                                year_weightings = self._get_year_weightings(network, year)
+                                year_weightings = self._get_year_weightings(
+                                    network, year
+                                )
                                 if year_weightings is not None:
-                                    discharge_mwh = float((year_stores[store_name].clip(lower=0).values * year_weightings).sum())
+                                    discharge_mwh = float(
+                                        (
+                                            year_stores[store_name].clip(lower=0).values
+                                            * year_weightings
+                                        ).sum()
+                                    )
                                 else:
-                                    discharge_mwh = float(year_stores[store_name].clip(lower=0).sum())
-                                
+                                    discharge_mwh = float(
+                                        year_stores[store_name].clip(lower=0).sum()
+                                    )
+
                                 # Get marginal cost
-                                marginal_cost = float(network.stores.loc[store_name, 'marginal_cost']) if 'marginal_cost' in network.stores.columns else 0.0
-                                
+                                marginal_cost = (
+                                    float(
+                                        network.stores.loc[store_name, "marginal_cost"]
+                                    )
+                                    if "marginal_cost" in network.stores.columns
+                                    else 0.0
+                                )
+
                                 # Calculate operational cost for this year
                                 operational_cost = discharge_mwh * marginal_cost
-                            
-                            if carrier_name in carrier_stats["operational_cost_by_carrier"]:
-                                carrier_stats["operational_cost_by_carrier"][carrier_name] += operational_cost
-                        
+
+                                if (
+                                    carrier_name
+                                    in carrier_stats["operational_cost_by_carrier"]
+                                ):
+                                    carrier_stats["operational_cost_by_carrier"][
+                                        carrier_name
+                                    ] += operational_cost
+
             # Calculate total system costs by carrier for this specific year
             # Total system cost = capital cost + operational cost
             for carrier_name in carrier_stats["capital_cost_by_carrier"]:
                 capital_cost = carrier_stats["capital_cost_by_carrier"][carrier_name]
-                operational_cost = carrier_stats["operational_cost_by_carrier"][carrier_name]
+                operational_cost = carrier_stats["operational_cost_by_carrier"][
+                    carrier_name
+                ]
                 total_system_cost = capital_cost + operational_cost
-                
+
                 if carrier_name in carrier_stats["total_system_cost_by_carrier"]:
-                    carrier_stats["total_system_cost_by_carrier"][carrier_name] = total_system_cost
-            
+                    carrier_stats["total_system_cost_by_carrier"][
+                        carrier_name
+                    ] = total_system_cost
+
             # Calculate capacity by carrier for this specific year
-            
+
             # 4. GENERATORS - Power capacity (MW) (including UNMET_LOAD)
-            if hasattr(network, 'generators') and not network.generators.empty:
+            if hasattr(network, "generators") and not network.generators.empty:
                 # Get generator-carrier mapping (include UNMET_LOAD)
-                cursor = conn.execute("""
+                cursor = conn.execute(
+                    """
                     SELECT c.name as component_name, 
                            CASE 
                                WHEN c.component_type = 'UNMET_LOAD' THEN 'Unmet Load'
@@ -1105,183 +1662,287 @@ class ResultStorage:
                            END as carrier_name
                     FROM components c
                     JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.network_id = ? AND c.component_type IN ('GENERATOR', 'UNMET_LOAD')
-                """, (network_id,))
+                    WHERE c.component_type IN ('GENERATOR', 'UNMET_LOAD')
+                """
+                )
                 generator_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
+
                 for gen_name in network.generators.index:
                     if gen_name in generator_carriers:
                         carrier_name = generator_carriers[gen_name]
-                        
+
                         # Check if this generator is available in this year (build_year <= year)
                         is_available = True
-                        if 'build_year' in network.generators.columns:
-                            build_year = network.generators.loc[gen_name, 'build_year']
+                        if "build_year" in network.generators.columns:
+                            build_year = network.generators.loc[gen_name, "build_year"]
                             if pd.notna(build_year) and int(build_year) > year:
                                 is_available = False
-                        
+
                         if is_available:
                             # Use p_nom_opt if available, otherwise p_nom
-                            if 'p_nom_opt' in network.generators.columns:
-                                capacity_mw = float(network.generators.loc[gen_name, 'p_nom_opt'])
+                            if "p_nom_opt" in network.generators.columns:
+                                capacity_mw = float(
+                                    network.generators.loc[gen_name, "p_nom_opt"]
+                                )
                             else:
-                                capacity_mw = float(network.generators.loc[gen_name, 'p_nom']) if 'p_nom' in network.generators.columns else 0.0
-                            
-                            if carrier_name in carrier_stats["power_capacity_by_carrier"]:
-                                carrier_stats["power_capacity_by_carrier"][carrier_name] += capacity_mw
-                                
+                                capacity_mw = (
+                                    float(network.generators.loc[gen_name, "p_nom"])
+                                    if "p_nom" in network.generators.columns
+                                    else 0.0
+                                )
+
+                            if (
+                                carrier_name
+                                in carrier_stats["power_capacity_by_carrier"]
+                            ):
+                                carrier_stats["power_capacity_by_carrier"][
+                                    carrier_name
+                                ] += capacity_mw
+
             # 2. STORAGE_UNITS - Power capacity (MW) + Energy capacity (MWh)
-            if hasattr(network, 'storage_units') and not network.storage_units.empty:
+            if hasattr(network, "storage_units") and not network.storage_units.empty:
                 # Get storage unit-carrier mapping
-                cursor = conn.execute("""
+                cursor = conn.execute(
+                    """
                     SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
                     JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.network_id = ? AND c.component_type = 'STORAGE_UNIT'
-                """, (network_id,))
+                    WHERE c.component_type = 'STORAGE_UNIT'
+                """
+                )
                 storage_unit_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
+
                 for su_name in network.storage_units.index:
                     if su_name in storage_unit_carriers:
                         carrier_name = storage_unit_carriers[su_name]
-                        
+
                         # Check if this storage unit is available in this year
                         is_available = True
-                        if 'build_year' in network.storage_units.columns:
-                            build_year = network.storage_units.loc[su_name, 'build_year']
+                        if "build_year" in network.storage_units.columns:
+                            build_year = network.storage_units.loc[
+                                su_name, "build_year"
+                            ]
                             if pd.notna(build_year) and int(build_year) > year:
                                 is_available = False
-                        
+
                         if is_available:
                             # Power capacity (MW)
-                            if 'p_nom_opt' in network.storage_units.columns:
-                                p_nom_opt = float(network.storage_units.loc[su_name, 'p_nom_opt'])
+                            if "p_nom_opt" in network.storage_units.columns:
+                                p_nom_opt = float(
+                                    network.storage_units.loc[su_name, "p_nom_opt"]
+                                )
                             else:
-                                p_nom_opt = float(network.storage_units.loc[su_name, 'p_nom']) if 'p_nom' in network.storage_units.columns else 0.0
-                            
-                            if carrier_name in carrier_stats["power_capacity_by_carrier"]:
-                                carrier_stats["power_capacity_by_carrier"][carrier_name] += p_nom_opt
-                            
+                                p_nom_opt = (
+                                    float(network.storage_units.loc[su_name, "p_nom"])
+                                    if "p_nom" in network.storage_units.columns
+                                    else 0.0
+                                )
+
+                            if (
+                                carrier_name
+                                in carrier_stats["power_capacity_by_carrier"]
+                            ):
+                                carrier_stats["power_capacity_by_carrier"][
+                                    carrier_name
+                                ] += p_nom_opt
+
                             # Energy capacity (MWh) using max_hours
                             max_hours = 1.0  # Default
-                            if 'max_hours' in network.storage_units.columns:
-                                max_hours = float(network.storage_units.loc[su_name, 'max_hours'])
+                            if "max_hours" in network.storage_units.columns:
+                                max_hours = float(
+                                    network.storage_units.loc[su_name, "max_hours"]
+                                )
                             energy_capacity_mwh = p_nom_opt * max_hours
-                            
-                            if carrier_name in carrier_stats["energy_capacity_by_carrier"]:
-                                carrier_stats["energy_capacity_by_carrier"][carrier_name] += energy_capacity_mwh
-            
+
+                            if (
+                                carrier_name
+                                in carrier_stats["energy_capacity_by_carrier"]
+                            ):
+                                carrier_stats["energy_capacity_by_carrier"][
+                                    carrier_name
+                                ] += energy_capacity_mwh
+
             # 3. STORES - Energy capacity (MWh) only
-            if hasattr(network, 'stores') and not network.stores.empty:
+            if hasattr(network, "stores") and not network.stores.empty:
                 # Get store-carrier mapping
-                cursor = conn.execute("""
+                cursor = conn.execute(
+                    """
                     SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
                     JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.network_id = ? AND c.component_type = 'STORE'
-                """, (network_id,))
+                    WHERE c.component_type = 'STORE'
+                """
+                )
                 store_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
+
                 for store_name in network.stores.index:
                     if store_name in store_carriers:
                         carrier_name = store_carriers[store_name]
-                        
+
                         # Check if this store is available in this year
                         is_available = True
-                        if 'build_year' in network.stores.columns:
-                            build_year = network.stores.loc[store_name, 'build_year']
+                        if "build_year" in network.stores.columns:
+                            build_year = network.stores.loc[store_name, "build_year"]
                             if pd.notna(build_year) and int(build_year) > year:
                                 is_available = False
-                        
+
                         if is_available:
                             # Energy capacity (MWh)
-                            if 'e_nom_opt' in network.stores.columns:
-                                capacity_mwh = float(network.stores.loc[store_name, 'e_nom_opt'])
+                            if "e_nom_opt" in network.stores.columns:
+                                capacity_mwh = float(
+                                    network.stores.loc[store_name, "e_nom_opt"]
+                                )
                             else:
-                                capacity_mwh = float(network.stores.loc[store_name, 'e_nom']) if 'e_nom' in network.stores.columns else 0.0
-                            
-                            if carrier_name in carrier_stats["energy_capacity_by_carrier"]:
-                                carrier_stats["energy_capacity_by_carrier"][carrier_name] += capacity_mwh
-                                
+                                capacity_mwh = (
+                                    float(network.stores.loc[store_name, "e_nom"])
+                                    if "e_nom" in network.stores.columns
+                                    else 0.0
+                                )
+
+                            if (
+                                carrier_name
+                                in carrier_stats["energy_capacity_by_carrier"]
+                            ):
+                                carrier_stats["energy_capacity_by_carrier"][
+                                    carrier_name
+                                ] += capacity_mwh
+
             # 4. LINES - Apparent power capacity (MVA -> MW)
-            if hasattr(network, 'lines') and not network.lines.empty:
+            if hasattr(network, "lines") and not network.lines.empty:
                 # Get line-carrier mapping
-                cursor = conn.execute("""
+                cursor = conn.execute(
+                    """
                     SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
                     JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.network_id = ? AND c.component_type = 'LINE'
-                """, (network_id,))
+                    WHERE c.component_type = 'LINE'
+                """
+                )
                 line_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
+
                 for line_name in network.lines.index:
                     if line_name in line_carriers:
                         carrier_name = line_carriers[line_name]
-                        
+
                         # Check if this line is available in this year
                         is_available = True
-                        if 'build_year' in network.lines.columns:
-                            build_year = network.lines.loc[line_name, 'build_year']
+                        if "build_year" in network.lines.columns:
+                            build_year = network.lines.loc[line_name, "build_year"]
                             if pd.notna(build_year) and int(build_year) > year:
                                 is_available = False
-                        
+
                         if is_available:
                             # Apparent power capacity (MVA -> MW, assume power factor = 1)
-                            if 's_nom_opt' in network.lines.columns:
-                                capacity_mva = float(network.lines.loc[line_name, 's_nom_opt'])
+                            if "s_nom_opt" in network.lines.columns:
+                                capacity_mva = float(
+                                    network.lines.loc[line_name, "s_nom_opt"]
+                                )
                             else:
-                                capacity_mva = float(network.lines.loc[line_name, 's_nom']) if 's_nom' in network.lines.columns else 0.0
-                            
+                                capacity_mva = (
+                                    float(network.lines.loc[line_name, "s_nom"])
+                                    if "s_nom" in network.lines.columns
+                                    else 0.0
+                                )
+
                             capacity_mw = capacity_mva  # Convert MVA to MW
-                            
-                            if carrier_name in carrier_stats["power_capacity_by_carrier"]:
-                                carrier_stats["power_capacity_by_carrier"][carrier_name] += capacity_mw
-            
+
+                            if (
+                                carrier_name
+                                in carrier_stats["power_capacity_by_carrier"]
+                            ):
+                                carrier_stats["power_capacity_by_carrier"][
+                                    carrier_name
+                                ] += capacity_mw
+
             # 5. LINKS - Power capacity (MW)
-            if hasattr(network, 'links') and not network.links.empty:
+            if hasattr(network, "links") and not network.links.empty:
                 # Get link-carrier mapping
-                cursor = conn.execute("""
+                cursor = conn.execute(
+                    """
                     SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
                     JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.network_id = ? AND c.component_type = 'LINK'
-                """, (network_id,))
+                    WHERE c.component_type = 'LINK'
+                """
+                )
                 link_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
+
                 for link_name in network.links.index:
                     if link_name in link_carriers:
                         carrier_name = link_carriers[link_name]
-                        
+
                         # Check if this link is available in this year
                         is_available = True
-                        if 'build_year' in network.links.columns:
-                            build_year = network.links.loc[link_name, 'build_year']
+                        if "build_year" in network.links.columns:
+                            build_year = network.links.loc[link_name, "build_year"]
                             if pd.notna(build_year) and int(build_year) > year:
                                 is_available = False
-                        
+
                         if is_available:
                             # Power capacity (MW)
-                            if 'p_nom_opt' in network.links.columns:
-                                capacity_mw = float(network.links.loc[link_name, 'p_nom_opt'])
+                            if "p_nom_opt" in network.links.columns:
+                                capacity_mw = float(
+                                    network.links.loc[link_name, "p_nom_opt"]
+                                )
                             else:
-                                capacity_mw = float(network.links.loc[link_name, 'p_nom']) if 'p_nom' in network.links.columns else 0.0
-                            
-                            if carrier_name in carrier_stats["power_capacity_by_carrier"]:
-                                carrier_stats["power_capacity_by_carrier"][carrier_name] += capacity_mw
-            
+                                capacity_mw = (
+                                    float(network.links.loc[link_name, "p_nom"])
+                                    if "p_nom" in network.links.columns
+                                    else 0.0
+                                )
+
+                            if (
+                                carrier_name
+                                in carrier_stats["power_capacity_by_carrier"]
+                            ):
+                                carrier_stats["power_capacity_by_carrier"][
+                                    carrier_name
+                                ] += capacity_mw
+
             logger.info(f"Calculated year {year} carrier statistics:")
-            logger.info(f"  Dispatch: {sum(carrier_stats['dispatch_by_carrier'].values()):.2f} MWh")
-            logger.info(f"  Emissions: {sum(carrier_stats['emissions_by_carrier'].values()):.2f} tonnes CO2")
-            logger.info(f"  Capital cost: {sum(carrier_stats['capital_cost_by_carrier'].values()):.2f} USD")
-            logger.info(f"  Operational cost: {sum(carrier_stats['operational_cost_by_carrier'].values()):.2f} USD")
-            logger.info(f"  Total system cost: {sum(carrier_stats['total_system_cost_by_carrier'].values()):.2f} USD")
-            logger.info(f"  Power capacity: {sum(carrier_stats['power_capacity_by_carrier'].values()):.2f} MW")
-            logger.info(f"  Energy capacity: {sum(carrier_stats['energy_capacity_by_carrier'].values()):.2f} MWh")
+            logger.info(
+                f"  Dispatch: {sum(carrier_stats['dispatch_by_carrier'].values()):.2f} MWh"
+            )
+            logger.info(
+                f"  Emissions: {sum(carrier_stats['emissions_by_carrier'].values()):.2f} tonnes CO2"
+            )
+            logger.info(
+                f"  Capital cost: {sum(carrier_stats['capital_cost_by_carrier'].values()):.2f} USD"
+            )
+            logger.info(
+                f"  Operational cost: {sum(carrier_stats['operational_cost_by_carrier'].values()):.2f} USD"
+            )
+            logger.info(
+                f"  Total system cost: {sum(carrier_stats['total_system_cost_by_carrier'].values()):.2f} USD"
+            )
+            logger.info(
+                f"  Power capacity: {sum(carrier_stats['power_capacity_by_carrier'].values()):.2f} MW"
+            )
+            logger.info(
+                f"  Energy capacity: {sum(carrier_stats['energy_capacity_by_carrier'].values()):.2f} MWh"
+            )
             
+            # Detailed logging for year-specific statistics
+            logger.info(f"  📊 Year {year} detailed carrier stats (RAW VALUES):")
+            for carrier in sorted(all_carriers_with_unmet):
+                dispatch = carrier_stats['dispatch_by_carrier'].get(carrier, 0.0)
+                emissions = carrier_stats['emissions_by_carrier'].get(carrier, 0.0)
+                capital_cost = carrier_stats['capital_cost_by_carrier'].get(carrier, 0.0)
+                operational_cost = carrier_stats['operational_cost_by_carrier'].get(carrier, 0.0)
+                total_cost = carrier_stats['total_system_cost_by_carrier'].get(carrier, 0.0)
+                
+                if dispatch > 0.001 or emissions > 0.001 or capital_cost > 0.001 or operational_cost > 0.001:
+                    logger.info(f"    {carrier}: dispatch={dispatch:.2f} MWh, emissions={emissions:.2f} tCO2, "
+                              f"capital={capital_cost:.2f} USD, operational={operational_cost:.2f} USD, "
+                              f"total={total_cost:.2f} USD")
+
             return carrier_stats
-            
+
         except Exception as e:
-            logger.error(f"Failed to calculate year {year} carrier statistics: {e}", exc_info=True)
+            logger.error(
+                f"Failed to calculate year {year} carrier statistics: {e}",
+                exc_info=True,
+            )
             return {
                 "dispatch_by_carrier": {},
                 "power_capacity_by_carrier": {},
@@ -1289,17 +1950,17 @@ class ResultStorage:
                 "emissions_by_carrier": {},
                 "capital_cost_by_carrier": {},
                 "operational_cost_by_carrier": {},
-                "total_system_cost_by_carrier": {}
+                "total_system_cost_by_carrier": {},
             }
-    
-    def _sum_year_based_carrier_statistics(self, conn, network_id: int) -> Dict[str, Any]:
+
+    def _sum_year_based_carrier_statistics(self, conn) -> Dict[str, Any]:
         """
-        Sum up per-year carrier statistics for accurate multi-year totals.
+        Sum up per-year carrier statistics for accurate multi-year totals (single network per database).
         For capacity: take the LAST YEAR (final capacity) instead of maximum.
         """
         try:
             import json
-            
+
             # Initialize totals
             totals = {
                 "dispatch_by_carrier": {},
@@ -1308,17 +1969,19 @@ class ResultStorage:
                 "emissions_by_carrier": {},
                 "capital_cost_by_carrier": {},
                 "operational_cost_by_carrier": {},
-                "total_system_cost_by_carrier": {}
+                "total_system_cost_by_carrier": {},
             }
-            
+
             # Get all carriers from database
-            cursor = conn.execute("""
-                SELECT DISTINCT name FROM carriers WHERE network_id = ?
-            """, (network_id,))
+            cursor = conn.execute(
+                """
+                SELECT DISTINCT name FROM carriers
+            """
+            )
             all_carriers = [row[0] for row in cursor.fetchall()]
-            
+
             # Initialize all carriers with zero values (including special "Unmet Load" carrier)
-            all_carriers_with_unmet = all_carriers + ['Unmet Load']
+            all_carriers_with_unmet = all_carriers + ["Unmet Load"]
             for carrier in all_carriers_with_unmet:
                 totals["dispatch_by_carrier"][carrier] = 0.0
                 totals["power_capacity_by_carrier"][carrier] = 0.0
@@ -1327,99 +1990,136 @@ class ResultStorage:
                 totals["capital_cost_by_carrier"][carrier] = 0.0
                 totals["operational_cost_by_carrier"][carrier] = 0.0
                 totals["total_system_cost_by_carrier"][carrier] = 0.0
-            
+
             # Get all year-based results, ordered by year
-            cursor = conn.execute("""
+            cursor = conn.execute(
+                """
                 SELECT year, results_json FROM network_solve_results_by_year 
-                WHERE network_id = ?
                 ORDER BY year
-            """, (network_id,))
-            
+            """
+            )
+
             year_results = cursor.fetchall()
-            logger.info(f"Found {len(year_results)} year-based results to sum for network {network_id}")
-            
+            logger.info(f"Found {len(year_results)} year-based results to sum")
+
             if not year_results:
-                logger.warning(f"No year-based results found for network {network_id}")
+                logger.warning(f"No year-based results found")
                 return totals
-            
+
             # For capacity: use the LAST YEAR only (final capacity state)
             last_year, last_results_json = year_results[-1]
-            
+
             try:
                 results = json.loads(last_results_json)
-                network_stats = results.get('network_statistics', {})
-                custom_stats = network_stats.get('custom_statistics', {})
-                
+                network_stats = results.get("network_statistics", {})
+                custom_stats = network_stats.get("custom_statistics", {})
+
                 # Use last year's capacity as the all-year capacity
-                power_capacity_by_carrier = custom_stats.get('power_capacity_by_carrier', {})
+                power_capacity_by_carrier = custom_stats.get(
+                    "power_capacity_by_carrier", {}
+                )
                 for carrier, value in power_capacity_by_carrier.items():
                     if carrier in totals["power_capacity_by_carrier"]:
                         totals["power_capacity_by_carrier"][carrier] = float(value or 0)
-                
-                energy_capacity_by_carrier = custom_stats.get('energy_capacity_by_carrier', {})
+
+                energy_capacity_by_carrier = custom_stats.get(
+                    "energy_capacity_by_carrier", {}
+                )
                 for carrier, value in energy_capacity_by_carrier.items():
                     if carrier in totals["energy_capacity_by_carrier"]:
-                        totals["energy_capacity_by_carrier"][carrier] = float(value or 0)
-                
-                logger.info(f"Used last year ({last_year}) capacity as all-year capacity")
-                
+                        totals["energy_capacity_by_carrier"][carrier] = float(
+                            value or 0
+                        )
+
+                logger.info(
+                    f"Used last year ({last_year}) capacity as all-year capacity"
+                )
+
             except Exception as e:
                 logger.error(f"Failed to process last year ({last_year}) results: {e}")
-            
+
             # For other stats (dispatch, emissions, costs): sum across all years
             for year, results_json in year_results:
                 try:
                     results = json.loads(results_json)
-                    network_stats = results.get('network_statistics', {})
-                    custom_stats = network_stats.get('custom_statistics', {})
-                    
+                    network_stats = results.get("network_statistics", {})
+                    custom_stats = network_stats.get("custom_statistics", {})
+
                     # Sum dispatch (energy values - sum across years)
-                    dispatch_by_carrier = custom_stats.get('dispatch_by_carrier', {})
+                    dispatch_by_carrier = custom_stats.get("dispatch_by_carrier", {})
                     for carrier, value in dispatch_by_carrier.items():
                         if carrier in totals["dispatch_by_carrier"]:
                             totals["dispatch_by_carrier"][carrier] += float(value or 0)
-                    
+
                     # Sum emissions (cumulative across years)
-                    emissions_by_carrier = custom_stats.get('emissions_by_carrier', {})
+                    emissions_by_carrier = custom_stats.get("emissions_by_carrier", {})
                     for carrier, value in emissions_by_carrier.items():
                         if carrier in totals["emissions_by_carrier"]:
                             totals["emissions_by_carrier"][carrier] += float(value or 0)
-                    
+
                     # Sum capital costs (cumulative across years)
-                    capital_cost_by_carrier = custom_stats.get('capital_cost_by_carrier', {})
+                    capital_cost_by_carrier = custom_stats.get(
+                        "capital_cost_by_carrier", {}
+                    )
                     for carrier, value in capital_cost_by_carrier.items():
                         if carrier in totals["capital_cost_by_carrier"]:
-                            totals["capital_cost_by_carrier"][carrier] += float(value or 0)
-                    
+                            totals["capital_cost_by_carrier"][carrier] += float(
+                                value or 0
+                            )
+
                     # Sum operational costs (cumulative across years)
-                    operational_cost_by_carrier = custom_stats.get('operational_cost_by_carrier', {})
+                    operational_cost_by_carrier = custom_stats.get(
+                        "operational_cost_by_carrier", {}
+                    )
                     for carrier, value in operational_cost_by_carrier.items():
                         if carrier in totals["operational_cost_by_carrier"]:
-                            totals["operational_cost_by_carrier"][carrier] += float(value or 0)
-                    
+                            totals["operational_cost_by_carrier"][carrier] += float(
+                                value or 0
+                            )
+
                     # Sum total system costs (cumulative across years)
-                    total_system_cost_by_carrier = custom_stats.get('total_system_cost_by_carrier', {})
+                    total_system_cost_by_carrier = custom_stats.get(
+                        "total_system_cost_by_carrier", {}
+                    )
                     for carrier, value in total_system_cost_by_carrier.items():
                         if carrier in totals["total_system_cost_by_carrier"]:
-                            totals["total_system_cost_by_carrier"][carrier] += float(value or 0)
-                    
+                            totals["total_system_cost_by_carrier"][carrier] += float(
+                                value or 0
+                            )
+
                 except Exception as e:
                     logger.error(f"Failed to process year {year} results: {e}")
                     continue
-            
+
             logger.info(f"Summed carrier statistics across {len(year_results)} years:")
-            logger.info(f"  Final power capacity: {sum(totals['power_capacity_by_carrier'].values()):.2f} MW")
-            logger.info(f"  Final energy capacity: {sum(totals['energy_capacity_by_carrier'].values()):.2f} MWh")
-            logger.info(f"  Total dispatch: {sum(totals['dispatch_by_carrier'].values()):.2f} MWh")
-            logger.info(f"  Total emissions: {sum(totals['emissions_by_carrier'].values()):.2f} tonnes CO2")
-            logger.info(f"  Total capital cost: {sum(totals['capital_cost_by_carrier'].values()):.2f} USD")
-            logger.info(f"  Total operational cost: {sum(totals['operational_cost_by_carrier'].values()):.2f} USD")
-            logger.info(f"  Total system cost: {sum(totals['total_system_cost_by_carrier'].values()):.2f} USD")
-            
+            logger.info(
+                f"  Final power capacity: {sum(totals['power_capacity_by_carrier'].values()):.2f} MW"
+            )
+            logger.info(
+                f"  Final energy capacity: {sum(totals['energy_capacity_by_carrier'].values()):.2f} MWh"
+            )
+            logger.info(
+                f"  Total dispatch: {sum(totals['dispatch_by_carrier'].values()):.2f} MWh"
+            )
+            logger.info(
+                f"  Total emissions: {sum(totals['emissions_by_carrier'].values()):.2f} tonnes CO2"
+            )
+            logger.info(
+                f"  Total capital cost: {sum(totals['capital_cost_by_carrier'].values()):.2f} USD"
+            )
+            logger.info(
+                f"  Total operational cost: {sum(totals['operational_cost_by_carrier'].values()):.2f} USD"
+            )
+            logger.info(
+                f"  Total system cost: {sum(totals['total_system_cost_by_carrier'].values()):.2f} USD"
+            )
+
             return totals
-            
+
         except Exception as e:
-            logger.error(f"Failed to sum year-based carrier statistics: {e}", exc_info=True)
+            logger.error(
+                f"Failed to sum year-based carrier statistics: {e}", exc_info=True
+            )
             # Return empty structure on error
             return {
                 "dispatch_by_carrier": {},
@@ -1428,12 +2128,13 @@ class ResultStorage:
                 "emissions_by_carrier": {},
                 "capital_cost_by_carrier": {},
                 "operational_cost_by_carrier": {},
-                "total_system_cost_by_carrier": {}
+                "total_system_cost_by_carrier": {},
             }
-    
+
     def _serialize_results_json(self, solve_result: Dict[str, Any]) -> str:
         """Serialize solve results to JSON string."""
         import json
+
         try:
             # Create a clean results dictionary
             results = {
@@ -1444,16 +2145,17 @@ class ResultStorage:
                 "solver_name": solve_result.get("solver_name", "unknown"),
                 "run_id": solve_result.get("run_id"),
                 "network_statistics": solve_result.get("network_statistics", {}),
-                "pypsa_result": solve_result.get("pypsa_result", {})
+                "pypsa_result": solve_result.get("pypsa_result", {}),
             }
             return json.dumps(results, default=self._json_serializer)
         except Exception as e:
             logger.warning(f"Failed to serialize results JSON: {e}")
             return json.dumps({"error": "serialization_failed"})
-    
+
     def _serialize_metadata_json(self, solve_result: Dict[str, Any]) -> str:
         """Serialize solve metadata to JSON string."""
         import json
+
         try:
             metadata = {
                 "solver_name": solve_result.get("solver_name", "unknown"),
@@ -1461,103 +2163,107 @@ class ResultStorage:
                 "multi_period": solve_result.get("multi_period", False),
                 "years": solve_result.get("years", []),
                 "network_name": solve_result.get("network_name"),
-                "num_snapshots": solve_result.get("num_snapshots", 0)
+                "num_snapshots": solve_result.get("num_snapshots", 0),
             }
             return json.dumps(metadata, default=self._json_serializer)
         except Exception as e:
             logger.warning(f"Failed to serialize metadata JSON: {e}")
             return json.dumps({"error": "serialization_failed"})
-    
-    def _filter_timeseries_by_year(self, timeseries_df: 'pd.DataFrame', snapshots: 'pd.Index', year: int) -> 'pd.DataFrame':
+
+    def _filter_timeseries_by_year(
+        self, timeseries_df: "pd.DataFrame", snapshots: "pd.Index", year: int
+    ) -> "pd.DataFrame":
         """Filter timeseries data by year"""
         try:
             # Handle MultiIndex case (multi-period optimization)
-            if hasattr(snapshots, 'levels'):
+            if hasattr(snapshots, "levels"):
                 period_values = snapshots.get_level_values(0)
                 year_mask = period_values == year
                 if year_mask.any():
                     year_snapshots = snapshots[year_mask]
                     return timeseries_df.loc[year_snapshots]
-            
+
             # Handle DatetimeIndex case (regular time series)
-            elif hasattr(snapshots, 'year'):
+            elif hasattr(snapshots, "year"):
                 year_mask = snapshots.year == year
                 if year_mask.any():
                     return timeseries_df.loc[year_mask]
-            
+
             # Fallback - return None if can't filter
             return None
-            
+
         except Exception as e:
             logger.error(f"Failed to filter timeseries by year {year}: {e}")
             return None
-    
-    def _get_year_weightings(self, network: 'pypsa.Network', year: int) -> 'np.ndarray':
+
+    def _get_year_weightings(self, network: "pypsa.Network", year: int) -> "np.ndarray":
         """Get snapshot weightings for a specific year"""
         try:
             # Filter snapshot weightings by year
-            if hasattr(network.snapshots, 'levels'):
+            if hasattr(network.snapshots, "levels"):
                 period_values = network.snapshots.get_level_values(0)
                 year_mask = period_values == year
                 if year_mask.any():
                     year_snapshots = network.snapshots[year_mask]
                     year_weightings = network.snapshot_weightings.loc[year_snapshots]
                     if isinstance(year_weightings, pd.DataFrame):
-                        if 'objective' in year_weightings.columns:
-                            return year_weightings['objective'].values
+                        if "objective" in year_weightings.columns:
+                            return year_weightings["objective"].values
                         else:
                             return year_weightings.iloc[:, 0].values
                     else:
                         return year_weightings.values
-            
-            elif hasattr(network.snapshots, 'year'):
+
+            elif hasattr(network.snapshots, "year"):
                 year_mask = network.snapshots.year == year
                 if year_mask.any():
                     year_weightings = network.snapshot_weightings.loc[year_mask]
                     if isinstance(year_weightings, pd.DataFrame):
-                        if 'objective' in year_weightings.columns:
-                            return year_weightings['objective'].values
+                        if "objective" in year_weightings.columns:
+                            return year_weightings["objective"].values
                         else:
                             return year_weightings.iloc[:, 0].values
                     else:
                         return year_weightings.values
-            
+
             return None
-            
+
         except Exception as e:
             logger.error(f"Failed to get year weightings for year {year}: {e}")
             return None
-    
-    def _calculate_total_demand(self, network: 'pypsa.Network') -> float:
+
+    def _calculate_total_demand(self, network: "pypsa.Network") -> float:
         """Calculate total demand from loads in the network"""
         try:
             total_demand = 0.0
-            
+
             # Calculate demand from loads
-            if hasattr(network, 'loads_t') and hasattr(network.loads_t, 'p'):
+            if hasattr(network, "loads_t") and hasattr(network.loads_t, "p"):
                 # Apply snapshot weightings to convert MW to MWh
                 weightings = network.snapshot_weightings
                 if isinstance(weightings, pd.DataFrame):
-                    if 'objective' in weightings.columns:
-                        weighting_values = weightings['objective'].values
+                    if "objective" in weightings.columns:
+                        weighting_values = weightings["objective"].values
                     else:
                         weighting_values = weightings.iloc[:, 0].values
                 else:
                     weighting_values = weightings.values
-                
-                total_demand = float((network.loads_t.p.values * weighting_values[:, None]).sum())
-            
+
+                total_demand = float(
+                    (network.loads_t.p.values * weighting_values[:, None]).sum()
+                )
+
             return total_demand
-            
+
         except Exception as e:
             logger.error(f"Failed to calculate total demand: {e}")
             return 0.0
-    
+
     def _json_serializer(self, obj):
         """Convert numpy/pandas types to JSON serializable types"""
         import numpy as np
         import pandas as pd
-        
+
         if isinstance(obj, (np.integer, np.int64, np.int32)):
             return int(obj)
         elif isinstance(obj, (np.floating, np.float64, np.float32)):
@@ -1568,7 +2274,7 @@ class ResultStorage:
             return obj.to_dict()
         elif isinstance(obj, pd.DataFrame):
             return obj.to_dict()
-        elif hasattr(obj, 'item'):  # Handle numpy scalars
+        elif hasattr(obj, "item"):  # Handle numpy scalars
             return obj.item()
         else:
-            raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
+            raise TypeError(f"Object of type {type(obj)} is not JSON serializable")