Bugfix discretized line capacity (#280)

* improve processing of postnetworks, fix missing trassenlänge

* remove duplicate line

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* improve robustness of trassenlänge division

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* divide instead of multiply

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: lindnemi

config/config.yaml

@@ -409,7 +409,7 @@ solving:
     max_iterations: 1 # settings for post-discretization: 1
     post_discretization:
       enable: false
-      line_unit_size: 1700
+      line_unit_size: 1698
       line_threshold: 0.3
       link_unit_size:
         DC: 1000

workflow/scripts/additional_functionality.py

@@ -234,7 +234,7 @@ def h2_production_limits(n, investment_year, limits_volume_min, limits_volume_ma
         efficiency = n.links.loc[production, "efficiency"]
 
         lhs = (
-            n.model["Link-p"].loc[:, production] 
+            n.model["Link-p"].loc[:, production]
             * n.snapshot_weightings.generators
             * efficiency
         ).sum()
@@ -662,6 +662,7 @@ def adapt_nuclear_output(n):
         carrier_attribute="",
     )
 
+
 def additional_functionality(n, snapshots, snakemake):
 
     logger.info("Adding Ariadne-specific functionality")

workflow/scripts/build_wasserstoff_kernnetz.py

@@ -365,7 +365,6 @@ def assign_locations(df, locations):
 
     # calc length of points
     length_factor = 1.0
-    length_factor = 1.0
     df["length_haversine"] = df.apply(
         lambda p: length_factor
         * haversine_pts([p.point0.x, p.point0.y], [p.point1.x, p.point1.y]),

workflow/scripts/export_ariadne_variables.py

@@ -4425,11 +4425,13 @@ def get_grid_capacity(n, region, year):
     ] *= 0.5
 
     # NEP subsets
+    current_year = n.generators.build_year.max()
     nep_dc = dc_links.query(
-        "index.str.startswith('DC') or index=='TYNDP2020_1' or index=='TYNDP2020_2' or index=='TYNDP2020_23'"
+        "(index.str.startswith('DC') or index.str.startswith('TYNDP')) and build_year > 2025 and (@current_year - 5 < build_year <= @current_year)"
+    ).index
+    nep_ac = ac_lines.query(
+        "(build_year > 2025) and (@current_year - 5 < build_year <= @current_year)"
     ).index
-    nep_ac = ac_lines.query("build_year > 2000").index
-
     var["Capacity|Electricity|Transmission|DC"] = (
         dc_links.eval("p_nom_opt * length").sum() * MW2GW
     )
@@ -4448,15 +4450,15 @@ def get_grid_capacity(n, region, year):
             snakemake.params.post_discretization["link_unit_size"]["DC"]
             - 5  # To account for numerical errors subtract a small capacity
         )
-        .multiply(snakemake.params.post_discretization["link_unit_size"]["DC"] / 2000)
+        .div(2000 // (snakemake.params.post_discretization["link_unit_size"]["DC"] - 5))
         .multiply(dc_links.length)
         .sum()
     )
     var["Length Additions|Electricity|Transmission|DC|NEP"] = (
         dc_links.loc[nep_dc]
         .eval("p_nom_opt - p_nom_min")
         .floordiv(snakemake.params.post_discretization["link_unit_size"]["DC"] - 5)
-        .multiply(snakemake.params.post_discretization["link_unit_size"]["DC"] / 2000)
+        .div(2000 // (snakemake.params.post_discretization["link_unit_size"]["DC"] - 5))
         .multiply(dc_links.length)
         .sum()
     )
@@ -4474,18 +4476,18 @@ def get_grid_capacity(n, region, year):
     )
     var["Length Additions|Electricity|Transmission|AC"] = (
         ac_lines.eval("s_nom_opt - s_nom_min")
-        .floordiv(snakemake.params.post_discretization["line_unit_size"] - 5)
-        .mul(
-            snakemake.params.post_discretization["line_unit_size"] / (2 * 2633)
-        )  # Trassen size is 2 * 2633, we allow "fractional Trassen" to account for different line types
+        .floordiv(
+            snakemake.params.post_discretization["line_unit_size"] - 5
+        )  # To account for numerical errors subtract a small capacity
+        .div(5265 // (snakemake.params.post_discretization["line_unit_size"] - 5))
         .multiply(ac_lines.length)
         .sum()
     )
     var["Length Additions|Electricity|Transmission|AC|NEP"] = (
         ac_lines.loc[nep_ac]
         .eval("s_nom_opt - s_nom_min")
         .floordiv(snakemake.params.post_discretization["line_unit_size"] - 5)
-        .mul(snakemake.params.post_discretization["line_unit_size"] / (2 * 2633))
+        .div(5265 // (snakemake.params.post_discretization["line_unit_size"] - 5))
         .multiply(ac_lines.length)
         .sum()
     )
@@ -4530,7 +4532,7 @@ def get_grid_capacity(n, region, year):
     return var
 
 
-def hack_DC_projects(n, n_start, model_year, snakemake, costs):
+def hack_DC_projects(n, p_nom_start, p_nom_planned, model_year, snakemake, costs):
 
     logger.info(f"Hacking DC projects for year {model_year}")
 
@@ -4548,30 +4550,10 @@ def hack_DC_projects(n, n_start, model_year, snakemake, costs):
     ]
     past_projects = tprojs[n.links.loc[tprojs, "build_year"] <= (model_year - 5)]
 
-    logger.info("Post-Discretizing DC projects")
-
-    p_nom_start = n_start.links.loc[current_projects, "p_nom"].apply(
-        lambda x: get_discretized_value(
-            x,
-            snakemake.params.post_discretization["link_unit_size"]["DC"],
-            snakemake.params.post_discretization["link_threshold"]["DC"],
-        )
-    )
-
-    # The values  in p_nom_opt may already be discretized, here we make sure that
-    # the same logic is applied to p_nom and p_nom_min
-    for attr in ["p_nom_opt", "p_nom", "p_nom_min"]:
-        n.links.loc[tprojs, attr] = n.links.loc[tprojs, attr].apply(
-            lambda x: get_discretized_value(
-                x,
-                snakemake.params.post_discretization["link_unit_size"]["DC"],
-                snakemake.params.post_discretization["link_threshold"]["DC"],
-            )
-        )
     for proj in tprojs:
-        if not isclose(n.links.loc[proj, "p_nom"], n_start.links.loc[proj, "p_nom"]):
+        if not isclose(n.links.loc[proj, "p_nom"], p_nom_planned[proj]):
             logger.warning(
-                f"Changed p_nom of {proj} from {n_start.links.loc[proj, 'p_nom']} to {n.links.loc[proj, 'p_nom']}"
+                f"(Post-)discretization changed p_nom of {proj} from {p_nom_planned[proj]} to {n.links.loc[proj, 'p_nom']}"
             )
 
     # Future projects should not have any capacity
@@ -4587,7 +4569,7 @@ def hack_DC_projects(n, n_start, model_year, snakemake, costs):
     if (snakemake.params.NEP_year == 2021) or (
         snakemake.params.NEP_transmission == "overhead"
     ):
-        logger.warning("Switching DC projects to NEP23 costs post-optimization")
+        logger.warning("Switching DC projects to NEP23 and underground costs.")
         n.links.loc[current_projects, "overnight_cost"] = (
             n.links.loc[current_projects, "length"]
             * (
@@ -4601,22 +4583,23 @@ def hack_DC_projects(n, n_start, model_year, snakemake, costs):
             + costs[0].at["HVDC inverter pair", "investment"] / 1e-9
         )
     # Current projects should have their p_nom_opt bigger or equal to p_nom until the year 2030 (Startnetz that we force in)
+    # TODO 2030 is hard coded but should be read from snakemake config
     if model_year <= 2030:
         assert (
             n.links.loc[current_projects, "p_nom_opt"] + 0.1
             >= n.links.loc[current_projects, "p_nom"]
         ).all()
 
-        n.links.loc[current_projects, "p_nom"] -= p_nom_start
-        n.links.loc[current_projects, "p_nom_min"] -= p_nom_start
+        n.links.loc[current_projects, "p_nom"] -= p_nom_start[current_projects]
+        n.links.loc[current_projects, "p_nom_min"] -= p_nom_start[current_projects]
 
     else:
         n.links.loc[current_projects, "p_nom"] = n.links.loc[
             current_projects, "p_nom_min"
         ]
 
     # Past projects should have their p_nom_opt bigger or equal to p_nom
-    if model_year <= 2035:
+    if model_year <= 2030 + 5:
         assert (
             n.links.loc[past_projects, "p_nom_opt"] + 0.1  # numerical error tolerance
             >= n.links.loc[past_projects, "p_nom"]
@@ -4625,53 +4608,58 @@ def hack_DC_projects(n, n_start, model_year, snakemake, costs):
     return n
 
 
-def hack_AC_projects(n, n_start, model_year, snakemake):
+def hack_AC_projects(n, s_nom_start, model_year, snakemake):
     logger.info(f"Hacking AC projects for year {model_year}")
 
-    # All transmission projects have build_year > 0, this is implicit in the query
-    ac_projs = n.lines.query("build_year > 0").index
     current_projects = n.lines.query(
         "@model_year - 5 < build_year <= @model_year"
     ).index
 
-    logger.info("Post-Discretizing AC projects")
-
-    for attr in ["s_nom_opt", "s_nom", "s_nom_min"]:
-        # The values  in s_nom_opt may already be discretized, here we make sure that
-        # the same logic is applied to s_nom and s_nom_min
-        n.lines.loc[ac_projs, attr] = n.lines.loc[ac_projs, attr].apply(
-            lambda x: get_discretized_value(
-                x,
-                snakemake.params.post_discretization["line_unit_size"],
-                snakemake.params.post_discretization["line_threshold"],
-            )
-        )
-
-    s_nom_start = n_start.lines.loc[current_projects, "s_nom"].apply(
-        lambda x: get_discretized_value(
-            x,
-            snakemake.params.post_discretization["line_unit_size"],
-            snakemake.params.post_discretization["line_threshold"],
-        )
-    )
-
     if snakemake.params.NEP_year == 2021:
         logger.warning("Switching AC projects to NEP23 costs post-optimization")
         n.lines.loc[current_projects, "overnight_cost"] *= 772 / 472
 
     # Eventhough the lines are available to the model from the start,
-    # we pretend that the lines were in expanded in this year
+    # we pretend that the lines were expanded in the current year
     # s_nom_start is used, because the model may expand lines
     # endogenously before that or after that
-    n.lines.loc[current_projects, "s_nom"] -= s_nom_start
-    n.lines.loc[current_projects, "s_nom_min"] -= s_nom_start
+    n.lines.loc[current_projects, "s_nom"] -= s_nom_start[current_projects]
+    n.lines.loc[current_projects, "s_nom_min"] -= s_nom_start[current_projects]
 
     return n
 
 
-def hack_transmission_projects(n, n_start, model_year, snakemake, costs):
-    n = hack_DC_projects(n, n_start, model_year, snakemake, costs)
-    n = hack_AC_projects(n, n_start, model_year, snakemake)
+def process_postnetworks(n, n_start, model_year, snakemake, costs):
+
+    logger.info("Post-Discretizing DC links")
+    _dc_lambda = lambda x: get_discretized_value(
+        x,
+        snakemake.params.post_discretization["link_unit_size"]["DC"],
+        snakemake.params.post_discretization["link_threshold"]["DC"],
+    )
+    for attr in ["p_nom_opt", "p_nom", "p_nom_min"]:
+        # The values  in p_nom_opt may already be discretized, here we make sure that
+        # the same logic is applied to p_nom and p_nom_min
+        n.links[attr] = n.links[attr].apply(_dc_lambda)
+
+    p_nom_planned = n_start.links["p_nom"]
+    p_nom_start = n_start.links["p_nom"].apply(_dc_lambda)
+
+    logger.info("Post-Discretizing AC lines")
+    _ac_lambda = lambda x: get_discretized_value(
+        x,
+        snakemake.params.post_discretization["line_unit_size"],
+        snakemake.params.post_discretization["line_threshold"],
+    )
+    for attr in ["s_nom_opt", "s_nom", "s_nom_min"]:
+        # The values  in s_nom_opt may already be discretized, here we make sure that
+        # the same logic is applied to s_nom and s_nom_min
+        n.lines[attr] = n.lines[attr].apply(_ac_lambda)
+
+    s_nom_start = n_start.lines["s_nom"].apply(_ac_lambda)
+
+    n = hack_DC_projects(n, p_nom_start, p_nom_planned, model_year, snakemake, costs)
+    n = hack_AC_projects(n, s_nom_start, model_year, snakemake)
     return n
 
 
@@ -4878,7 +4866,7 @@ def get_data(
     modelyears = [fn[-7:-3] for fn in snakemake.input.networks]
     # Hack the transmission projects
     networks = [
-        hack_transmission_projects(n.copy(), _networks[0], int(my), snakemake, costs)
+        process_postnetworks(n.copy(), _networks[0], int(my), snakemake, costs)
         for n, my in zip(_networks, modelyears)
     ]
 

workflow/scripts/plot_ariadne_report.py

@@ -21,7 +21,7 @@
 path = "../submodules/pypsa-eur/scripts"
 sys.path.insert(1, os.path.abspath(path))
 from _helpers import configure_logging, set_scenario_config
-from export_ariadne_variables import get_discretized_value, hack_transmission_projects
+from export_ariadne_variables import get_discretized_value, process_postnetworks
 from plot_power_network import load_projection
 from plot_summary import preferred_order, rename_techs
 from prepare_sector_network import prepare_costs
@@ -1501,7 +1501,7 @@ def plot_elec_map_de(
 
     # Hack the transmission projects
     networks = [
-        hack_transmission_projects(n.copy(), _networks[0], int(my), snakemake, costs)
+        process_postnetworks(n.copy(), _networks[0], int(my), snakemake, costs)
         for n, my in zip(_networks, modelyears)
     ]