set up workflow for LT EEG sweeps

Author: lindnemi

Snakefile

@@ -1020,15 +1020,15 @@ rule prepare_st_low_res_network:
         ),
     input:
         network=RESULTS
-        + "networks/base_s_{clusters}_{opts}_{sector_opts}_{st_years}.nc",
+        + "networks/base_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}.nc",
     output:
         st_low_res_prenetwork=RESULTS
-        + "st_low_res_prenetworks/base_s_{clusters}_{opts}_{sector_opts}_{st_years}_eeg_level_{eeg_level}.nc",
+        + "st_low_res_prenetworks/base_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}_eeg_level_{eeg_level}.nc",
     resources:
         mem_mb=16000,
     log:
         RESULTS
-        + "logs/st_low_res_prenetwork_s_{clusters}_{opts}_{sector_opts}_{st_years}_eeg_level_{eeg_level}.log",
+        + "logs/st_low_res_prenetwork_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}_eeg_level_{eeg_level}.log",
     script:
         "scripts/pypsa-de/prepare_st_low_res_network.py"
 
@@ -1042,21 +1042,21 @@ rule solve_st_low_res_network:
         custom_extra_functionality=input_custom_extra_functionality,
     input:
         st_low_res_prenetwork=RESULTS
-        + "st_low_res_prenetworks/base_s_{clusters}_{opts}_{sector_opts}_{st_years}_eeg_level_{eeg_level}.nc",
+        + "st_low_res_prenetworks/base_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}_eeg_level_{eeg_level}.nc",
         co2_totals_name=resources("co2_totals.csv"),
         energy_totals=resources("energy_totals.csv"),
     output:
         st_low_res_network=RESULTS
-        + "st_low_res_networks/{sensitivity}/base_s_{clusters}_{opts}_{sector_opts}_{st_years}_eeg_level_{eeg_level}.nc",
+        + "st_low_res_networks/{sensitivity}/base_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}_eeg_level_{eeg_level}.nc",
     shadow:
         shadow_config
     log:
         solver=RESULTS
-        + "logs/st_low_res_networks/{sensitivity}/base_s_{clusters}_{opts}_{sector_opts}_{st_years}_eeg_level_{eeg_level}_solver.log",
+        + "logs/st_low_res_networks/{sensitivity}/base_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}_eeg_level_{eeg_level}_solver.log",
         memory=RESULTS
-        + "logs/st_low_res_networks/{sensitivity}/base_s_{clusters}_{opts}_{sector_opts}_{st_years}_eeg_level_{eeg_level}_memory.log",
+        + "logs/st_low_res_networks/{sensitivity}/base_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}_eeg_level_{eeg_level}_memory.log",
         python=RESULTS
-        + "logs/st_low_res_networks/{sensitivity}/base_s_{clusters}_{opts}_{sector_opts}_{st_years}_eeg_level_{eeg_level}_python.log",
+        + "logs/st_low_res_networks/{sensitivity}/base_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}_eeg_level_{eeg_level}_python.log",
     threads: solver_threads
     resources:
         mem_mb=config_provider("solving", "mem_mb"),
@@ -1102,9 +1102,11 @@ use rule export_ariadne_variables as export_st_variables with:
         energy_totals=resources("energy_totals.csv"),
         st_low_res_networks=expand(
             RESULTS
-            + "st_low_res_networks/{sensitivity}/base_s_{clusters}_{opts}_{sector_opts}_{st_years}_eeg_level_{eeg_level}.nc",
+            + "st_low_res_networks/{sensitivity}/base_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}_eeg_level_{eeg_level}.nc",
             **config["scenario"],
-            st_years=config_provider("iiasa_database", "regret_run", "st_years"),
+            eeg_sweep_year=config_provider(
+                "iiasa_database", "regret_run", "eeg_sweep_year"
+            ),
             allow_missing=True,
         ),
     output:
@@ -1128,6 +1130,111 @@ rule st_all:
         ),
 
 
+rule solve_eeg_sweep_lt:
+    params:
+        solving=config_provider("solving"),
+        foresight=config_provider("foresight"),
+        co2_sequestration_potential=config_provider(
+            "sector", "co2_sequestration_potential", default=200
+        ),
+        custom_extra_functionality=input_custom_extra_functionality,
+        energy_year=config_provider("energy", "energy_totals_year"),
+    input:
+        network=resources(
+            "networks/base_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}_final.nc"
+        ),
+        co2_totals_name=resources("co2_totals.csv"),
+        energy_totals=resources("energy_totals.csv"),
+    output:
+        network=RESULTS
+        + "networks/base_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}_EEG_{eeg_level}.nc",
+        config=RESULTS
+        + "configs/config.base_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}_EEG_{eeg_level}.yaml",
+    shadow:
+        shadow_config
+    log:
+        solver=RESULTS
+        + "logs/base_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}_EEG_{eeg_level}_solver.log",
+        memory=RESULTS
+        + "logs/base_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}_EEG_{eeg_level}_memory.log",
+        python=RESULTS
+        + "logs/base_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}_EEG_{eeg_level}_python.log",
+    threads: solver_threads
+    resources:
+        mem_mb=config_provider("solving", "mem_mb"),
+        runtime=config_provider("solving", "runtime", default="6h"),
+    benchmark:
+        (
+            RESULTS
+            + "benchmarks/solve_sector_network/base_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}_EEG_{eeg_level}"
+        )
+    conda:
+        "envs/environment.yaml"
+    script:
+        "scripts/solve_network.py"
+
+
+use rule export_ariadne_variables as export_eeg_sweep_lt_variables with:
+    input:
+        template="data/template_ariadne_database.xlsx",
+        industry_demands=expand(
+            resources(
+                "industrial_energy_demand_base_s_{clusters}_{planning_horizons}.csv"
+            ),
+            **config["scenario"],
+            allow_missing=True,
+        ),
+        networks=expand(
+            RESULTS
+            + "networks/base_s_{clusters}_{opts}_{sector_opts}_{planning_horizons}.nc",
+            **config["scenario"],
+            allow_missing=True,
+        ),
+        costs=expand(
+            resources("costs_{planning_horizons}.csv"),
+            **config["scenario"],
+            allow_missing=True,
+        ),
+        industrial_production_per_country_tomorrow=expand(
+            resources(
+                "industrial_production_per_country_tomorrow_{planning_horizons}-modified.csv"
+            ),
+            **config["scenario"],
+            allow_missing=True,
+        ),
+        industry_sector_ratios=expand(
+            resources("industry_sector_ratios_{planning_horizons}.csv"),
+            **config["scenario"],
+            allow_missing=True,
+        ),
+        industrial_production=resources("industrial_production_per_country.csv"),
+        energy_totals=resources("energy_totals.csv"),
+        eeg_sweep_networks=expand(
+            RESULTS
+            + "networks/base_s_{clusters}_{opts}_{sector_opts}_{eeg_sweep_year}_EEG_{eeg_level}.nc",
+            **config["scenario"],
+            eeg_sweep_year=config_provider(
+                "iiasa_database", "regret_run", "eeg_sweep_year"
+            ),
+            allow_missing=True,
+        ),
+    output:
+        exported_variables=RESULTS + "ariadne/exported_variables_EEG_{eeg_level}.xlsx",
+        exported_variables_full=RESULTS
+        + "ariadne/exported_variables_full_EEG_{eeg_level}.xlsx",
+    log:
+        RESULTS + "logs/export_ariadne_variables_EEG_{eeg_level}.log",
+
+
+rule eeg_sweep:
+    input:
+        expand(
+            RESULTS + "ariadne/exported_variables_full_EEG_{eeg_level}.xlsx",
+            eeg_level=config_provider("iiasa_database", "regret_run", "EEG_levels"),
+            run=config_provider("run", "name"),
+        ),
+
+
 rule prepare_regret_network:
     params:
         solving=config_provider("solving"),

config/config.de.yaml

@@ -56,13 +56,13 @@ iiasa_database:
     #- no_flex
     #- gas_price_60
     #- gas_price_80
-    st_years:
+    eeg_sweep_year:
     - 2030
     EEG_levels:
     - 1.00
     # - 0.95
     # - 0.90
-    - 0.85
+    # - 0.85
     # - 0.80
     # - 0.75
     - 0.70
@@ -776,7 +776,7 @@ onshore_nep_force:
 offshore_nep_force:
   cutin_year: 2025
   cutout_year: 2030
-  delay_years: 0
+  delay_years: 2
 
 scale_capacity:
   2020:

scripts/pypsa-de/additional_functionality.py

@@ -863,9 +863,27 @@ def additional_functionality(n, snapshots, snakemake):
     try:
         investment_year = int(snakemake.wildcards.planning_horizons[-4:])
     except AttributeError:
-        investment_year = int(snakemake.wildcards.st_years[-4:])
+        investment_year = int(snakemake.wildcards.eeg_sweep_year)
     constraints = snakemake.params.solving["constraints"]
-
+    if snakemake.wildcards.get("eeg_sweep_year"):
+        eeg_sweep_year = int(snakemake.wildcards.eeg_sweep_year)
+        assert eeg_sweep_year == 2030, "EEG sweep implemented only for 2030 "
+        lvl = float(snakemake.wildcards.eeg_level)
+        constraints["limits_capacity_min"]["Generator"]["onwind"]["DE"][
+            eeg_sweep_year
+        ] = constraints["limits_capacity_max"]["Generator"]["onwind"]["DE"][
+            eeg_sweep_year
+        ] = 115 * lvl
+        constraints["limits_capacity_min"]["Generator"]["offwind"]["DE"][
+            eeg_sweep_year
+        ] = constraints["limits_capacity_max"]["Generator"]["offwind"]["DE"][
+            eeg_sweep_year
+        ] = 30 * lvl
+        constraints["limits_capacity_min"]["Generator"]["solar"]["DE"][
+            eeg_sweep_year
+        ] = constraints["limits_capacity_max"]["Generator"]["solar"]["DE"][
+            eeg_sweep_year
+        ] = 215 * lvl
     if not snakemake.params.get("regret_run"):
         add_capacity_limits(
             n, investment_year, constraints["limits_capacity_min"], snakemake, "minimum"

scripts/pypsa-de/export_ariadne_variables.py

@@ -5542,10 +5542,12 @@ def get_data(
 
     # Load data
     _networks = [pypsa.Network(fn) for fn in snakemake.input.networks]
-    if snakemake.input.st_low_res_networks:
-        _networks_st = [pypsa.Network(fn) for fn in snakemake.input.st_low_res_networks]
-        N_st = len(_networks_st)
-        _networks[-N_st:] = _networks_st
+    if snakemake.input.eeg_sweep_networks:
+        _sweep_networks = [
+            pypsa.Network(fn) for fn in snakemake.input.eeg_sweep_networks
+        ]
+        N_st = len(_sweep_networks)
+        _networks[-N_st:] = _sweep_networks
 
     nhours = _networks[0].snapshot_weightings.generators.sum()
     nyears = nhours / 8760

scripts/pypsa-de/prepare_st_low_res_network.py

@@ -126,7 +126,7 @@ def fix_capacities(n_lt, no_flex=False):
             clusters=27,
             opts="",
             sector_opts="none",
-            st_years="2030",
+            eeg_sweep_year="2030",
             run="HighDemand",
             eeg_level=0.7,
         )
@@ -138,7 +138,7 @@ def fix_capacities(n_lt, no_flex=False):
     update_config_from_wildcards(snakemake.config, snakemake.wildcards)
 
     n_lt = pypsa.Network(snakemake.input.network)
-    st_years = snakemake.wildcards.get("st_years", None)
+    eeg_sweep_year = snakemake.wildcards.get("eeg_sweep_year", None)
     logging_frequency = snakemake.config.get("solving", {}).get(
         "mem_logging_frequency", 30
     )
@@ -155,7 +155,7 @@ def fix_capacities(n_lt, no_flex=False):
     n = fix_capacities(n_lt, snakemake.params.get("no_flex_lt_run", False))
 
     scale_new_res_to_target(
-        n, eeg_targets, int(st_years), ratio=float(snakemake.wildcards.eeg_level)
+        n, eeg_targets, int(eeg_sweep_year), ratio=float(snakemake.wildcards.eeg_level)
     )
 
     if h2_vent:
@@ -207,7 +207,7 @@ def fix_capacities(n_lt, no_flex=False):
         n,
         solve_opts=snakemake.params.solving["options"],
         foresight=snakemake.params.foresight,
-        planning_horizons=st_years,
+        planning_horizons=eeg_sweep_year,
         co2_sequestration_potential=snakemake.params["co2_sequestration_potential"],
         limit_max_growth=snakemake.params.get("sector", {}).get("limit_max_growth"),
         regret_run=True,
@@ -223,7 +223,7 @@ def fix_capacities(n_lt, no_flex=False):
         p_max_pu=0,
         p_nom_extendable=True,
         carrier="co2",
-        marginal_cost=-co2_prices[int(st_years)],
+        marginal_cost=-co2_prices[int(eeg_sweep_year)],
     )
     n.global_constraints.drop("CO2Limit", inplace=True)
     n.global_constraints.drop("co2_limit-DE", inplace=True)

scripts/solve_network.py

@@ -1457,7 +1457,9 @@ def solve_network(
     np.random.seed(solve_opts.get("seed", 123))
 
     n = pypsa.Network(snakemake.input.network)
-    planning_horizons = snakemake.wildcards.get("planning_horizons", None)
+    planning_horizons = snakemake.wildcards.get(
+        "planning_horizons", snakemake.wildcards.get("eeg_sweep_year", None)
+    )
 
     prepare_network(
         n,