pyconvexity 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

pyconvexity/solvers/pypsa/storage.py

@@ -10,7 +10,7 @@ import pandas as pd
 import numpy as np
 from typing import Dict, Any, Optional, Callable
 
-from pyconvexity.core.types import StaticValue, TimeseriesPoint
+from pyconvexity.core.types import StaticValue
 from pyconvexity.models import (
     list_components_by_type, set_static_attribute, set_timeseries_attribute
 )
@@ -210,25 +210,20 @@ class ResultStorage:
                     if component_series.isna().all():
                         continue
                     
-                    # Convert to TimeseriesPoint list
-                    timeseries_points = []
-                    for period_index, (timestamp_idx, value) in enumerate(component_series.items()):
+                    # Convert to efficient values array
+                    values = []
+                    for value in component_series.values:
                         if pd.isna(value):
-                            continue
-                        
-                        timestamp = int(timestamp_idx.timestamp()) if hasattr(timestamp_idx, 'timestamp') else period_index
-                        timeseries_points.append(TimeseriesPoint(
-                            timestamp=timestamp,
-                            value=float(value),
-                            period_index=period_index
-                        ))
+                            values.append(0.0)  # Fill NaN with 0.0
+                        else:
+                            values.append(float(value))
                     
-                    if not timeseries_points:
+                    if not values:
                         continue
                     
-                    # Store using atomic utility
+                    # Store using efficient format
                     try:
-                        set_timeseries_attribute(conn, component_id, attr_name, timeseries_points, scenario_id)
+                        set_timeseries_attribute(conn, component_id, attr_name, values, scenario_id)
                         stored_count += 1
                     except Exception as e:
                         # Handle validation errors gracefully
@@ -350,262 +345,43 @@ class ResultStorage:
         network: 'pypsa.Network',
         solve_result: Dict[str, Any]
     ) -> Dict[str, Any]:
-        """Calculate network statistics in the format expected by the frontend."""
+        """Calculate network statistics - focusing only on capacity for now."""
         try:
-            # Calculate basic statistics
-            total_generation_mwh = 0.0
-            total_load_mwh = 0.0
-            unmet_load_mwh = 0.0
-            
-            # Calculate generation statistics (simple sum of all positive generator output)
-            if hasattr(network, 'generators_t') and hasattr(network.generators_t, 'p'):
-                gen_data = network.generators_t.p
-                if not gen_data.empty:
-                    # Debug: Log what's in the generators DataFrame
-                    logger.info(f"Generators DataFrame columns: {list(gen_data.columns)}")
-                    logger.info(f"Generators DataFrame shape: {gen_data.shape}")
-                    
-                    # Total generation - only count positive generation (ignore negative values like storage charging)
-                    # CRITICAL: 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
-                        else:
-                            weighting_values = weightings.iloc[:, 0].values
-                    else:
-                        weighting_values = weightings.values
-                    
-                    # Apply weightings and clip to positive values
-                    total_generation_mwh = float((gen_data.clip(lower=0).values * weighting_values[:, None]).sum())
-                    
-                    # Debug logging
-                    raw_sum = gen_data.sum().sum()
-                    clipped_sum = gen_data.clip(lower=0).sum().sum()
-                    
-                    logger.info(f"Generation calculation: raw_sum={raw_sum}, clipped_sum={clipped_sum}")
-                    
-                    # Check for negative generator values
-                    negative_gen_columns = []
-                    for col in gen_data.columns:
-                        if (gen_data[col] < 0).any():
-                            negative_gen_columns.append(col)
-                            min_val = gen_data[col].min()
-                            logger.warning(f"Generator column '{col}' has negative values (min: {min_val})")
-                    
-                    if negative_gen_columns:
-                        logger.info(f"Found {len(negative_gen_columns)} generator columns with negative values: {negative_gen_columns}")
-                    
-                    # Calculate unmet load if component type mapping available
-                    if hasattr(network, '_component_type_map'):
-                        unmet_load_total = 0.0
-                        for gen_name, gen_type in network._component_type_map.items():
-                            if gen_type == 'UNMET_LOAD' and gen_name in gen_data.columns:
-                                # Unmet load should be positive (it's generation to meet unserved demand)
-                                unmet_load_total += max(0, gen_data[gen_name].sum())
-                        unmet_load_mwh = float(unmet_load_total)
-            
-            # Calculate load statistics
-            if hasattr(network, 'loads_t') and hasattr(network.loads_t, 'p'):
-                load_data = network.loads_t.p
-                if not load_data.empty:
-                    # Debug: Log what's in the loads DataFrame
-                    logger.info(f"Loads DataFrame columns: {list(load_data.columns)}")
-                    logger.info(f"Loads DataFrame shape: {load_data.shape}")
-                    logger.info(f"Sample loads data (first 5 columns): {load_data.iloc[:3, :5].to_dict()}")
-                    
-                    # CRITICAL: 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
-                        else:
-                            weighting_values = weightings.iloc[:, 0].values
-                    else:
-                        weighting_values = weightings.values
-                    
-                    total_load_mwh = float(abs((load_data.values * weighting_values[:, None]).sum()))
-                    logger.info(f"Total load calculation with weightings: {total_load_mwh} MWh")
-                    logger.info(f"Total load calculation without weightings: {abs(load_data.sum().sum())} MW")
-                    
-                    # Check if any columns have negative values (which shouldn't be in loads)
-                    negative_columns = []
-                    for col in load_data.columns:
-                        if (load_data[col] < 0).any():
-                            negative_columns.append(col)
-                            min_val = load_data[col].min()
-                            logger.warning(f"Load column '{col}' has negative values (min: {min_val})")
-                    
-                    if negative_columns:
-                        logger.error(f"Found {len(negative_columns)} load columns with negative values: {negative_columns}")
-                else:
-                    total_load_mwh = 0.0
-            
-            # Calculate transmission losses from links (CORRECTED)
-            total_link_losses_mwh = 0.0
-            total_link_flow_mwh = 0.0
-            if hasattr(network, 'links_t') and hasattr(network.links_t, 'p0'):
-                link_p0_data = network.links_t.p0  # Power at bus0
-                link_p1_data = network.links_t.p1  # Power at bus1
-                
-                if not link_p0_data.empty and not link_p1_data.empty:
-                    logger.info(f"Links p0 DataFrame columns: {list(link_p0_data.columns)}")
-                    logger.info(f"Links p0 DataFrame shape: {link_p0_data.shape}")
-                    logger.info(f"Links p1 DataFrame columns: {list(link_p1_data.columns)}")
-                    logger.info(f"Links p1 DataFrame shape: {link_p1_data.shape}")
-                    
-                    # CORRECT calculation: For each link and timestep, calculate losses properly
-                    # Losses occur when power flows through a link with efficiency < 1.0
-                    # p1 = p0 * efficiency, so losses = p0 - p1 = p0 * (1 - efficiency)
-                    
-                    link_losses_by_link = {}
-                    total_losses = 0.0
-                    total_flow = 0.0
-                    
-                    for link_name in link_p0_data.columns:
-                        p0_series = link_p0_data[link_name]  # Power input to link
-                        p1_series = link_p1_data[link_name]  # Power output from link
-                        
-                        # Calculate losses for this link across all timesteps
-                        # Losses should always be positive regardless of flow direction
-                        # For each timestep: losses = abs(p0) * (1 - efficiency)
-                        # But we don't have efficiency here, so use: losses = abs(p0) - abs(p1)
-                        
-                        # Calculate losses properly for each timestep
-                        timestep_losses = abs(p0_series) - abs(p1_series)
-                        link_losses = timestep_losses.sum()
-                        link_flow = abs(p0_series).sum()  # Total absolute flow through this link
-                        
-                        link_losses_by_link[link_name] = {
-                            'losses_mwh': link_losses,
-                            'flow_mwh': link_flow,
-                            'loss_rate': (link_losses / link_flow * 100) if link_flow > 0 else 0
-                        }
-                        
-                        total_losses += link_losses
-                        total_flow += link_flow
-                        
-                        # Log details for first few links
-                        if len(link_losses_by_link) <= 5:
-                            avg_p0 = p0_series.mean()
-                            avg_p1 = p1_series.mean()
-                            logger.info(f"  Link '{link_name}': avg_p0={avg_p0:.1f}MW, avg_p1={avg_p1:.1f}MW, losses={link_losses:.1f}MWh, flow={link_flow:.1f}MWh")
-                    
-                    total_link_losses_mwh = total_losses
-                    total_link_flow_mwh = total_flow
-                    
-                    # Summary statistics
-                    logger.info(f"Link transmission analysis:")
-                    logger.info(f"  Total link flow: {total_link_flow_mwh:.1f} MWh")
-                    logger.info(f"  Total link losses: {total_link_losses_mwh:.1f} MWh")
-                    logger.info(f"  Average loss rate: {(total_link_losses_mwh/total_link_flow_mwh*100):.2f}%")
-                    logger.info(f"  Number of links: {len(link_losses_by_link)}")
-                    
-                    # Show top 5 links by losses
-                    top_loss_links = sorted(link_losses_by_link.items(), key=lambda x: x[1]['losses_mwh'], reverse=True)[:5]
-                    logger.info(f"  Top 5 links by losses:")
-                    for link_name, stats in top_loss_links:
-                        logger.info(f"    {link_name}: {stats['losses_mwh']:.1f} MWh ({stats['loss_rate']:.2f}%)")
-            
-            # Calculate storage losses if any
-            total_storage_losses_mwh = 0.0
-            storage_charging_mwh = 0.0
-            storage_discharging_mwh = 0.0
-            
-            # Check for storage units
-            if hasattr(network, 'storage_units_t') and hasattr(network.storage_units_t, 'p'):
-                storage_data = network.storage_units_t.p
-                if not storage_data.empty:
-                    logger.info(f"Storage units DataFrame columns: {list(storage_data.columns)}")
-                    logger.info(f"Storage units DataFrame shape: {storage_data.shape}")
-                    
-                    # Storage: positive = discharge (generation), negative = charge (consumption)
-                    total_storage_power = storage_data.sum().sum()
-                    storage_discharging_mwh = storage_data.clip(lower=0).sum().sum()  # Positive values
-                    storage_charging_mwh = abs(storage_data.clip(upper=0).sum().sum())  # Negative values made positive
-                    
-                    logger.info(f"Storage analysis:")
-                    logger.info(f"  Total storage net: {total_storage_power:.1f} MWh")
-                    logger.info(f"  Storage discharging: {storage_discharging_mwh:.1f} MWh")
-                    logger.info(f"  Storage charging: {storage_charging_mwh:.1f} MWh")
-                    
-                    # Storage losses = charging - discharging (due to round-trip efficiency)
-                    total_storage_losses_mwh = storage_charging_mwh - storage_discharging_mwh
-                    if total_storage_losses_mwh < 0:
-                        logger.warning(f"Negative storage losses: {total_storage_losses_mwh:.1f} MWh (net discharge)")
-                        total_storage_losses_mwh = 0.0  # Don't count net discharge as negative loss
-            
-            # Check for other PyPSA components that might consume energy
-            other_consumption_mwh = 0.0
-            
-            # Check stores
-            if hasattr(network, 'stores_t') and hasattr(network.stores_t, 'p'):
-                stores_data = network.stores_t.p
-                if not stores_data.empty:
-                    stores_consumption = abs(stores_data.sum().sum())
-                    other_consumption_mwh += stores_consumption
-                    logger.info(f"Stores consumption: {stores_consumption:.1f} MWh")
-            
-            # Total consumption (link losses already accounted for in PyPSA generation)
-            total_consumption_with_losses_mwh = (total_load_mwh + total_storage_losses_mwh + other_consumption_mwh)
-            
-            # Detailed energy balance analysis
-            logger.info(f"=== DETAILED ENERGY BALANCE ANALYSIS ===")
-            logger.info(f"GENERATION SIDE:")
-            logger.info(f"  Total generation: {total_generation_mwh:.1f} MWh")
-            logger.info(f"  Storage discharging: {storage_discharging_mwh:.1f} MWh")
-            logger.info(f"  Total supply: {total_generation_mwh + storage_discharging_mwh:.1f} MWh")
-            logger.info(f"")
-            logger.info(f"CONSUMPTION SIDE:")
-            logger.info(f"  Load demand: {total_load_mwh:.1f} MWh")
-            logger.info(f"  Storage charging: {storage_charging_mwh:.1f} MWh")
-            logger.info(f"  Link losses: {total_link_losses_mwh:.1f} MWh (for info only - already in generation)")
-            logger.info(f"  Storage losses: {total_storage_losses_mwh:.1f} MWh")
-            logger.info(f"  Other consumption: {other_consumption_mwh:.1f} MWh")
-            logger.info(f"  Total consumption: {total_load_mwh + storage_charging_mwh + total_storage_losses_mwh + other_consumption_mwh:.1f} MWh")
-            logger.info(f"")
-            logger.info(f"BALANCE CHECK:")
-            total_supply = total_generation_mwh + storage_discharging_mwh
-            total_consumption = total_load_mwh + storage_charging_mwh + total_storage_losses_mwh + other_consumption_mwh
-            balance_error = total_supply - total_consumption
-            logger.info(f"  Supply - Consumption = {balance_error:.1f} MWh")
-            logger.info(f"  Balance error %: {(balance_error/total_supply*100):.3f}%")
-            logger.info(f"=========================================")
-            
-            # Calculate carrier-specific statistics first
+            # Calculate carrier-specific statistics
             carrier_stats = self._calculate_carrier_statistics(conn, network_id, network)
             
-            # Calculate totals from carrier statistics
-            total_capital_cost = sum(carrier_stats["capital_cost_by_carrier"].values())
-            total_operational_cost = sum(carrier_stats["operational_cost_by_carrier"].values())
-            total_emissions = sum(carrier_stats["emissions_by_carrier"].values())
-            
-            # Calculate derived statistics
+            # Calculate basic network statistics
             total_cost = solve_result.get('objective_value', 0.0)
-            unmet_load_percentage = (unmet_load_mwh / total_load_mwh * 100) if total_load_mwh > 0 else 0.0
-            load_factor = (total_generation_mwh / total_load_mwh) if total_load_mwh > 0 else 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())
             
-            logger.info(f"Cost breakdown: Capital=${total_capital_cost:.0f}, Operational=${total_operational_cost:.0f}, Total Objective=${total_cost:.0f}")
+            # Calculate unmet load statistics
+            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
             
             # Create nested structure expected by frontend
             network_statistics = {
                 "core_summary": {
                     "total_generation_mwh": total_generation_mwh,
-                    "total_demand_mwh": total_load_mwh,  # Frontend expects "demand" not "load"
+                    "total_demand_mwh": total_demand_mwh,
                     "total_cost": total_cost,
-                    "load_factor": load_factor,
+                    "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
+                    # Include carrier-specific statistics (capacity, dispatch, emissions, costs)
                     **carrier_stats,
-                    "total_capital_cost": total_capital_cost,  # Sum from carriers
-                    "total_operational_cost": total_operational_cost,  # Sum from carriers  
-                    "total_currency_cost": total_cost,  # PyPSA objective (discounted total)
-                    "total_emissions_tons_co2": total_emissions,  # Sum from carriers
-                    "average_price_per_mwh": (total_cost / total_generation_mwh) if total_generation_mwh > 0 else 0.0,
+                    "total_capital_cost": total_capital_cost,
+                    "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,
                     "unmet_load_percentage": unmet_load_percentage,
-                    "max_unmet_load_hour_mw": 0.0  # TODO: Calculate max hourly unmet load
+                    "max_unmet_load_hour_mw": 0.0       # TODO: Calculate max hourly unmet load later
                 },
                 "runtime_info": {
                     "component_count": (
@@ -620,7 +396,6 @@ class ResultStorage:
             }
             
             logger.info(f"Calculated network statistics: core_summary={network_statistics['core_summary']}")
-            logger.info(f"Calculated custom statistics: custom_statistics={network_statistics['custom_statistics']}")
             return network_statistics
             
         except Exception as e:
@@ -635,6 +410,13 @@ class ResultStorage:
                     "unserved_energy_mwh": 0.0
                 },
                 "custom_statistics": {
+                    "dispatch_by_carrier": {},
+                    "power_capacity_by_carrier": {},
+                    "energy_capacity_by_carrier": {},
+                    "emissions_by_carrier": {},
+                    "capital_cost_by_carrier": {},
+                    "operational_cost_by_carrier": {},
+                    "total_system_cost_by_carrier": {},
                     "total_capital_cost": 0.0,
                     "total_operational_cost": 0.0,
                     "total_currency_cost": 0.0,
@@ -653,50 +435,188 @@ class ResultStorage:
                 "error": str(e)
             }
     
-    def _serialize_results_json(self, solve_result: Dict[str, Any]) -> str:
-        """Serialize solve results to JSON string."""
-        import json
+    def _calculate_carrier_statistics(self, conn, network_id: int, network: 'pypsa.Network') -> Dict[str, Any]:
+        """
+        Calculate carrier-specific statistics directly from the network.
+        This is the primary calculation - per-year stats will be calculated separately.
+        """
         try:
-            # Create a clean results dictionary
-            results = {
-                "success": solve_result.get("success", False),
-                "status": solve_result.get("status", "unknown"),
-                "solve_time": solve_result.get("solve_time", 0.0),
-                "objective_value": solve_result.get("objective_value"),
-                "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", {})
+            # Calculate all-year statistics directly from the network
+            # Extract years from network snapshots
+            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'):
+                years = sorted(network.snapshots.year.unique())
+            elif hasattr(network, '_available_years'):
+                years = network._available_years
+            else:
+                years = [2020]  # Fallback
+            
+            logger.info(f"Calculating all-year carrier statistics for years: {years}")
+            
+            # Calculate per-year statistics first
+            all_year_stats = {
+                "dispatch_by_carrier": {},
+                "power_capacity_by_carrier": {},
+                "energy_capacity_by_carrier": {},
+                "emissions_by_carrier": {},
+                "capital_cost_by_carrier": {},
+                "operational_cost_by_carrier": {},
+                "total_system_cost_by_carrier": {}
             }
-            return json.dumps(results, default=self._json_serializer)
+            
+            # Initialize all carriers with zero values
+            cursor = conn.execute("""
+                SELECT DISTINCT name FROM carriers WHERE network_id = ?
+            """, (network_id,))
+            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']
+            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
+                all_year_stats["energy_capacity_by_carrier"][carrier] = 0.0
+                all_year_stats["emissions_by_carrier"][carrier] = 0.0
+                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)
+                
+                # 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)
+                    
+                    # 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)
+            
+            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")
+            
+            return all_year_stats
+            
         except Exception as e:
-            logger.warning(f"Failed to serialize results JSON: {e}")
-            return json.dumps({"error": "serialization_failed"})
+            logger.error(f"Failed to calculate carrier statistics: {e}", exc_info=True)
+            return {
+                "dispatch_by_carrier": {},
+                "power_capacity_by_carrier": {},
+                "energy_capacity_by_carrier": {},
+                "emissions_by_carrier": {},
+                "capital_cost_by_carrier": {},
+                "operational_cost_by_carrier": {},
+                "total_system_cost_by_carrier": {}
+            }
     
-    def _serialize_metadata_json(self, solve_result: Dict[str, Any]) -> str:
-        """Serialize solve metadata to JSON string."""
-        import json
+    def _store_year_based_statistics(
+        self,
+        conn,
+        network_id: int,
+        network: 'pypsa.Network',
+        year_statistics: Dict[int, Dict[str, Any]],
+        scenario_id: Optional[int]
+    ) -> int:
+        """Store year-based statistics to database"""
         try:
-            metadata = {
-                "solver_name": solve_result.get("solver_name", "unknown"),
-                "run_id": solve_result.get("run_id"),
-                "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)
-            }
-            return json.dumps(metadata, default=self._json_serializer)
+            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("""
+                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,
+                    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)
+                )
+            """)
+            
+            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)
+                    
+                    # 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
+                    }
+                    
+                    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)
+                    ))
+                    
+                    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")
+            return stored_count
+            
         except Exception as e:
-            logger.warning(f"Failed to serialize metadata JSON: {e}")
-            return json.dumps({"error": "serialization_failed"})
+            logger.error(f"Failed to store year-based statistics: {e}", exc_info=True)
+            return 0
     
-    def _calculate_carrier_statistics(self, conn, network_id: int, network: 'pypsa.Network') -> Dict[str, Any]:
-        """Calculate carrier-specific statistics that the frontend expects."""
+    def _calculate_year_carrier_statistics(self, conn, network_id: int, network: 'pypsa.Network', year: int) -> Dict[str, Any]:
+        """
+        Calculate carrier-specific statistics for a specific year.
+        For now, only calculate capacity statistics.
+        """
         try:
-            # Initialize carrier statistics (separate power and energy capacity like old solver)
+            # Initialize carrier statistics
             carrier_stats = {
                 "dispatch_by_carrier": {},
-                "power_capacity_by_carrier": {},  # MW - Generators + Storage Units (power)
+                "power_capacity_by_carrier": {},  # MW - Generators + Storage Units (power) + Lines + Links
                 "energy_capacity_by_carrier": {},  # MWh - Stores + Storage Units (energy)
                 "emissions_by_carrier": {},
                 "capital_cost_by_carrier": {},
@@ -710,8 +630,9 @@ class ResultStorage:
             """, (network_id,))
             all_carriers = [row[0] for row in cursor.fetchall()]
             
-            # Initialize all carriers with zero values
-            for carrier in all_carriers:
+            # Initialize all carriers with zero values (including special "Unmet Load" carrier)
+            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
                 carrier_stats["energy_capacity_by_carrier"][carrier] = 0.0
@@ -720,37 +641,41 @@ class ResultStorage:
                 carrier_stats["operational_cost_by_carrier"][carrier] = 0.0
                 carrier_stats["total_system_cost_by_carrier"][carrier] = 0.0
             
-            # Calculate dispatch by carrier (generation + storage discharge)
+            # Calculate dispatch (generation) by carrier for this specific year
             
-            # 1. GENERATORS - All generation
+            # 1. GENERATORS - Generation dispatch (including UNMET_LOAD)
             if hasattr(network, 'generators_t') and hasattr(network.generators_t, 'p'):
-                # Get generator-carrier mapping
+                # Get generator-carrier mapping (include both GENERATOR and UNMET_LOAD)
                 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 = 'GENERATOR'
-                """, (network_id,))
-                
+                SELECT c.name as component_name, 
+                       CASE 
+                           WHEN c.component_type = 'UNMET_LOAD' THEN 'Unmet Load'
+                           ELSE carr.name 
+                       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,))
                 generator_carriers = {row[0]: row[1] for row in cursor.fetchall()}
                 
-                # Calculate dispatch for each generator
-                for gen_name in network.generators_t.p.columns:
-                    if gen_name in generator_carriers:
-                        carrier_name = generator_carriers[gen_name]
-                        # 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
+                # Filter generation data for this specific 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())
                             else:
-                                weighting_values = weightings.iloc[:, 0].values
-                        else:
-                            weighting_values = weightings.values
-                        
-                        generation_mwh = float((network.generators_t.p[gen_name].values * weighting_values).sum())
-                        if carrier_name in carrier_stats["dispatch_by_carrier"]:
-                            carrier_stats["dispatch_by_carrier"][carrier_name] += generation_mwh
+                                # 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")
+                            
+                            if carrier_name in carrier_stats["dispatch_by_carrier"]:
+                                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'):
@@ -761,29 +686,26 @@ class ResultStorage:
                     JOIN carriers carr ON c.carrier_id = carr.id
                     WHERE c.network_id = ? AND c.component_type = 'STORAGE_UNIT'
                 """, (network_id,))
-                
                 storage_unit_carriers = {row[0]: row[1] for row in cursor.fetchall()}
                 
-                # Calculate dispatch for each storage unit (discharge only)
-                for su_name in network.storage_units_t.p.columns:
-                    if su_name in storage_unit_carriers:
-                        carrier_name = storage_unit_carriers[su_name]
-                        # Apply snapshot weightings and only count positive discharge
-                        weightings = network.snapshot_weightings
-                        if isinstance(weightings, pd.DataFrame):
-                            if 'objective' in weightings.columns:
-                                weighting_values = weightings['objective'].values
+                # Filter storage unit data for this specific 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())
                             else:
-                                weighting_values = weightings.iloc[:, 0].values
-                        else:
-                            weighting_values = weightings.values
-                        
-                        # Only count positive values (discharge)
-                        su_power = network.storage_units_t.p[su_name]
-                        discharge_mwh = float((su_power.clip(lower=0) * weighting_values).sum())
-                        
-                        if carrier_name in carrier_stats["dispatch_by_carrier"]:
-                            carrier_stats["dispatch_by_carrier"][carrier_name] += discharge_mwh
+                                # 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")
+                            
+                            if carrier_name in carrier_stats["dispatch_by_carrier"]:
+                                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'):
@@ -794,719 +716,295 @@ class ResultStorage:
                     JOIN carriers carr ON c.carrier_id = carr.id
                     WHERE c.network_id = ? AND c.component_type = 'STORE'
                 """, (network_id,))
-                
                 store_carriers = {row[0]: row[1] for row in cursor.fetchall()}
                 
-                # Calculate dispatch for each store (discharge only)
-                for store_name in network.stores_t.p.columns:
-                    if store_name in store_carriers:
-                        carrier_name = store_carriers[store_name]
-                        # Apply snapshot weightings and only count positive discharge
-                        weightings = network.snapshot_weightings
-                        if isinstance(weightings, pd.DataFrame):
-                            if 'objective' in weightings.columns:
-                                weighting_values = weightings['objective'].values
+                # Filter store data for this specific 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())
                             else:
-                                weighting_values = weightings.iloc[:, 0].values
-                        else:
-                            weighting_values = weightings.values
-                        
-                        # Only count positive values (discharge)
-                        store_power = network.stores_t.p[store_name]
-                        discharge_mwh = float((store_power.clip(lower=0) * weighting_values).sum())
-                        
-                        if carrier_name in carrier_stats["dispatch_by_carrier"]:
-                            carrier_stats["dispatch_by_carrier"][carrier_name] += discharge_mwh
+                                # 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")
+                            
+                            if carrier_name in carrier_stats["dispatch_by_carrier"]:
+                                carrier_stats["dispatch_by_carrier"][carrier_name] += discharge_mwh
             
-            # Calculate capacity by carrier (power + energy capacity)
+            # 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,))
+            emission_factors = {row[0]: row[1] for row in cursor.fetchall()}
             
-            # 1. GENERATORS - Power capacity (MW)
-            if hasattr(network, 'generators') and not network.generators.empty:
-                # Get generator-carrier mapping
-                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 = 'GENERATOR'
-                """, (network_id,))
-                
-                generator_carriers = {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():
+                # Handle None values safely
+                if dispatch_mwh is None:
+                    dispatch_mwh = 0.0
                 
-                # Calculate capacity for each generator
-                for gen_name in network.generators.index:
-                    if gen_name in generator_carriers:
-                        carrier_name = generator_carriers[gen_name]
-                        # Use p_nom_opt if available, otherwise p_nom (POWER capacity)
-                        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
-            
-            # 2. STORAGE_UNITS - Power capacity (MW) + Energy capacity (MWh)
-            if hasattr(network, 'storage_units') and not network.storage_units.empty:
-                # Get storage unit-carrier mapping
-                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,))
+                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
                 
-                storage_unit_carriers = {row[0]: row[1] for row in cursor.fetchall()}
+                emissions_tonnes = dispatch_mwh * emission_factor
                 
-                # Calculate capacity for each storage unit
-                for su_name in network.storage_units.index:
-                    if su_name in storage_unit_carriers:
-                        carrier_name = storage_unit_carriers[su_name]
-                        
-                        # 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'])
-                        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
-                        
-                        # Energy capacity (MWh) using max_hours (matching old solver)
-                        max_hours = 1.0  # Default from validation data
-                        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["emissions_by_carrier"]:
+                    carrier_stats["emissions_by_carrier"][carrier_name] += emissions_tonnes
             
-            # 3. STORES - Energy capacity (MWh) only
-            if hasattr(network, 'stores') and not network.stores.empty:
-                # Get store-carrier mapping
-                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,))
-                
-                store_carriers = {row[0]: row[1] for row in cursor.fetchall()}
-                
-                # Calculate energy capacity for each store
-                for store_name in network.stores.index:
-                    if store_name in store_carriers:
-                        carrier_name = store_carriers[store_name]
-                        
-                        # Energy capacity (MWh) - stores don't have power capacity, only energy
-                        if 'e_nom_opt' in network.stores.columns:
-                            e_nom_opt = float(network.stores.loc[store_name, 'e_nom_opt'])
-                        else:
-                            e_nom_opt = float(network.stores.loc[store_name, 'e_nom']) if 'e_nom' in network.stores.columns else 0.0
-                        
-                        # Stores contribute only to energy capacity
-                        if carrier_name in carrier_stats["energy_capacity_by_carrier"]:
-                            carrier_stats["energy_capacity_by_carrier"][carrier_name] += e_nom_opt
+            # Calculate capital costs by carrier for this specific year
+            # Capital costs are annualized and counted every year the component is active
             
-            # 4. LINES - Apparent power capacity (MVA)
-            if hasattr(network, 'lines') and not network.lines.empty:
-                # Get line-carrier mapping
-                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,))
-                
-                line_carriers = {row[0]: row[1] for row in cursor.fetchall()}
+            # 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
                 
-                # Calculate capacity for each line
-                for line_name in network.lines.index:
-                    if line_name in line_carriers:
-                        carrier_name = line_carriers[line_name]
-                        
-                        # Apparent power capacity (MVA) - convert to MW equivalent for consistency
-                        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
-                        
-                        # Convert MVA to MW (assume power factor = 1 for simplicity)
-                        capacity_mw = capacity_mva
-                        
-                        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:
-                # Get link-carrier mapping
-                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,))
+                build_year = int(build_year)
+                if build_year > current_year:
+                    return False  # Not built yet
                 
-                link_carriers = {row[0]: row[1] for row in cursor.fetchall()}
+                if pd.isna(lifetime) or lifetime == float('inf'):
+                    return True  # Infinite lifetime
                 
-                # Calculate capacity for each link
-                for link_name in network.links.index:
-                    if link_name in link_carriers:
-                        carrier_name = link_carriers[link_name]
-                        
-                        # Power capacity (MW)
-                        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
-            
-            # Calculate emissions by carrier
-            cursor = conn.execute("""
-                SELECT name, co2_emissions
-                FROM carriers 
-                WHERE network_id = ? AND co2_emissions IS NOT NULL
-                ORDER BY name
-            """, (network_id,))
-            
-            emission_factors = {}
-            for row in cursor.fetchall():
-                carrier_name, co2_emissions = row
-                emission_factors[carrier_name] = co2_emissions
+                lifetime = int(lifetime)
+                end_year = build_year + lifetime - 1
+                return current_year <= end_year
             
-            # Calculate emissions = dispatch * emission_factor
-            for carrier, dispatch_mwh in carrier_stats["dispatch_by_carrier"].items():
-                emission_factor = emission_factors.get(carrier, 0.0)
-                emissions = dispatch_mwh * emission_factor
-                carrier_stats["emissions_by_carrier"][carrier] = emissions
-            
-            # Calculate cost statistics by carrier (all component types)
-            
-            # 1. GENERATORS - Operational and capital costs
+            # 1. GENERATORS - Capital costs (including UNMET_LOAD)
             if hasattr(network, 'generators') and not network.generators.empty:
-                # Get generator-carrier mapping
+                # Get generator info: carrier, capital_cost, build_year, lifetime (include UNMET_LOAD)
                 cursor = conn.execute("""
-                    SELECT c.name as component_name, carr.name as carrier_name
+                    SELECT c.name as component_name, 
+                           CASE 
+                               WHEN c.component_type = 'UNMET_LOAD' THEN 'Unmet Load'
+                               ELSE carr.name 
+                           END as carrier_name
                     FROM components c
                     JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.network_id = ? AND c.component_type = 'GENERATOR'
+                    WHERE c.network_id = ? AND c.component_type IN ('GENERATOR', 'UNMET_LOAD')
                 """, (network_id,))
-                
                 generator_carriers = {row[0]: row[1] for row in cursor.fetchall()}
                 
-                # Calculate operational costs based on dispatch and marginal costs
-                if hasattr(network, 'generators_t') and hasattr(network.generators_t, 'p'):
-                    for gen_name in network.generators.index:
-                        if gen_name in generator_carriers and gen_name in network.generators_t.p.columns:
-                            carrier_name = generator_carriers[gen_name]
-                            
-                            # Get marginal cost for this generator
-                            marginal_cost = 0.0
-                            if 'marginal_cost' in network.generators.columns:
-                                marginal_cost = float(network.generators.loc[gen_name, 'marginal_cost'])
-                            
-                            # Calculate operational cost = dispatch * marginal_cost (with weightings)
-                            weightings = network.snapshot_weightings
-                            if isinstance(weightings, pd.DataFrame):
-                                if 'objective' in weightings.columns:
-                                    weighting_values = weightings['objective'].values
-                                else:
-                                    weighting_values = weightings.iloc[:, 0].values
-                            else:
-                                weighting_values = weightings.values
-                            
-                            dispatch_mwh = float((network.generators_t.p[gen_name].values * weighting_values).sum())
-                            operational_cost = dispatch_mwh * marginal_cost
-                            
-                            if carrier_name in carrier_stats["operational_cost_by_carrier"]:
-                                carrier_stats["operational_cost_by_carrier"][carrier_name] += operational_cost
-                
-                # Calculate annual capital costs for all operational generators (matching old solver per-year logic)
-                for gen_name in network.generators.index:
-                    if gen_name in generator_carriers:
-                        carrier_name = generator_carriers[gen_name]
-                        
-                        # Get capital cost and capacity
-                        capital_cost_per_mw = 0.0
-                        if 'capital_cost' in network.generators.columns:
-                            capital_cost_per_mw = float(network.generators.loc[gen_name, 'capital_cost'])
-                        
-                        capacity_mw = 0.0
-                        if 'p_nom_opt' in network.generators.columns:
-                            capacity_mw = float(network.generators.loc[gen_name, 'p_nom_opt'])
-                        elif 'p_nom' in network.generators.columns:
-                            capacity_mw = float(network.generators.loc[gen_name, 'p_nom'])
-                        
-                        # Annual capital cost for operational assets (undiscounted)
-                        annual_capital_cost = capital_cost_per_mw * capacity_mw
-                        
-                        if carrier_name in carrier_stats["capital_cost_by_carrier"]:
-                            carrier_stats["capital_cost_by_carrier"][carrier_name] += annual_capital_cost
-                
-                # Calculate operational costs including fixed costs (matching old solver)
                 for gen_name in network.generators.index:
                     if gen_name in generator_carriers:
                         carrier_name = generator_carriers[gen_name]
                         
-                        # Fixed O&M costs (annual cost per MW of capacity)
-                        fixed_cost_per_mw = 0.0
-                        if 'fixed_cost' in network.generators.columns:
-                            fixed_cost_per_mw = float(network.generators.loc[gen_name, 'fixed_cost'])
-                        
-                        capacity_mw = 0.0
-                        if 'p_nom_opt' in network.generators.columns:
-                            capacity_mw = float(network.generators.loc[gen_name, 'p_nom_opt'])
-                        elif 'p_nom' in network.generators.columns:
-                            capacity_mw = float(network.generators.loc[gen_name, 'p_nom'])
+                        # 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
                         
-                        fixed_cost_total = fixed_cost_per_mw * capacity_mw
-                        
-                        if carrier_name in carrier_stats["operational_cost_by_carrier"]:
-                            carrier_stats["operational_cost_by_carrier"][carrier_name] += fixed_cost_total
+                        # 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'])
+                            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
+                            
+                            # 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
             
-            # 2. STORAGE_UNITS - Operational and capital costs
+            # 2. STORAGE_UNITS - Capital costs
             if hasattr(network, 'storage_units') and not network.storage_units.empty:
-                # Get storage unit-carrier mapping
                 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,))
-                
                 storage_unit_carriers = {row[0]: row[1] for row in cursor.fetchall()}
                 
-                # Calculate operational costs (marginal costs for storage units)
-                if hasattr(network, 'storage_units_t') and hasattr(network.storage_units_t, 'p'):
-                    for su_name in network.storage_units.index:
-                        if su_name in storage_unit_carriers and su_name in network.storage_units_t.p.columns:
-                            carrier_name = storage_unit_carriers[su_name]
-                            
-                            # Get marginal cost for this storage unit
-                            marginal_cost = 0.0
-                            if 'marginal_cost' in network.storage_units.columns:
-                                marginal_cost = float(network.storage_units.loc[su_name, 'marginal_cost'])
-                            
-                            # Calculate operational cost = dispatch * marginal_cost (discharge only)
-                            weightings = network.snapshot_weightings
-                            if isinstance(weightings, pd.DataFrame):
-                                if 'objective' in weightings.columns:
-                                    weighting_values = weightings['objective'].values
-                                else:
-                                    weighting_values = weightings.iloc[:, 0].values
-                            else:
-                                weighting_values = weightings.values
-                            
-                            su_power = network.storage_units_t.p[su_name]
-                            discharge_mwh = float((su_power.clip(lower=0) * weighting_values).sum())
-                            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
-                
-                # Calculate fixed O&M costs for storage units (matching old solver)
                 for su_name in network.storage_units.index:
                     if su_name in storage_unit_carriers:
                         carrier_name = storage_unit_carriers[su_name]
                         
-                        # Fixed O&M costs (annual cost per MW of capacity)
-                        fixed_cost_per_mw = 0.0
-                        if 'fixed_cost' in network.storage_units.columns:
-                            fixed_cost_per_mw = float(network.storage_units.loc[su_name, 'fixed_cost'])
+                        # 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
                         
-                        capacity_mw = 0.0
-                        if 'p_nom_opt' in network.storage_units.columns:
-                            capacity_mw = float(network.storage_units.loc[su_name, 'p_nom_opt'])
-                        elif 'p_nom' in network.storage_units.columns:
-                            capacity_mw = float(network.storage_units.loc[su_name, 'p_nom'])
-                        
-                        fixed_cost_total = fixed_cost_per_mw * capacity_mw
-                        
-                        if carrier_name in carrier_stats["operational_cost_by_carrier"]:
-                            carrier_stats["operational_cost_by_carrier"][carrier_name] += fixed_cost_total
-                
-                # Calculate annual capital costs for all operational storage units
-                for su_name in network.storage_units.index:
-                    if su_name in storage_unit_carriers:
-                        carrier_name = storage_unit_carriers[su_name]
-                        
-                        # Get capital cost for this storage unit
-                        capital_cost_per_mw = 0.0
-                        if 'capital_cost' in network.storage_units.columns:
-                            capital_cost_per_mw = float(network.storage_units.loc[su_name, 'capital_cost'])
-                        
-                        # Get capacity
-                        capacity_mw = 0.0
-                        if 'p_nom_opt' in network.storage_units.columns:
-                            capacity_mw = float(network.storage_units.loc[su_name, 'p_nom_opt'])
-                        elif 'p_nom' in network.storage_units.columns:
-                            capacity_mw = float(network.storage_units.loc[su_name, 'p_nom'])
-                        
-                        # Annual capital cost for operational assets (undiscounted)
-                        annual_capital_cost = capital_cost_per_mw * capacity_mw
-                        
-                        if carrier_name in carrier_stats["capital_cost_by_carrier"]:
-                            carrier_stats["capital_cost_by_carrier"][carrier_name] += annual_capital_cost
+                        # 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'])
+                            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
+                            
+                            # 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
             
-            # 3. STORES - Operational and capital costs
+            # 3. STORES - Capital costs (per MWh)
             if hasattr(network, 'stores') and not network.stores.empty:
-                # Get store-carrier mapping
                 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,))
-                
                 store_carriers = {row[0]: row[1] for row in cursor.fetchall()}
                 
-                # Calculate operational costs (marginal costs for stores)
-                if hasattr(network, 'stores_t') and hasattr(network.stores_t, 'p'):
-                    for store_name in network.stores.index:
-                        if store_name in store_carriers and store_name in network.stores_t.p.columns:
-                            carrier_name = store_carriers[store_name]
-                            
-                            # Get marginal cost for this store
-                            marginal_cost = 0.0
-                            if 'marginal_cost' in network.stores.columns:
-                                marginal_cost = float(network.stores.loc[store_name, 'marginal_cost'])
-                            
-                            # Calculate operational cost = dispatch * marginal_cost (discharge only)
-                            weightings = network.snapshot_weightings
-                            if isinstance(weightings, pd.DataFrame):
-                                if 'objective' in weightings.columns:
-                                    weighting_values = weightings['objective'].values
-                                else:
-                                    weighting_values = weightings.iloc[:, 0].values
-                            else:
-                                weighting_values = weightings.values
-                            
-                            store_power = network.stores_t.p[store_name]
-                            discharge_mwh = float((store_power.clip(lower=0) * weighting_values).sum())
-                            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
-                
-                # Calculate annual capital costs for all operational stores (based on energy capacity)
                 for store_name in network.stores.index:
                     if store_name in store_carriers:
                         carrier_name = store_carriers[store_name]
                         
-                        # Get capital cost for this store (per MWh)
-                        capital_cost_per_mwh = 0.0
-                        if 'capital_cost' in network.stores.columns:
-                            capital_cost_per_mwh = float(network.stores.loc[store_name, 'capital_cost'])
+                        # 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
                         
-                        # Get energy capacity
-                        energy_capacity_mwh = 0.0
-                        if 'e_nom_opt' in network.stores.columns:
-                            energy_capacity_mwh = float(network.stores.loc[store_name, 'e_nom_opt'])
-                        elif 'e_nom' in network.stores.columns:
-                            energy_capacity_mwh = float(network.stores.loc[store_name, 'e_nom'])
-                        
-                        # Annual capital cost for operational assets (undiscounted)
-                        annual_capital_cost = capital_cost_per_mwh * energy_capacity_mwh
-                        
-                        if carrier_name in carrier_stats["capital_cost_by_carrier"]:
-                            carrier_stats["capital_cost_by_carrier"][carrier_name] += annual_capital_cost
+                        # 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'])
+                            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
+                            
+                            # 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
             
-            # 4. LINES - Capital costs only (no operational costs for transmission lines)
+            # 4. LINES - Capital costs (per MVA)
             if hasattr(network, 'lines') and not network.lines.empty:
-                # Get line-carrier mapping
                 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,))
-                
                 line_carriers = {row[0]: row[1] for row in cursor.fetchall()}
                 
-                # Calculate capital costs for lines (based on s_nom_opt capacity)
                 for line_name in network.lines.index:
                     if line_name in line_carriers:
                         carrier_name = line_carriers[line_name]
                         
-                        # Get capital cost for this line (per MVA)
-                        capital_cost_per_mva = 0.0
-                        if 'capital_cost' in network.lines.columns:
-                            capital_cost_per_mva = float(network.lines.loc[line_name, 'capital_cost'])
-                        
-                        # Get apparent power capacity (MVA)
-                        capacity_mva = 0.0
-                        if 's_nom_opt' in network.lines.columns:
-                            capacity_mva = float(network.lines.loc[line_name, 's_nom_opt'])
-                        elif 's_nom' in network.lines.columns:
-                            capacity_mva = float(network.lines.loc[line_name, 's_nom'])
+                        # 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
                         
-                        # Annual capital cost for operational assets (undiscounted)
-                        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
+                        # 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'])
+                            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
+                            
+                            # 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
             
-            # 5. LINKS - Capital and operational costs
+            # 5. LINKS - Capital costs (per MW)
             if hasattr(network, 'links') and not network.links.empty:
-                # Get link-carrier mapping
                 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,))
-                
                 link_carriers = {row[0]: row[1] for row in cursor.fetchall()}
                 
-                # Calculate operational costs (marginal costs for links)
-                if hasattr(network, 'links_t') and hasattr(network.links_t, 'p0'):
-                    for link_name in network.links.index:
-                        if link_name in link_carriers and link_name in network.links_t.p0.columns:
-                            carrier_name = link_carriers[link_name]
-                            
-                            # Get marginal cost for this link
-                            marginal_cost = 0.0
-                            if 'marginal_cost' in network.links.columns:
-                                marginal_cost = float(network.links.loc[link_name, 'marginal_cost'])
-                            
-                            # Calculate operational cost = flow * marginal_cost (use absolute flow)
-                            weightings = network.snapshot_weightings
-                            if isinstance(weightings, pd.DataFrame):
-                                if 'objective' in weightings.columns:
-                                    weighting_values = weightings['objective'].values
-                                else:
-                                    weighting_values = weightings.iloc[:, 0].values
-                            else:
-                                weighting_values = weightings.values
-                            
-                            # Use absolute flow for cost calculation
-                            link_flow = abs(network.links_t.p0[link_name])
-                            flow_mwh = float((link_flow * weighting_values).sum())
-                            operational_cost = flow_mwh * marginal_cost
-                            
-                            if carrier_name in carrier_stats["operational_cost_by_carrier"]:
-                                carrier_stats["operational_cost_by_carrier"][carrier_name] += operational_cost
-                
-                # Calculate capital costs for links
                 for link_name in network.links.index:
                     if link_name in link_carriers:
                         carrier_name = link_carriers[link_name]
                         
-                        # Get capital cost for this link (per MW)
-                        capital_cost_per_mw = 0.0
-                        if 'capital_cost' in network.links.columns:
-                            capital_cost_per_mw = float(network.links.loc[link_name, 'capital_cost'])
-                        
-                        # Get power capacity (MW)
-                        capacity_mw = 0.0
-                        if 'p_nom_opt' in network.links.columns:
-                            capacity_mw = float(network.links.loc[link_name, 'p_nom_opt'])
-                        elif 'p_nom' in network.links.columns:
-                            capacity_mw = float(network.links.loc[link_name, 'p_nom'])
+                        # 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
                         
-                        # Annual capital cost for operational assets (undiscounted)
-                        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
-            
-            # Calculate total system cost = capital + operational
-            for carrier in all_carriers:
-                capital = carrier_stats["capital_cost_by_carrier"][carrier]
-                operational = carrier_stats["operational_cost_by_carrier"][carrier]
-                carrier_stats["total_system_cost_by_carrier"][carrier] = capital + operational
-            
-            logger.info(f"Calculated carrier statistics for {len(all_carriers)} carriers")
-            logger.info(f"Total dispatch: {sum(carrier_stats['dispatch_by_carrier'].values()):.2f} MWh")
-            logger.info(f"Total power capacity: {sum(carrier_stats['power_capacity_by_carrier'].values()):.2f} MW")
-            logger.info(f"Total energy capacity: {sum(carrier_stats['energy_capacity_by_carrier'].values()):.2f} MWh")
-            logger.info(f"Total emissions: {sum(carrier_stats['emissions_by_carrier'].values()):.2f} tCO2")
-            logger.info(f"Total capital cost: {sum(carrier_stats['capital_cost_by_carrier'].values()):.2f} USD")
-            logger.info(f"Total 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")
-            
-            return carrier_stats
-            
-        except Exception as e:
-            logger.error(f"Failed to calculate carrier statistics: {e}", exc_info=True)
-            return {
-                "dispatch_by_carrier": {},
-                "power_capacity_by_carrier": {},
-                "energy_capacity_by_carrier": {},
-                "emissions_by_carrier": {},
-                "capital_cost_by_carrier": {},
-                "operational_cost_by_carrier": {},
-                "total_system_cost_by_carrier": {}
-            }
-    
-    def _store_year_based_statistics(
-        self,
-        conn,
-        network_id: int,
-        network: 'pypsa.Network',
-        year_statistics: Dict[int, Dict[str, Any]],
-        scenario_id: Optional[int]
-    ) -> int:
-        """Store year-based statistics to 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("""
-                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,
-                    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)
-                )
-            """)
-            
-            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)
-                    
-                    # 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
-                    }
-                    
-                    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)
-                    ))
-                    
-                    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")
-            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]:
-        """
-        Calculate carrier-specific statistics for a specific year with proper database access.
-        
-        CRITICAL: This method now consistently applies snapshot weightings to ALL energy calculations
-        to convert MW to MWh, matching the old PyPSA solver behavior. This is essential for 
-        multi-hourly models (e.g., 3-hourly models where each timestep = 3 hours).
-        """
-        try:
-            # Initialize carrier statistics (separate power and energy capacity like old solver)
-            carrier_stats = {
-                "dispatch_by_carrier": {},
-                "power_capacity_by_carrier": {},  # MW - Generators + Storage Units (power)
-                "energy_capacity_by_carrier": {},  # MWh - Stores + Storage Units (energy)
-                "emissions_by_carrier": {},
-                "capital_cost_by_carrier": {},
-                "operational_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,))
-            all_carriers = [row[0] for row in cursor.fetchall()]
-            
-            # Initialize all carriers with zero values
-            for carrier in all_carriers:
-                carrier_stats["dispatch_by_carrier"][carrier] = 0.0
-                carrier_stats["power_capacity_by_carrier"][carrier] = 0.0
-                carrier_stats["energy_capacity_by_carrier"][carrier] = 0.0
-                carrier_stats["emissions_by_carrier"][carrier] = 0.0
-                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
-            
-            # Get generator-carrier mapping from database
-            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 = 'GENERATOR'
-            """, (network_id,))
-            generator_carriers = {row[0]: row[1] for row in cursor.fetchall()}
+                        # 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'])
+                            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
+                            
+                            # 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
             
-            # Calculate year-specific dispatch by carrier (all component types)
+            # 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 - Year-specific generation
+            # 1. GENERATORS - Operational costs (including UNMET_LOAD)
             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("""
+                    SELECT c.name as component_name, 
+                           CASE 
+                               WHEN c.component_type = 'UNMET_LOAD' THEN 'Unmet Load'
+                               ELSE carr.name 
+                           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,))
+                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)
                 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())
-                            else:
-                                # Fallback: use all-year weightings if year-specific not available
-                                weightings = network.snapshot_weightings
-                                if isinstance(weightings, pd.DataFrame):
-                                    if 'objective' in weightings.columns:
-                                        weighting_values = weightings['objective'].values
-                                    else:
-                                        weighting_values = weightings.iloc[:, 0].values
-                                else:
-                                    weighting_values = weightings.values
-                                # Apply weightings to the filtered year data
-                                if len(weighting_values) == len(year_generation):
-                                    generation_mwh = float((year_generation[gen_name].values * weighting_values).sum())
+                            
+                            # 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
+                            
+                            # 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)
+                                if year_weightings is not None:
+                                    generation_mwh = float((year_generation[gen_name].values * year_weightings).sum())
                                 else:
-                                    # Last resort: 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")
-                            
-                            if carrier_name in carrier_stats["dispatch_by_carrier"]:
-                                carrier_stats["dispatch_by_carrier"][carrier_name] += generation_mwh
+                                
+                                # Get marginal cost
+                                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
             
-            # 2. STORAGE_UNITS - Year-specific discharge
+            # 2. STORAGE_UNITS - Operational costs (discharge only)
             if hasattr(network, 'storage_units_t') and hasattr(network.storage_units_t, 'p'):
-                # Get storage unit-carrier mapping
+                # Get storage unit info: carrier, marginal_cost, build_year, lifetime
                 cursor = conn.execute("""
                     SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
@@ -1521,33 +1019,32 @@ class ResultStorage:
                     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())
-                            else:
-                                # Fallback: use all-year weightings if year-specific not available
-                                weightings = network.snapshot_weightings
-                                if isinstance(weightings, pd.DataFrame):
-                                    if 'objective' in weightings.columns:
-                                        weighting_values = weightings['objective'].values
-                                    else:
-                                        weighting_values = weightings.iloc[:, 0].values
-                                else:
-                                    weighting_values = weightings.values
-                                # Apply weightings to the filtered year data
-                                if len(weighting_values) == len(year_storage):
-                                    discharge_mwh = float((year_storage[su_name].clip(lower=0).values * weighting_values).sum())
+                            
+                            # 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
+                            
+                            # 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)
+                                if year_weightings is not None:
+                                    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())
-                                    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
+                                
+                                # 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
+                                
+                                # 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
             
-            # 3. STORES - Year-specific discharge
+            # 3. STORES - Operational costs (discharge only)
             if hasattr(network, 'stores_t') and hasattr(network.stores_t, 'p'):
-                # Get store-carrier mapping
+                # Get store info: carrier, marginal_cost, build_year, lifetime
                 cursor = conn.execute("""
                     SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
@@ -1562,34 +1059,56 @@ class ResultStorage:
                     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())
-                            else:
-                                # Fallback: use all-year weightings if year-specific not available
-                                weightings = network.snapshot_weightings
-                                if isinstance(weightings, pd.DataFrame):
-                                    if 'objective' in weightings.columns:
-                                        weighting_values = weightings['objective'].values
-                                    else:
-                                        weighting_values = weightings.iloc[:, 0].values
-                                else:
-                                    weighting_values = weightings.values
-                                # Apply weightings to the filtered year data
-                                if len(weighting_values) == len(year_stores):
-                                    discharge_mwh = float((year_stores[store_name].clip(lower=0).values * weighting_values).sum())
+                            
+                            # 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
+                            
+                            # 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)
+                                if year_weightings is not None:
+                                    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())
-                                    logger.warning(f"Could not apply snapshot weightings for store {store_name} in year {year} - energy may be incorrect")
+                                
+                                # Get marginal cost
+                                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["dispatch_by_carrier"]:
-                                carrier_stats["dispatch_by_carrier"][carrier_name] += discharge_mwh
+                            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]
+                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
             
-            # Calculate year-specific capacity by carrier (capacity available in this year)
+            # Calculate capacity by carrier for this specific year
             
-            # 1. GENERATORS - Year-specific power capacity
+            # 4. GENERATORS - Power capacity (MW) (including UNMET_LOAD)
             if hasattr(network, 'generators') and not network.generators.empty:
+                # Get generator-carrier mapping (include UNMET_LOAD)
+                cursor = conn.execute("""
+                    SELECT c.name as component_name, 
+                           CASE 
+                               WHEN c.component_type = 'UNMET_LOAD' THEN 'Unmet Load'
+                               ELSE carr.name 
+                           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,))
+                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]
@@ -1610,8 +1129,8 @@ class ResultStorage:
                             
                             if carrier_name in carrier_stats["power_capacity_by_carrier"]:
                                 carrier_stats["power_capacity_by_carrier"][carrier_name] += capacity_mw
-            
-            # 2. STORAGE_UNITS - Year-specific power capacity
+                                
+            # 2. STORAGE_UNITS - Power capacity (MW) + Energy capacity (MWh)
             if hasattr(network, 'storage_units') and not network.storage_units.empty:
                 # Get storage unit-carrier mapping
                 cursor = conn.execute("""
@@ -1634,16 +1153,25 @@ class ResultStorage:
                                 is_available = False
                         
                         if is_available:
-                            # Use p_nom_opt if available, otherwise p_nom
+                            # Power capacity (MW)
                             if 'p_nom_opt' in network.storage_units.columns:
-                                capacity_mw = float(network.storage_units.loc[su_name, 'p_nom_opt'])
+                                p_nom_opt = 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
+                                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] += capacity_mw
+                                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'])
+                            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
             
-            # 3. STORES - Year-specific energy capacity
+            # 3. STORES - Energy capacity (MWh) only
             if hasattr(network, 'stores') and not network.stores.empty:
                 # Get store-carrier mapping
                 cursor = conn.execute("""
@@ -1666,17 +1194,16 @@ class ResultStorage:
                                 is_available = False
                         
                         if is_available:
-                            # Use e_nom_opt if available, otherwise e_nom (energy capacity)
+                            # Energy capacity (MWh)
                             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
                             
-                            # Add to capacity (stores contribute energy capacity to the general "capacity" metric)
-                            if carrier_name in carrier_stats["power_capacity_by_carrier"]:
-                                carrier_stats["power_capacity_by_carrier"][carrier_name] += capacity_mwh
-            
-            # 4. LINES - Year-specific apparent power capacity
+                            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:
                 # Get line-carrier mapping
                 cursor = conn.execute("""
@@ -1699,19 +1226,18 @@ class ResultStorage:
                                 is_available = False
                         
                         if is_available:
-                            # Use s_nom_opt if available, otherwise s_nom (convert MVA to MW)
+                            # 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'])
                             else:
                                 capacity_mva = float(network.lines.loc[line_name, 's_nom']) if 's_nom' in network.lines.columns else 0.0
                             
-                            # Convert MVA to MW (assume power factor = 1)
-                            capacity_mw = capacity_mva
+                            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
             
-            # 5. LINKS - Year-specific power capacity
+            # 5. LINKS - Power capacity (MW)
             if hasattr(network, 'links') and not network.links.empty:
                 # Get link-carrier mapping
                 cursor = conn.execute("""
@@ -1734,7 +1260,7 @@ class ResultStorage:
                                 is_available = False
                         
                         if is_available:
-                            # Use p_nom_opt if available, otherwise p_nom
+                            # Power capacity (MW)
                             if 'p_nom_opt' in network.links.columns:
                                 capacity_mw = float(network.links.loc[link_name, 'p_nom_opt'])
                             else:
@@ -1743,376 +1269,158 @@ class ResultStorage:
                             if carrier_name in carrier_stats["power_capacity_by_carrier"]:
                                 carrier_stats["power_capacity_by_carrier"][carrier_name] += capacity_mw
             
-            # Calculate year-specific emissions (based on year-specific dispatch)
+            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")
+            
+            return carrier_stats
+            
+        except Exception as e:
+            logger.error(f"Failed to calculate year {year} carrier statistics: {e}", exc_info=True)
+            return {
+                "dispatch_by_carrier": {},
+                "power_capacity_by_carrier": {},
+                "energy_capacity_by_carrier": {},
+                "emissions_by_carrier": {},
+                "capital_cost_by_carrier": {},
+                "operational_cost_by_carrier": {},
+                "total_system_cost_by_carrier": {}
+            }
+    
+    def _sum_year_based_carrier_statistics(self, conn, network_id: int) -> Dict[str, Any]:
+        """
+        Sum up per-year carrier statistics for accurate multi-year totals.
+        For capacity: take the LAST YEAR (final capacity) instead of maximum.
+        """
+        try:
+            import json
+            
+            # Initialize totals
+            totals = {
+                "dispatch_by_carrier": {},
+                "power_capacity_by_carrier": {},
+                "energy_capacity_by_carrier": {},
+                "emissions_by_carrier": {},
+                "capital_cost_by_carrier": {},
+                "operational_cost_by_carrier": {},
+                "total_system_cost_by_carrier": {}
+            }
+            
+            # Get all carriers from database
             cursor = conn.execute("""
-                SELECT name, co2_emissions
-                FROM carriers 
-                WHERE network_id = ? AND co2_emissions IS NOT NULL
-                ORDER BY name
+                SELECT DISTINCT name FROM carriers WHERE network_id = ?
             """, (network_id,))
+            all_carriers = [row[0] for row in cursor.fetchall()]
             
-            emission_factors = {}
-            for row in cursor.fetchall():
-                carrier_name, co2_emissions = row
-                emission_factors[carrier_name] = co2_emissions
-            
-            # Calculate emissions = year_dispatch * emission_factor
-            for carrier, dispatch_mwh in carrier_stats["dispatch_by_carrier"].items():
-                emission_factor = emission_factors.get(carrier, 0.0)
-                emissions = dispatch_mwh * emission_factor
-                carrier_stats["emissions_by_carrier"][carrier] = emissions
+            # Initialize all carriers with zero values (including special "Unmet Load" carrier)
+            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
+                totals["energy_capacity_by_carrier"][carrier] = 0.0
+                totals["emissions_by_carrier"][carrier] = 0.0
+                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("""
+                SELECT year, results_json FROM network_solve_results_by_year 
+                WHERE network_id = ?
+                ORDER BY year
+            """, (network_id,))
             
-            # Calculate year-specific costs (all component types)
-            # For multi-period models, costs are complex - capital costs are incurred at build time
-            # but operational costs are incurred when generating
+            year_results = cursor.fetchall()
+            logger.info(f"Found {len(year_results)} year-based results to sum for network {network_id}")
             
-            # 1. GENERATORS - Year-specific operational and capital costs
-            if hasattr(network, 'generators') and not network.generators.empty:
-                for gen_name in network.generators.index:
-                    if gen_name in generator_carriers:
-                        carrier_name = generator_carriers[gen_name]
-                        
-                        # Operational costs = year_dispatch * marginal_cost
-                        if 'marginal_cost' in network.generators.columns:
-                            year_dispatch = 0.0
-                            if hasattr(network, 'generators_t') and hasattr(network.generators_t, 'p'):
-                                year_generation = self._filter_timeseries_by_year(network.generators_t.p, network.snapshots, year)
-                                if year_generation is not None and gen_name in year_generation.columns:
-                                    year_weightings = self._get_year_weightings(network, year)
-                                    if year_weightings is not None:
-                                        year_dispatch = float((year_generation[gen_name].values * year_weightings).sum())
-                                    else:
-                                        # Fallback: use all-year weightings if year-specific not available
-                                        weightings = network.snapshot_weightings
-                                        if isinstance(weightings, pd.DataFrame):
-                                            if 'objective' in weightings.columns:
-                                                weighting_values = weightings['objective'].values
-                                            else:
-                                                weighting_values = weightings.iloc[:, 0].values
-                                        else:
-                                            weighting_values = weightings.values
-                                        # Apply weightings to the filtered year data
-                                        if len(weighting_values) == len(year_generation):
-                                            year_dispatch = float((year_generation[gen_name].values * weighting_values).sum())
-                                        else:
-                                            year_dispatch = float(year_generation[gen_name].sum())
-                                            logger.warning(f"Could not apply snapshot weightings for operational cost calc of {gen_name} in year {year} - cost may be incorrect")
-                            
-                            marginal_cost = float(network.generators.loc[gen_name, 'marginal_cost'])
-                            operational_cost = year_dispatch * marginal_cost
-                            
-                            if carrier_name in carrier_stats["operational_cost_by_carrier"]:
-                                carrier_stats["operational_cost_by_carrier"][carrier_name] += operational_cost
-                        
-                        # Capital costs - include if asset is operational in this year (matching old solver)
-                        if 'capital_cost' in network.generators.columns:
-                            # Check if this generator is operational in this year
-                            is_operational = True
-                            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_operational = False  # Not built yet
-                            
-                            if is_operational:
-                                capital_cost_per_mw = float(network.generators.loc[gen_name, 'capital_cost'])
-                                
-                                if 'p_nom_opt' in network.generators.columns:
-                                    capacity_mw = float(network.generators.loc[gen_name, 'p_nom_opt'])
-                                elif 'p_nom' in network.generators.columns:
-                                    capacity_mw = float(network.generators.loc[gen_name, 'p_nom'])
-                                else:
-                                    capacity_mw = 0.0
-                                
-                                # Annual capital cost for operational assets (undiscounted)
-                                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
+            if not year_results:
+                logger.warning(f"No year-based results found for network {network_id}")
+                return totals
             
-            # 2. STORAGE_UNITS - Year-specific operational and capital costs
-            if hasattr(network, 'storage_units') and not network.storage_units.empty:
-                # Get storage unit-carrier mapping
-                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,))
-                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]
-                        
-                        # Operational costs = year_discharge * marginal_cost
-                        if 'marginal_cost' in network.storage_units.columns:
-                            year_discharge = 0.0
-                            if hasattr(network, 'storage_units_t') and hasattr(network.storage_units_t, 'p'):
-                                year_storage = self._filter_timeseries_by_year(network.storage_units_t.p, network.snapshots, year)
-                                if year_storage is not None and su_name in year_storage.columns:
-                                    year_weightings = self._get_year_weightings(network, year)
-                                    if year_weightings is not None:
-                                        year_discharge = float((year_storage[su_name].clip(lower=0).values * year_weightings).sum())
-                                    else:
-                                        # Fallback: use all-year weightings if year-specific not available
-                                        weightings = network.snapshot_weightings
-                                        if isinstance(weightings, pd.DataFrame):
-                                            if 'objective' in weightings.columns:
-                                                weighting_values = weightings['objective'].values
-                                            else:
-                                                weighting_values = weightings.iloc[:, 0].values
-                                        else:
-                                            weighting_values = weightings.values
-                                        # Apply weightings to the filtered year data
-                                        if len(weighting_values) == len(year_storage):
-                                            year_discharge = float((year_storage[su_name].clip(lower=0).values * weighting_values).sum())
-                                        else:
-                                            year_discharge = float(year_storage[su_name].clip(lower=0).sum())
-                                            logger.warning(f"Could not apply snapshot weightings for operational cost calc of storage unit {su_name} in year {year} - cost may be incorrect")
-                            
-                            marginal_cost = float(network.storage_units.loc[su_name, 'marginal_cost'])
-                            operational_cost = year_discharge * marginal_cost
-                            
-                            if carrier_name in carrier_stats["operational_cost_by_carrier"]:
-                                carrier_stats["operational_cost_by_carrier"][carrier_name] += operational_cost
-                        
-                        # Capital costs - include if asset is operational in this year (matching old solver)
-                        if 'capital_cost' in network.storage_units.columns:
-                            # Check if this storage unit is operational in this year
-                            is_operational = True
-                            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_operational = False  # Not built yet
-                            
-                            if is_operational:
-                                capital_cost_per_mw = float(network.storage_units.loc[su_name, 'capital_cost'])
-                                
-                                if 'p_nom_opt' in network.storage_units.columns:
-                                    capacity_mw = float(network.storage_units.loc[su_name, 'p_nom_opt'])
-                                elif 'p_nom' in network.storage_units.columns:
-                                    capacity_mw = float(network.storage_units.loc[su_name, 'p_nom'])
-                                else:
-                                    capacity_mw = 0.0
-                                
-                                # Annual capital cost for operational assets (undiscounted)
-                                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
+            # For capacity: use the LAST YEAR only (final capacity state)
+            last_year, last_results_json = year_results[-1]
             
-            # 3. STORES - Year-specific operational and capital costs
-            if hasattr(network, 'stores') and not network.stores.empty:
-                # Get store-carrier mapping
-                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,))
-                store_carriers = {row[0]: row[1] for row in cursor.fetchall()}
+            try:
+                results = json.loads(last_results_json)
+                network_stats = results.get('network_statistics', {})
+                custom_stats = network_stats.get('custom_statistics', {})
                 
-                for store_name in network.stores.index:
-                    if store_name in store_carriers:
-                        carrier_name = store_carriers[store_name]
-                        
-                        # Operational costs = year_discharge * marginal_cost
-                        if 'marginal_cost' in network.stores.columns:
-                            year_discharge = 0.0
-                            if hasattr(network, 'stores_t') and hasattr(network.stores_t, 'p'):
-                                year_stores = self._filter_timeseries_by_year(network.stores_t.p, network.snapshots, year)
-                                if year_stores is not None and store_name in year_stores.columns:
-                                    year_weightings = self._get_year_weightings(network, year)
-                                    if year_weightings is not None:
-                                        year_discharge = float((year_stores[store_name].clip(lower=0).values * year_weightings).sum())
-                                    else:
-                                        # Fallback: use all-year weightings if year-specific not available
-                                        weightings = network.snapshot_weightings
-                                        if isinstance(weightings, pd.DataFrame):
-                                            if 'objective' in weightings.columns:
-                                                weighting_values = weightings['objective'].values
-                                            else:
-                                                weighting_values = weightings.iloc[:, 0].values
-                                        else:
-                                            weighting_values = weightings.values
-                                        # Apply weightings to the filtered year data
-                                        if len(weighting_values) == len(year_stores):
-                                            year_discharge = float((year_stores[store_name].clip(lower=0).values * weighting_values).sum())
-                                        else:
-                                            year_discharge = float(year_stores[store_name].clip(lower=0).sum())
-                                            logger.warning(f"Could not apply snapshot weightings for operational cost calc of store {store_name} in year {year} - cost may be incorrect")
-                            
-                            marginal_cost = float(network.stores.loc[store_name, 'marginal_cost'])
-                            operational_cost = year_discharge * marginal_cost
-                            
-                            if carrier_name in carrier_stats["operational_cost_by_carrier"]:
-                                carrier_stats["operational_cost_by_carrier"][carrier_name] += operational_cost
-                        
-                        # Capital costs - include if asset is operational in this year (matching old solver)
-                        if 'capital_cost' in network.stores.columns:
-                            # Check if this store is operational in this year
-                            is_operational = True
-                            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_operational = False  # Not built yet
-                            
-                            if is_operational:
-                                capital_cost_per_mwh = float(network.stores.loc[store_name, 'capital_cost'])
-                                
-                                if 'e_nom_opt' in network.stores.columns:
-                                    capacity_mwh = float(network.stores.loc[store_name, 'e_nom_opt'])
-                                elif 'e_nom' in network.stores.columns:
-                                    capacity_mwh = float(network.stores.loc[store_name, 'e_nom'])
-                                else:
-                                    capacity_mwh = 0.0
-                                
-                                # Annual capital cost for operational assets (undiscounted)
-                                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
-            
-            # 4. LINES - Year-specific capital costs (only count if built in this year)
-            if hasattr(network, 'lines') and not network.lines.empty:
-                # Get line-carrier mapping
-                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,))
-                line_carriers = {row[0]: row[1] for row in cursor.fetchall()}
+                # Use last year's capacity as the all-year capacity
+                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)
                 
-                for line_name in network.lines.index:
-                    if line_name in line_carriers:
-                        carrier_name = line_carriers[line_name]
-                        
-                        # Capital costs - include if asset is operational in this year (matching old solver)
-                        if 'capital_cost' in network.lines.columns:
-                            # Check if this line is operational in this year
-                            is_operational = True
-                            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_operational = False  # Not built yet
-                            
-                            if is_operational:
-                                capital_cost_per_mva = float(network.lines.loc[line_name, 'capital_cost'])
-                                
-                                if 's_nom_opt' in network.lines.columns:
-                                    capacity_mva = float(network.lines.loc[line_name, 's_nom_opt'])
-                                elif 's_nom' in network.lines.columns:
-                                    capacity_mva = float(network.lines.loc[line_name, 's_nom'])
-                                else:
-                                    capacity_mva = 0.0
-                                
-                                # Annual capital cost for operational assets (undiscounted)
-                                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
-            
-            # 5. LINKS - Year-specific operational and capital costs
-            if hasattr(network, 'links') and not network.links.empty:
-                # Get link-carrier mapping
-                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,))
-                link_carriers = {row[0]: row[1] for row in cursor.fetchall()}
+                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)
                 
-                # Operational costs for links (year-specific flow)
-                if hasattr(network, 'links_t') and hasattr(network.links_t, 'p0'):
-                    for link_name in network.links.index:
-                        if link_name in link_carriers:
-                            carrier_name = link_carriers[link_name]
-                            
-                            # Get marginal cost for this link
-                            marginal_cost = 0.0
-                            if 'marginal_cost' in network.links.columns:
-                                marginal_cost = float(network.links.loc[link_name, 'marginal_cost'])
-                            
-                            # Calculate operational cost = year_flow * marginal_cost
-                            year_flow = 0.0
-                            if link_name in network.links_t.p0.columns:
-                                year_links = self._filter_timeseries_by_year(network.links_t.p0, network.snapshots, year)
-                                if year_links is not None and link_name in year_links.columns:
-                                    year_weightings = self._get_year_weightings(network, year)
-                                    if year_weightings is not None:
-                                        year_flow = float((abs(year_links[link_name]).values * year_weightings).sum())
-                                    else:
-                                        # Fallback: use all-year weightings if year-specific not available
-                                        weightings = network.snapshot_weightings
-                                        if isinstance(weightings, pd.DataFrame):
-                                            if 'objective' in weightings.columns:
-                                                weighting_values = weightings['objective'].values
-                                            else:
-                                                weighting_values = weightings.iloc[:, 0].values
-                                        else:
-                                            weighting_values = weightings.values
-                                        # Apply weightings to the filtered year data
-                                        if len(weighting_values) == len(year_links):
-                                            year_flow = float((abs(year_links[link_name]).values * weighting_values).sum())
-                                        else:
-                                            year_flow = float(abs(year_links[link_name]).sum())
-                                            logger.warning(f"Could not apply snapshot weightings for operational cost calc of link {link_name} in year {year} - cost may be incorrect")
-                            
-                            operational_cost = year_flow * marginal_cost
-                            
-                            if carrier_name in carrier_stats["operational_cost_by_carrier"]:
-                                carrier_stats["operational_cost_by_carrier"][carrier_name] += operational_cost
+                logger.info(f"Used last year ({last_year}) capacity as all-year capacity")
                 
-                # Capital costs for links - only count if built in this year
-                for link_name in network.links.index:
-                    if link_name in link_carriers:
-                        carrier_name = link_carriers[link_name]
-                        
-                        # Capital costs - include if asset is operational in this year (matching old solver)
-                        if 'capital_cost' in network.links.columns:
-                            # Check if this link is operational in this year
-                            is_operational = True
-                            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_operational = False  # Not built yet
-                            
-                            if is_operational:
-                                capital_cost_per_mw = float(network.links.loc[link_name, 'capital_cost'])
-                                
-                                if 'p_nom_opt' in network.links.columns:
-                                    capacity_mw = float(network.links.loc[link_name, 'p_nom_opt'])
-                                elif 'p_nom' in network.links.columns:
-                                    capacity_mw = float(network.links.loc[link_name, 'p_nom'])
-                                else:
-                                    capacity_mw = 0.0
-                                
-                                # Annual capital cost for operational assets (undiscounted)
-                                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
+            except Exception as e:
+                logger.error(f"Failed to process last year ({last_year}) results: {e}")
             
-            # Calculate total system cost = capital + operational (for this year)
-            for carrier in all_carriers:
-                capital = carrier_stats["capital_cost_by_carrier"][carrier]
-                operational = carrier_stats["operational_cost_by_carrier"][carrier]
-                carrier_stats["total_system_cost_by_carrier"][carrier] = capital + operational
+            # 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', {})
+                    
+                    # Sum dispatch (energy values - sum across years)
+                    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', {})
+                    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', {})
+                    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)
+                    
+                    # Sum operational costs (cumulative across years)
+                    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)
+                    
+                    # Sum total system costs (cumulative across years)
+                    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)
+                    
+                except Exception as e:
+                    logger.error(f"Failed to process year {year} results: {e}")
+                    continue
             
-            logger.info(f"Calculated year {year} carrier statistics:")
-            logger.info(f"  Dispatch: {sum(carrier_stats['dispatch_by_carrier'].values()):.2f} MWh")
-            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"  Emissions: {sum(carrier_stats['emissions_by_carrier'].values()):.2f} tCO2")
-            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"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")
             
-            return carrier_stats
+            return totals
             
         except Exception as e:
-            logger.error(f"Failed to calculate year {year} 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": {},
                 "power_capacity_by_carrier": {},
@@ -2123,10 +1431,46 @@ class ResultStorage:
                 "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 = {
+                "success": solve_result.get("success", False),
+                "status": solve_result.get("status", "unknown"),
+                "solve_time": solve_result.get("solve_time", 0.0),
+                "objective_value": solve_result.get("objective_value"),
+                "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", {})
+            }
+            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"),
+                "run_id": solve_result.get("run_id"),
+                "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)
+            }
+            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':
-        """Filter timeseries data by year - copied from solver for consistency"""
+        """Filter timeseries data by year"""
         try:
-            
             # Handle MultiIndex case (multi-period optimization)
             if hasattr(snapshots, 'levels'):
                 period_values = snapshots.get_level_values(0)
@@ -2149,9 +1493,8 @@ class ResultStorage:
             return None
     
     def _get_year_weightings(self, network: 'pypsa.Network', year: int) -> 'np.ndarray':
-        """Get snapshot weightings for a specific year - copied from solver for consistency"""
+        """Get snapshot weightings for a specific year"""
         try:
-            
             # Filter snapshot weightings by year
             if hasattr(network.snapshots, 'levels'):
                 period_values = network.snapshots.get_level_values(0)
@@ -2185,6 +1528,30 @@ class ResultStorage:
             logger.error(f"Failed to get year weightings for year {year}: {e}")
             return None
     
+    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'):
+                # 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
+                    else:
+                        weighting_values = weightings.iloc[:, 0].values
+                else:
+                    weighting_values = weightings.values
+                
+                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"""
@@ -2204,4 +1571,4 @@ class ResultStorage:
         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")