Merge branch 'main' into initial_capex_bugfix

Author: alxsmith

run_example.py

@@ -48,7 +48,7 @@
     for scenario_name, scenario_df in results_df.items():
         if scenario_name == "bau":
             continue  # Skip BAU for absolute value plotting
-        filtered_results[scenario_name] = scenario_df.select(COMPARE_COLS)
+        filtered_results[scenario_name] = scenario_df.select(["year", *COMPARE_COLS])
 
     # Concatenate and transform to long format
     combined_df = pl.concat(

src/npa_howtopay/model.py

@@ -478,7 +478,7 @@ def run_model(scenario_params: ScenarioParams, input_params: InputParams, ts_par
 
 
 def create_delta_bau_df(results_df: dict[str, pl.DataFrame], compare_cols: list[str]) -> pl.DataFrame:
-    bau_df = results_df["bau"].select(compare_cols)
+    bau_df = results_df["bau"].select(["year"] + compare_cols)
 
     # Create comparison DataFrames for each scenario
     comparison_dfs = {}
@@ -488,11 +488,9 @@ def create_delta_bau_df(results_df: dict[str, pl.DataFrame], compare_cols: list[
 
         # Join with BAU to subtract values
         comparison_df = scenario_df.join(
-            bau_df.select(["year"] + [col for col in compare_cols[1:]]).rename({
-                col: f"bau_{col}" for col in compare_cols[1:]
-            }),
+            bau_df.select(["year"] + [col for col in compare_cols]).rename({col: f"bau_{col}" for col in compare_cols}),
             on="year",
-        ).select(["year", *[pl.col(col).sub(pl.col(f"bau_{col}")) for col in compare_cols[1:]]])
+        ).select(["year", *[pl.col(col).sub(pl.col(f"bau_{col}")) for col in compare_cols]])
 
         comparison_dfs[scenario_name] = comparison_df
     delta_bau_df = pl.concat(

src/npa_howtopay/params.py

@@ -14,7 +14,6 @@
 KWH_PER_THERM = 29.3071
 
 COMPARE_COLS = [
-    "year",
     # revenue requirement
     "gas_inflation_adjusted_revenue_requirement",
     "electric_inflation_adjusted_revenue_requirement",
@@ -214,11 +213,13 @@ def load_time_series_params_from_yaml(run_name: str, data_dir: str = "data") ->
     return _load_time_series_params_from_yaml(str(yaml_path))
 
 
-def load_time_series_params_from_web_params(web_params: dict, start_year: int, end_year: int) -> TimeSeriesParams:
+def load_time_series_params_from_web_params(
+    web_params: dict, start_year: int, end_year: int, cost_inflation_rate: float = 0.0
+) -> TimeSeriesParams:
     """Load time series parameters from web parameters (scalar values)"""
 
     web_params_obj = WebParams(**web_params)
-    generated_data = create_time_series_from_web_params(web_params_obj, start_year, end_year)
+    generated_data = create_time_series_from_web_params(web_params_obj, start_year, end_year, cost_inflation_rate)
 
     return TimeSeriesParams(
         npa_projects=generated_data["npa_projects"],

src/npa_howtopay/web_params.py

@@ -1,5 +1,6 @@
 from attrs import define
 import polars as pl
+from typing import Optional
 
 
 @define
@@ -32,34 +33,64 @@ def create_npa_projects(web_params: WebParams, start_year: int, end_year: int) -
     })
 
 
-def create_gas_fixed_overhead_costs(web_params: WebParams, start_year: int, end_year: int) -> pl.DataFrame:
+def create_gas_fixed_overhead_costs(
+    web_params: WebParams, start_year: int, end_year: int, cost_inflation_rate: float = 0.0
+) -> pl.DataFrame:
+    years = list(range(start_year, end_year + 1))
+    base_cost = web_params.gas_fixed_overhead_costs
+
+    # Apply compound inflation: cost * (1 + rate)^(year - start_year)
+    costs = [base_cost * (1 + cost_inflation_rate) ** (year - start_year) for year in years]
+
     return pl.DataFrame({
-        "year": list(range(start_year, end_year + 1)),
-        "cost": [web_params.gas_fixed_overhead_costs] * (end_year - start_year + 1),
+        "year": years,
+        "cost": costs,
     })
 
 
-def create_electric_fixed_overhead_costs(web_params: WebParams, start_year: int, end_year: int) -> pl.DataFrame:
+def create_electric_fixed_overhead_costs(
+    web_params: WebParams, start_year: int, end_year: int, cost_inflation_rate: float = 0.0
+) -> pl.DataFrame:
+    years = list(range(start_year, end_year + 1))
+    base_cost = web_params.electric_fixed_overhead_costs
+
+    # Apply compound inflation: cost * (1 + rate)^(year - start_year)
+    costs = [base_cost * (1 + cost_inflation_rate) ** (year - start_year) for year in years]
+
     return pl.DataFrame({
-        "year": list(range(start_year, end_year + 1)),
-        "cost": [web_params.electric_fixed_overhead_costs] * (end_year - start_year + 1),
+        "year": years,
+        "cost": costs,
     })
 
 
-def create_gas_bau_lpp_costs_per_year(web_params: WebParams, start_year: int, end_year: int) -> pl.DataFrame:
+def create_gas_bau_lpp_costs_per_year(
+    web_params: WebParams, start_year: int, end_year: int, cost_inflation_rate: float = 0.0
+) -> pl.DataFrame:
+    years = list(range(start_year, end_year + 1))
+    base_cost = web_params.gas_bau_lpp_costs_per_year
+
+    # Apply compound inflation: cost * (1 + rate)^(year - start_year)
+    costs = [base_cost * (1 + cost_inflation_rate) ** (year - start_year) for year in years]
+
     return pl.DataFrame({
-        "year": list(range(start_year, end_year + 1)),
-        "cost": [web_params.gas_bau_lpp_costs_per_year] * (end_year - start_year + 1),
+        "year": years,
+        "cost": costs,
     })
 
 
 def create_time_series_from_web_params(
-    web_params: WebParams, start_year: int, end_year: int
+    web_params: WebParams, start_year: int, end_year: int, cost_inflation_rate: float = 0.0
 ) -> dict[str, pl.DataFrame]:
     """Create all time series DataFrames from web parameters"""
     return {
         "npa_projects": create_npa_projects(web_params, start_year, end_year),
-        "gas_fixed_overhead_costs": create_gas_fixed_overhead_costs(web_params, start_year, end_year),
-        "electric_fixed_overhead_costs": create_electric_fixed_overhead_costs(web_params, start_year, end_year),
-        "gas_bau_lpp_costs_per_year": create_gas_bau_lpp_costs_per_year(web_params, start_year, end_year),
+        "gas_fixed_overhead_costs": create_gas_fixed_overhead_costs(
+            web_params, start_year, end_year, cost_inflation_rate
+        ),
+        "electric_fixed_overhead_costs": create_electric_fixed_overhead_costs(
+            web_params, start_year, end_year, cost_inflation_rate
+        ),
+        "gas_bau_lpp_costs_per_year": create_gas_bau_lpp_costs_per_year(
+            web_params, start_year, end_year, cost_inflation_rate
+        ),
     }

tests/test_input_load.py

@@ -1,4 +1,6 @@
+import polars as pl
 import pytest
+from polars.testing import assert_frame_equal
 
 from npa_howtopay.params import (
     ScenarioParams,
@@ -26,6 +28,75 @@ def web_params():
     }
 
 
+@pytest.fixture
+def expected_gas_bau_lpp_costs_no_inflation():
+    """Expected gas BAU LPP costs for 2025-2030 with no inflation"""
+    return pl.DataFrame({
+        "year": [2025, 2026, 2027, 2028, 2029, 2030],
+        "cost": [100.0, 100.0, 100.0, 100.0, 100.0, 100.0],
+    })
+
+
+@pytest.fixture
+def expected_gas_fixed_overhead_costs_no_inflation():
+    """Expected gas fixed overhead costs for 2025-2030 with no inflation"""
+    return pl.DataFrame({
+        "year": [2025, 2026, 2027, 2028, 2029, 2030],
+        "cost": [100.0, 100.0, 100.0, 100.0, 100.0, 100.0],
+    })
+
+
+@pytest.fixture
+def expected_electric_fixed_overhead_costs_no_inflation():
+    """Expected electric fixed overhead costs for 2025-2030 with no inflation"""
+    return pl.DataFrame({
+        "year": [2025, 2026, 2027, 2028, 2029, 2030],
+        "cost": [100.0, 100.0, 100.0, 100.0, 100.0, 100.0],
+    })
+
+
+@pytest.fixture
+def expected_gas_bau_lpp_costs_with_inflation():
+    """Expected gas BAU LPP costs for 2025-2030 with 5% inflation"""
+    return pl.DataFrame({
+        "year": [2025, 2026, 2027, 2028, 2029, 2030],
+        "cost": [100.0, 105.0, 110.25, 115.7625, 121.550625, 127.62815625],
+    })
+
+
+@pytest.fixture
+def expected_gas_fixed_overhead_costs_with_inflation():
+    """Expected gas fixed overhead costs for 2025-2030 with 5% inflation"""
+    return pl.DataFrame({
+        "year": [2025, 2026, 2027, 2028, 2029, 2030],
+        "cost": [100.0, 105.0, 110.25, 115.7625, 121.550625, 127.62815625],
+    })
+
+
+@pytest.fixture
+def expected_electric_fixed_overhead_costs_with_inflation():
+    """Expected electric fixed overhead costs for 2025-2030 with 5% inflation"""
+    return pl.DataFrame({
+        "year": [2025, 2026, 2027, 2028, 2029, 2030],
+        "cost": [100.0, 105.0, 110.25, 115.7625, 121.550625, 127.62815625],
+    })
+
+
+@pytest.fixture
+def expected_npa_projects():
+    """Expected NPA projects for 2025-2030"""
+    return pl.DataFrame({
+        "project_year": [2025, 2026, 2027, 2028, 2029, 2030],
+        "num_converts": [100, 100, 100, 100, 100, 100],
+        "pipe_value_per_user": [1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0],
+        "pipe_decomm_cost_per_user": [100.0, 100.0, 100.0, 100.0, 100.0, 100.0],
+        "peak_kw_winter_headroom": [10.0, 10.0, 10.0, 10.0, 10.0, 10.0],
+        "peak_kw_summer_headroom": [10.0, 10.0, 10.0, 10.0, 10.0, 10.0],
+        "aircon_percent_adoption_pre_npa": [0.8, 0.8, 0.8, 0.8, 0.8, 0.8],
+        "is_scattershot": [False, False, False, False, False, False],
+    })
+
+
 def test_load_sample_yaml():
     """Test loading the sample.yaml file"""
     # Load the sample scenario
@@ -34,36 +105,54 @@ def test_load_sample_yaml():
     assert params is not None
 
 
-def test_load_web_params(web_params):
-    """Test loading the web params"""
-    params = load_time_series_params_from_web_params(web_params, 2025, 2050)
-    # Verify params has expected structure
+def test_load_web_params_no_inflation(
+    web_params,
+    expected_gas_bau_lpp_costs_no_inflation,
+    expected_gas_fixed_overhead_costs_no_inflation,
+    expected_electric_fixed_overhead_costs_no_inflation,
+    expected_npa_projects,
+):
+    """Test loading the web params without inflation"""
+    params = load_time_series_params_from_web_params(web_params, 2025, 2030)
+
+    # Verify params is not None
     assert params is not None
 
-    # Verify gas_bau_lpp_costs df has correct shape and columns
-    assert params.gas_bau_lpp_costs_per_year.shape == (26, 2)
-    assert set(params.gas_bau_lpp_costs_per_year.columns) == {"year", "cost"}
+    # Test each DataFrame against expected values
+    assert params.gas_bau_lpp_costs_per_year.equals(expected_gas_bau_lpp_costs_no_inflation)
+    assert params.gas_fixed_overhead_costs.equals(expected_gas_fixed_overhead_costs_no_inflation)
+    assert params.electric_fixed_overhead_costs.equals(expected_electric_fixed_overhead_costs_no_inflation)
+    assert params.npa_projects.equals(expected_npa_projects)
 
-    # Verify gas_fixed_overhead_costs df has correct shape and columns
-    assert params.gas_fixed_overhead_costs.shape == (26, 2)
-    assert set(params.gas_fixed_overhead_costs.columns) == {"year", "cost"}
 
-    # Verify electric_fixed_overhead_costs df has correct shape and columns
-    assert params.electric_fixed_overhead_costs.shape == (26, 2)
-    assert set(params.electric_fixed_overhead_costs.columns) == {"year", "cost"}
+def test_load_web_params_with_inflation(
+    web_params,
+    expected_gas_bau_lpp_costs_with_inflation,
+    expected_gas_fixed_overhead_costs_with_inflation,
+    expected_electric_fixed_overhead_costs_with_inflation,
+    expected_npa_projects,
+):
+    """Test loading the web params with 5% inflation"""
+    params = load_time_series_params_from_web_params(web_params, 2025, 2030, cost_inflation_rate=0.05)
 
-    # Verify npa_projects df has correct shape and columns
-    assert params.npa_projects.shape == (26, 8)
-    assert set(params.npa_projects.columns) == {
-        "project_year",
-        "num_converts",
-        "pipe_value_per_user",
-        "pipe_decomm_cost_per_user",
-        "peak_kw_winter_headroom",
-        "peak_kw_summer_headroom",
-        "aircon_percent_adoption_pre_npa",
-        "is_scattershot",
-    }
+    # Verify params is not None
+    assert params is not None
+
+    # Test each DataFrame against expected values with proper float tolerance
+    assert_frame_equal(
+        params.gas_bau_lpp_costs_per_year, expected_gas_bau_lpp_costs_with_inflation, check_exact=False, atol=1e-10
+    )
+    assert_frame_equal(
+        params.gas_fixed_overhead_costs, expected_gas_fixed_overhead_costs_with_inflation, check_exact=False, atol=1e-10
+    )
+    assert_frame_equal(
+        params.electric_fixed_overhead_costs,
+        expected_electric_fixed_overhead_costs_with_inflation,
+        check_exact=False,
+        atol=1e-10,
+    )
+    # NPA projects should match exactly (no floats)
+    assert params.npa_projects.equals(expected_npa_projects)
 
 
 def test_load_time_series_params_from_yaml():