Edisgo run edisgo

edisgo/edisgo.py

@@ -243,6 +243,33 @@ def config(self):
     def config(self, kwargs):
         self._config = Config(**kwargs)
 
+    def run_pipeline(self, config, overlying_grid_data=None):
+        """
+        Run a YAML/JSON task pipeline on this EDisGo instance.
+
+        See :mod:`edisgo.run` for the config schema and task list.
+
+        Parameters
+        ----------
+        config : str, :class:`pathlib.Path`, or dict
+            Pipeline config as path to a YAML/JSON file or as a dict.
+        overlying_grid_data : dict, optional
+            Overlying-grid data (e.g. eTraGo results) consumed by the
+            ``import_overlying_grid_data`` task when
+            ``overlying_grid.source == "etrago"``.
+
+        Returns
+        -------
+        :class:`~.EDisGo`
+            The EDisGo instance after the pipeline has run.
+
+        """
+        from edisgo.run import _run_pipeline_on
+
+        return _run_pipeline_on(
+            self, config, overlying_grid_data=overlying_grid_data
+        )
+
     def import_ding0_grid(self, path, legacy_ding0_grids=True):
         """
         Import ding0 topology data from csv files in the format as

edisgo/io/powermodels_io.py

@@ -311,17 +311,20 @@ def from_powermodels(
             ]
         results = pd.DataFrame(index=timesteps, columns=names, data=data)
         if (flex == "gen_nd") & (pm["nw"]["1"]["opf_version"] in [3, 4]):
-            edisgo_object.timeseries._generators_active_power.loc[:, names] = (
+            ti = edisgo_object.timeseries.timeindex
+            edisgo_object.timeseries._generators_active_power.loc[ti, names] = (
                 edisgo_object.timeseries.generators_active_power.loc[:, names].values
                 - results[names].values
             )
         elif flex in ["heatpumps", "electromobility"]:
-            edisgo_object.timeseries._loads_active_power.loc[:, names] = results[
+            ti = edisgo_object.timeseries.timeindex
+            edisgo_object.timeseries._loads_active_power.loc[ti, names] = results[
                 names
             ].values
         elif flex == "dsm":
-            edisgo_object.timeseries._loads_active_power.loc[:, names] = (
-                edisgo_object.timeseries._loads_active_power.loc[:, names].values
+            ti = edisgo_object.timeseries.timeindex
+            edisgo_object.timeseries._loads_active_power.loc[ti, names] = (
+                edisgo_object.timeseries._loads_active_power.loc[ti, names].values
                 + results[names].values
             )
         elif flex == "storage":
@@ -333,8 +336,9 @@ def from_powermodels(
                         data=results[names].values,
                     )
                 else:
+                    ti = edisgo_object.timeseries.timeindex
                     edisgo_object.timeseries._storage_units_active_power.loc[
-                        :, names
+                        ti, names
                     ] = results[names].values
             except AttributeError:
                 setattr(
@@ -366,15 +370,22 @@ def from_powermodels(
         # calculate relative error
         df2 = deepcopy(df)
         for flex in df2.columns:
-            abs_error = abs(df2[flex].values - hv_flex_dict[flex].values)
-            rel_error = [
-                (
+            if type(hv_flex_dict[flex]) == pd.Series:
+                abs_error = abs(df2[flex].values - hv_flex_dict[flex].values)
+                rel_error = [
                     abs_error[i] / hv_flex_dict[flex].iloc[i]
                     if ((abs_error > 0.01)[i] & (hv_flex_dict[flex].iloc[i] != 0))
                     else 0
-                )
-                for i in range(len(abs_error))
-            ]
+                    for i in range(len(abs_error))
+                ]
+            else:
+                abs_error = abs(df2[flex].values - hv_flex_dict[flex].sum(axis=1).values)
+                rel_error = [
+                    abs_error[i] / hv_flex_dict[flex].sum(axis=1).iloc[i]
+                    if ((abs_error > 0.01)[i] & (hv_flex_dict[flex].sum(axis=1).iloc[i] != 0))
+                    else 0
+                    for i in range(len(abs_error))
+                ]
             df2[flex] = rel_error
         # write results to edisgo object
         edisgo_object.opf_results.overlying_grid = pd.DataFrame(
@@ -794,8 +805,8 @@ def _build_branch(edisgo_obj, psa_net, pm, flexible_storage_units, s_base):
             # only modify r, x and l values if min value is too small
             branches[par] = val.clip(lower=min_value)
             logger.warning(
-                f"Min value of {text} is too small. Lowest {100 * quant}% of {text} values will be set "
-                f"to {min_value} {unit}"
+                f"Min value of {text} is too small. Lowest {100 * quant}% of "
+                f"{text} values will be set to {min_value} {unit}"
             )
 
     for branch_i in np.arange(len(branches.index)):
@@ -940,8 +951,8 @@ def _build_load(
             pf, sign = _get_pf(edisgo_obj, pm, idx_bus, "charging_point")
         else:
             logger.warning(
-                f"No type specified for load {loads_df.index[load_i]}. Power factor and sign will"
-                "be set for conventional load."
+                f"No type specified for load {loads_df.index[load_i]}. "
+                "Power factor and sign will be set for conventional load."
             )
             pf, sign = _get_pf(edisgo_obj, pm, idx_bus, "conventional_load")
         p_d = psa_net.loads_t.p_set[loads_df.index[load_i]]
@@ -1018,9 +1029,18 @@ def _build_battery_storage(
     """
     branches = pd.concat([psa_net.lines, psa_net.transformers])
     if not edisgo_obj.overlying_grid.storage_units_soc.empty:
+        # Align the SOC series (which may use another year) onto the edisgo
+        # time index plus one end-of-period step. Uses reindex, so a missing
+        # step yields NaN instead of a KeyError.
+        from edisgo.tools.tools import align_series_to_timeindex
+
+        soc_aligned = align_series_to_timeindex(
+            edisgo_obj.overlying_grid.storage_units_soc,
+            edisgo_obj.timeseries.timeindex,
+            extra_step=True,
+        )
         data = pd.concat(
-            [edisgo_obj.overlying_grid.storage_units_soc]
-            * len(edisgo_obj.topology.storage_units_df),
+            [soc_aligned] * len(edisgo_obj.topology.storage_units_df),
             axis=1,
         ).values
     else:
@@ -1226,9 +1246,10 @@ def _build_heatpump(psa_net, pm, edisgo_obj, s_base, flexible_hps):
     comparison = (heat_df2[hp_p_nom.index] > hp_cop * hp_p_nom.squeeze()).any()
     if comparison.any():
         logger.warning(
-            "Heat demand is higher than rated heatpump power"
-            f" of heatpumps: {comparison.index[comparison.values].values}. Demand can not be covered if no sufficient"
-            " heat storage capacities are available."
+            "Heat demand is higher than rated heatpump power of heatpumps: "
+            f"{comparison.index[comparison.values].values}. "
+            "Demand can not be covered if no sufficient heat storage "
+            "capacities are available."
         )
     for hp_i in np.arange(len(heat_df.index)):
         idx_bus = _mapping(psa_net, edisgo_obj, heat_df.bus.iloc[hp_i])
@@ -1595,11 +1616,18 @@ def _build_hv_requirements(
     )
 
     for i in np.arange(len(opf_flex)):
-        pm["HV_requirements"][str(i + 1)] = {
-            "P": hv_flex_dict[opf_flex[i]].iloc[0],
-            "name": opf_flex[i],
-            "count": count,
-        }
+        if type(hv_flex_dict[opf_flex[i]]) == pd.DataFrame:
+            pm["HV_requirements"][str(i + 1)] = {
+                "P": hv_flex_dict[opf_flex[i]].sum(axis=1).iloc[0],
+                "name": opf_flex[i],
+                "count": count,
+            }
+        else:
+            pm["HV_requirements"][str(i + 1)] = {
+                "P": hv_flex_dict[opf_flex[i]].iloc[0],
+                "name": opf_flex[i],
+                "count": count,
+            }
 
 
 def _build_timeseries(
@@ -1929,9 +1957,14 @@ def _build_component_timeseries(
 
     if (kind == "HV_requirements") & (pm["opf_version"] in [3, 4]):
         for i in np.arange(len(opf_flex)):
-            pm_comp[(str(i + 1))] = {
-                "P": hv_flex_dict[opf_flex[i]].round(20).tolist(),
-            }
+            if type(hv_flex_dict[opf_flex[i]])==pd.DataFrame:
+                pm_comp[(str(i + 1))] = {
+                    "P": hv_flex_dict[opf_flex[i]].sum(axis=1).round(20).tolist(),
+                }
+            else:
+                pm_comp[(str(i + 1))] = {
+                    "P": hv_flex_dict[opf_flex[i]].round(20).tolist(),
+                }
 
     pm["time_series"][kind] = pm_comp
 

edisgo/network/overlying_grid.py

@@ -95,6 +95,17 @@ def __init__(self, **kwargs):
             "feedin_district_heating", pd.DataFrame(dtype="float64")
         )
 
+        self.dispatchable_generators_active_power = kwargs.get(
+            "dispatchable_generators_active_power", pd.DataFrame(dtype="float64")
+        )
+
+        self.dispatchable_generators_reactive_power = kwargs.get(
+            "dispatchable_generators_reactive_power", pd.DataFrame(dtype="float64")
+        )
+
+        self.renewables_potential = kwargs.get(
+            "renewables_potential", pd.Series(dtype="float64")
+        )
     @property
     def _attributes(self):
         return [
@@ -108,6 +119,9 @@ def _attributes(self):
             "heat_pump_central_active_power",
             "thermal_storage_units_central_soc",
             "feedin_district_heating",
+            "dispatchable_generators_active_power",
+            "dispatchable_generators_reactive_power",
+            "renewables_potential",
         ]
 
     def reduce_memory(self, attr_to_reduce=None, to_type="float32"):

edisgo/run/__init__.py

@@ -0,0 +1,31 @@
+"""
+YAML/JSON-driven pipeline runner for eDisGo.
+
+Two entry points share the same core:
+
+    from edisgo.run import run_edisgo
+    edisgo = run_edisgo("presets/uc2_flex_opf.yaml")
+
+    # or, on an existing EDisGo instance:
+    edisgo = EDisGo(ding0_grid="30879")
+    edisgo.run_pipeline("my_run.yaml")
+
+Pipelines are lists of named tasks from :mod:`edisgo.run.tasks`. Each step
+is either a string (``worst_case_ts``) or a single-key mapping with
+parameters (``import_electromobility: {charging_strategy: dumb}``). Tasks
+can be grouped into ordered ``stages`` that can save artifacts and reload
+them with ``load_from``, enabling two-phase workflows (base reinforce +
+per-scenario reinforce).
+"""
+
+from edisgo.run.context import RunContext
+from edisgo.run.registry import known_tasks, register_task
+from edisgo.run.runner import _run_pipeline_on, run_edisgo
+
+__all__ = [
+    "RunContext",
+    "_run_pipeline_on",
+    "known_tasks",
+    "register_task",
+    "run_edisgo",
+]