feat: introduce offshore wind hubs topology

Snakefile

@@ -79,46 +79,42 @@ if config["foresight"] == "perfect":
 
 def input_all_tyndp(w):
     files = []
-    files.extend(
-        expand(
-            (
-                resources(
-                    "maps/base_h2_network_{clusters}_{opts}_{sector_opts}_{planning_horizons}.pdf"
-                )
-                if config_provider("sector", "H2_network")(w)
-                else []
-            ),
-            run=config["run"]["name"],
-            **config["scenario"],
+    if config_provider("sector", "H2_network")(w):
+        files.extend(
+            expand(
+                (
+                    resources(
+                        "maps/base_h2_network_{clusters}_{opts}_{sector_opts}_{planning_horizons}.pdf"
+                    )
+                ),
+                run=config["run"]["name"],
+                **config["scenario"],
+            )
         )
-    )
-    files.extend(
-        expand(
-            (
-                resources(
-                    "maps/base_offshore_network_{clusters}_{opts}_{sector_opts}_{planning_horizons}_{carrier}.pdf"
-                )
-                if config_provider("sector", "offshore_hubs_tyndp", "enable")(w)
-                else []
-            ),
-            run=config["run"]["name"],
-            **config["scenario"],
-            carrier=config_provider("plotting", "offshore_maps", "bus_carriers")(w),
+    if config_provider("sector", "offshore_hubs_tyndp", "enable")(w):
+        files.extend(
+            expand(
+                (
+                    resources(
+                        "maps/base_offshore_network_{clusters}_{opts}_{sector_opts}_{planning_horizons}_{carrier}.pdf"
+                    )
+                ),
+                run=config["run"]["name"],
+                **config["scenario"],
+                carrier=config_provider("plotting", "offshore_maps", "bus_carriers")(w),
+            )
         )
-    )
-    files.extend(
-        expand(
-            (
-                RESULTS
-                + "maps/base_s_{clusters}_{opts}_{sector_opts}_{planning_horizons}-offshore_network_{carrier}.pdf"
-                if config_provider("sector", "offshore_hubs_tyndp", "enable")(w)
-                else []
-            ),
-            run=config["run"]["name"],
-            **config["scenario"],
-            carrier=config_provider("plotting", "offshore_maps", "bus_carriers")(w),
+        files.extend(
+            expand(
+                (
+                    RESULTS
+                    + "maps/base_s_{clusters}_{opts}_{sector_opts}_{planning_horizons}-offshore_network_{carrier}.pdf"
+                ),
+                run=config["run"]["name"],
+                **config["scenario"],
+                carrier=config_provider("plotting", "offshore_maps", "bus_carriers")(w),
+            )
         )
-    )
     return files
 
 

config/config.tyndp.yaml

@@ -161,6 +161,8 @@ costs:
       HVDC submarine: 25
       H2 (g) submarine pipeline: 25
       offwind: 25
+    efficiency:
+      electrolysis: 0.68  # ToDo Account for time-varying efficiencies, currently using fixed 2020 value from TYNDP 2024
 
 clustering:
   mode: administrative

config/test/config.tyndp.yaml

@@ -187,6 +187,8 @@ costs:
       HVDC submarine: 25
       H2 (g) submarine pipeline: 25
       offwind: 25
+    efficiency:
+      electrolysis: 0.68  # ToDo Account for time-varying efficiencies, currently using fixed 2020 value from TYNDP 2024
 
 clustering:
   mode: administrative

rules/build_sector.smk

@@ -1291,18 +1291,6 @@ def input_heat_source_power(w):
     }
 
 
-def input_offshore_hubs(w):
-    offshore_files = [
-        "offshore_buses",
-        "offshore_grid",
-        "offshore_electrolysers",
-        "offshore_generators",
-    ]
-    if config_provider("sector", "offshore_hubs_tyndp", "enable")(w):
-        return {f: resources(f"{f}.csv") for f in offshore_files}
-    return {f: [] for f in offshore_files}
-
-
 if config["sector"]["h2_topology_tyndp"]:
 
     rule build_tyndp_h2_network:
@@ -1398,6 +1386,18 @@ if config["sector"]["offshore_hubs_tyndp"]["enable"]:
             "../scripts/build_tyndp_offshore_hubs.py"
 
 
+def input_offshore_hubs(w):
+    offshore_files = [
+        "offshore_buses",
+        "offshore_grid",
+        "offshore_electrolysers",
+        "offshore_generators",
+    ]
+    if config_provider("sector", "offshore_hubs_tyndp", "enable")(w):
+        return {f: resources(f"{f}.csv") for f in offshore_files}
+    return {}
+
+
 rule prepare_sector_network:
     params:
         time_resolution=config_provider("clustering", "temporal", "resolution_sector"),

scripts/add_brownfield.py

@@ -118,6 +118,7 @@ def add_brownfield(
     # hydrogen- and electricity-generating wind farms share the same potential; values are adjusted accordingly
     if offshore_hubs_tyndp:
         filter = {"Link": "Offshore", "Generator": "offwind"}
+        eff_map = {"Link": "efficiency", "Generator": "efficiency_dc_to_h2"}
         for c in n.iterate_components(["Link", "Generator"]):
             off_fixed_i = c.df[
                 (c.df.index.str.contains(filter[c.name])) & (c.df.build_year != year)
@@ -128,15 +129,30 @@ def add_brownfield(
 
             off_capacity = c.df.loc[off_i, "p_nom"]
             off_potential = c.df.loc[off_i, "p_nom_max"]
+
+            # Determine existing capacities in MW_e and MW_h2
             already_existing = (
-                c.df.loc[off_fixed_i, "p_nom_opt"]
-                .rename(lambda x: x.split("-2")[0] + f"-{year}")
+                c.df.loc[off_fixed_i]
+                .assign(
+                    p_nom_opt_e=lambda df: np.where(
+                        df.carrier.str.contains("h2"),
+                        df.p_nom_opt.div(df[eff_map[c.name]]),
+                        df.p_nom_opt,
+                    ),
+                    p_nom_opt_h2=lambda df: np.where(
+                        ~df.carrier.str.contains("h2"),
+                        df.p_nom_opt.mul(df[eff_map[c.name]]),
+                        df.p_nom_opt,
+                    ),
+                )
+                .rename(lambda x: x.split("-2")[0] + f"-{year}")[
+                    ["p_nom_opt", "p_nom_opt_e", "p_nom_opt_h2"]
+                ]
                 .groupby(level=0)
                 .sum()
             )
 
             # account for the shared potential of hydrogen- and electricity-generating wind farms
-            already_existing_l = already_existing.copy()
             if c.name == "Generator":
                 h2_gens = already_existing.loc[
                     already_existing.index.str.contains("h2")
@@ -145,43 +161,25 @@ def add_brownfield(
                     already_existing.index.str.contains("dc.*oh")
                 ]
 
-                off_h2_gens = n.generators.loc[h2_gens.index]
-                off_dc_gens = n.generators.loc[dc_gens.index]
-                off_electrolysers = n.links.loc[
-                    (n.links.index.str.contains("Offshore Electrolysis"))
-                    & (n.links.build_year == year)
-                ].set_index("bus1")
-                # ToDo Account for time-varying efficiencies across planning horizons
-                eff_h2 = (
-                    off_electrolysers.loc[off_h2_gens.bus]
-                    .set_index(h2_gens.index)
-                    .efficiency
-                )
-                eff_dc = (
-                    off_electrolysers.loc[off_dc_gens.bus + " H2"]
-                    .set_index(dc_gens.index)
-                    .efficiency
-                )
-
-                h2_to_dc = h2_gens.div(eff_h2).rename(
+                h2_to_dc = h2_gens.p_nom_opt_e.rename(
                     index=lambda x: x.replace("h2", "dc")
-                )
-                dc_to_h2 = dc_gens.mul(eff_dc).rename(
+                ).rename("p_nom_opt")
+                dc_to_h2 = dc_gens.p_nom_opt_h2.rename(
                     index=lambda x: x.replace("dc", "h2")
-                )
+                ).rename("p_nom_opt")
 
                 already_existing_l = (
-                    pd.concat([already_existing, h2_to_dc, dc_to_h2])
+                    pd.concat([already_existing.p_nom_opt, h2_to_dc, dc_to_h2])
                     .groupby(level=0)
                     .sum()
                 )
             else:
-                already_existing_l = already_existing_l.p_nom_opt
+                already_existing_l = already_existing.p_nom_opt
 
             # values should be non-negative; clipping applied to handle rounding errors
             remaining_capacity = (
                 off_capacity
-                - already_existing.reindex(index=off_capacity.index).fillna(0)
+                - already_existing.p_nom_opt.reindex(index=off_capacity.index).fillna(0)
             ).clip(lower=0)
             remaining_potential = (
                 off_potential

scripts/prepare_sector_network.py

@@ -80,7 +80,7 @@ def define_spatial(nodes, options, offshore_buses_fn=None, buses_h2_file=None):
 
     # offshore hubs
 
-    if options.get("offshore_hubs_tyndp") and offshore_buses_fn:
+    if options["offshore_hubs_tyndp"]["enable"] and offshore_buses_fn:
         spatial.offshore_hubs = SimpleNamespace()
         offshore_buses = pd.read_csv(offshore_buses_fn, index_col=0)
         offshore_buses_h2 = offshore_buses.set_index(offshore_buses.index + " H2")
@@ -3067,6 +3067,11 @@ def add_offshore_generators_tyndp(
 
     # Adjust capacities and costs to account for efficiency
     h2_idx = offshore_generators.filter(like="h2", axis=0).index
+    offshore_generators["efficiency"] = np.where(
+        offshore_generators["carrier"].str.contains("h2"),
+        costs.at["electrolysis", "efficiency"],
+        1.0,
+    )
     offshore_generators.loc[h2_idx, ["p_nom_min", "p_nom_max"]] *= costs.at[
         "electrolysis", "efficiency"
     ]
@@ -3117,7 +3122,8 @@ def add_offshore_generators_tyndp(
         p_nom_extendable=offshore_generators.p_nom_extendable,
         capital_cost=offshore_generators.capital_cost,
         marginal_cost=costs.at["offwind", "marginal_cost"],
-        efficiency=costs.at["offwind", "efficiency"],
+        efficiency_dc_to_b0=offshore_generators.efficiency,
+        efficiency_dc_to_h2=costs.at["electrolysis", "efficiency"],
         p_max_pu=p_max_pu,
         lifetime=costs.at["offwind", "lifetime"],
     )
@@ -7521,10 +7527,15 @@ def add_import_options(
     heating_efficiencies = pd.read_csv(fn, index_col=[1, 0]).loc[year]
 
     buses_h2_file = snakemake.input.buses_h2 if options["h2_topology_tyndp"] else None
+    buses_oh_file = (
+        snakemake.input.offshore_buses
+        if options["offshore_hubs_tyndp"]["enable"]
+        else None
+    )
     spatial = define_spatial(
         pop_layout.index,
         options,
-        offshore_buses_fn=snakemake.input.offshore_buses,
+        offshore_buses_fn=buses_oh_file,
         buses_h2_file=buses_h2_file,
     )
 

scripts/solve_network.py

@@ -1172,15 +1172,12 @@ def add_offshore_hubs_constraint(
     h2_gens = gens.loc[(h2_i) & (ext_i)]
     h2_gens_i = h2_gens.index
     dc_gens_i = h2_gens_i.str.replace("h2", "dc").str.replace(" H2", "")
-
-    off_electrolysers = n.links.loc[
-        (n.links.index.str.contains("Offshore Electrolysis"))
-        & (n.links.build_year == planning_horizons)
-    ].set_index("bus1")
-    eff_l = off_electrolysers.loc[h2_gens.bus].set_index(h2_gens_i).efficiency
     p_nom = n.model["Generator-p_nom"]
 
-    lhs = p_nom.loc[dc_gens_i] + p_nom.loc[h2_gens_i] / eff_l
+    lhs = (
+        p_nom.loc[dc_gens_i]
+        + p_nom.loc[h2_gens_i] / h2_gens.loc[h2_gens_i, "efficiency_dc_to_b0"]
+    )
     rhs = gens.loc[dc_gens_i].p_nom_max
 
     if not lhs.empty:
@@ -1198,22 +1195,22 @@ def add_offshore_hubs_constraint(
     off_gens_i = gens.loc[(off_i) & (ext_i)].index
     grouper_ext = gens.loc[off_gens_i].zone.rename("Generator-ext")
     idx = pd.Index(set(limit.index).intersection(grouper_ext))
-    eff_z = eff_l.reindex(off_gens_i, fill_value=1)
+    eff_z = gens["efficiency_dc_to_b0"].reindex(off_gens_i)
     lhs = (p_nom.loc[off_gens_i] / eff_z).groupby(grouper_ext).sum().loc[idx]
 
-    # ToDo Account for time-varying efficiencies across planning horizons
-    existing_z = (
-        gens.loc[(off_i) & ~(ext_i), "p_nom"]
-        .rename(lambda x: x.split("-2")[0] + f"-{planning_horizons}")
-        .groupby(level=0)
-        .sum()
-    )
-    grouper_z = gens.loc[existing_z.index].zone
     existing_z = (
-        (existing_z / eff_z.loc[existing_z.index])
-        .groupby(grouper_z)
+        gens.loc[(off_i) & ~(ext_i)]
+        .assign(
+            p_nom=lambda df: np.where(
+                df.carrier.str.contains("h2"),
+                df.p_nom.div(df.efficiency_dc_to_h2),
+                df.p_nom,
+            )
+        )
+        .rename(lambda x: x.split("-2")[0] + f"-{planning_horizons}")[["p_nom", "zone"]]
+        .groupby(by="zone")
         .sum()
-        .reindex(idx, fill_value=0)
+        .reindex(idx, fill_value=0)["p_nom"]
     )
     rhs = limit.loc[idx] - existing_z