Fixing flex result handling

Author: sebastian-peter

pypsdm/models/enums.py

@@ -39,6 +39,7 @@ def get_plot_name(self):
 
     def get_result_type(self) -> type[TimeSeries]:
         # locally to avoid circular imports
+        from pypsdm import FlexOption
         from pypsdm.models.result.grid.connector import ConnectorCurrent
         from pypsdm.models.result.grid.switch import SwitchResult
         from pypsdm.models.result.grid.transformer import Transformer2WResult
@@ -47,7 +48,6 @@ def get_result_type(self) -> type[TimeSeries]:
             ComplexPowerWithSoc,
             ComplexVoltage,
         )
-        from pypsdm import FlexOption
 
         if isinstance(self, SystemParticipantsEnum):
             if self.has_soc():

pypsdm/models/result/container/participants.py

@@ -83,14 +83,14 @@ def __add__(self, other: "SystemParticipantsResultContainer"):
     def p(self) -> DataFrame:
         p_series = {
             participants.entity_type().value: participants.p_sum()  # type: ignore
-            for participants in self.to_list(include_flex=False)
+            for participants in self.participants_to_list()
         }
         return pd.DataFrame(p_series).sort_index().ffill().fillna(0)
 
     def q(self) -> DataFrame:
         q_series = {
             participants.entity_type().value: participants.q_sum()  # type: ignore
-            for participants in self.to_list(include_flex=False)
+            for participants in self.participants_to_list()
         }
         return pd.DataFrame(q_series).sort_index().ffill().fillna(0)
 
@@ -109,31 +109,31 @@ def get_participants(
         return self.to_dict().get(sp_type)
 
     def find_participant_result(self, uuid: str):
-        for participants_res in self.to_list(include_flex=False):
+        for participants_res in self.to_list():
             if uuid in participants_res:
                 return participants_res.get(uuid)
         return ValueError(f"No participant result with uuid: {uuid}")
 
     def energies(self) -> dict[SystemParticipantsEnum, float]:
         return {
             sp_type: res.energy()
-            for sp_type, res in self.to_dict(include_empty=False).items()
+            for sp_type, res in self.participants_to_dict(include_empty=False).items()
             if sp_type != SystemParticipantsEnum.FLEX_OPTIONS
         }
 
     def load_and_generation_energies(self) -> dict[EntitiesEnum, Tuple[float, float]]:
         return {
             sp_type: res.load_and_generation()
-            for sp_type, res in self.to_dict(include_empty=False).items()
+            for sp_type, res in self.participants_to_dict(include_empty=False).items()
         }
 
     def sum(self) -> ComplexPower:
         participant_res = []
-        for participant in self.to_list(include_em=False, include_flex=False):
+        for participant in self.participants_to_list(include_em=False):
             participant_res.append(participant.sum())
         return ComplexPower.sum(participant_res)
 
-    def to_dict(
+    def participants_to_dict(
         self, include_empty: bool = False
     ) -> dict[SystemParticipantsEnum, ComplexPowerDict]:
         dct = {
@@ -146,20 +146,38 @@ def to_dict(
             SystemParticipantsEnum.EV_CHARGING_STATION: self.evcs,
             SystemParticipantsEnum.ELECTRIC_VEHICLE: self.evs,
             SystemParticipantsEnum.HEAT_PUMP: self.hps,
-            SystemParticipantsEnum.FLEX_OPTIONS: self.flex,
         }
         if not include_empty:
             dct = {k: v for k, v in dct.items() if len(v) > 0}
         return dct
 
-    def to_list(
-        self, include_em: bool = True, include_flex=True, include_empty=True
+    def participants_to_list(
+        self, include_em: bool = True, include_empty=True
     ) -> list[ComplexPowerDict]:  # type: ignore
+        dct = self.participants_to_dict(include_empty)
+        if not include_em:
+            del dct[SystemParticipantsEnum.ENERGY_MANAGEMENT]
+        return list(dct.values())
+
+    def to_dict(
+        self, include_empty: bool = False
+    ) -> dict[SystemParticipantsEnum, TimeSeriesDict]:
+        dct: dict[SystemParticipantsEnum, TimeSeriesDict] = self.participants_to_dict(
+            include_empty=True
+        )
+
+        dct[SystemParticipantsEnum.FLEX_OPTIONS] = self.flex
+
+        if not include_empty:
+            dct = {k: v for k, v in dct.items() if len(v) > 0}
+        return dct
+
+    def to_list(
+        self, include_em: bool = True, include_empty=True
+    ) -> list[TimeSeriesDict]:  # type: ignore
         dct = self.to_dict(include_empty)
         if not include_em:
             del dct[SystemParticipantsEnum.ENERGY_MANAGEMENT]
-        if not include_flex:
-            del dct[SystemParticipantsEnum.FLEX_OPTIONS]
         return list(dct.values())
 
     def filter_by_date_time(self, time: Union[datetime, list[datetime]]):
@@ -199,7 +217,7 @@ def concat(
         )
 
     def to_csv(self, path: str, delimiter: str = ",", mkdirs=False):
-        for participant in self.to_list(include_empty=False, include_flex=True):
+        for participant in self.to_list(include_empty=False):
             participant.to_csv(path, delimiter, mkdirs=mkdirs)
 
     @classmethod

pypsdm/plots/results/connector.py

@@ -101,7 +101,7 @@ def ax_plot_transformer_s(
     resolution: Resolution | None = None,
     **kwargs,
 ):
-    if len(res.i_a_mag) == 0:
+    if len(res.data) == 0:
         raise ValueError("Transformer current time series is empty. No data to plot")
 
     rated_power = res.apparent_power(trafo_key, gwr, side).apply(lambda x: np.real(x))

pypsdm/plots/results/power.py

@@ -298,7 +298,7 @@ def plot_aggregated_load_and_generation(
 def plot_all_participants(
     participants: Union[SystemParticipantsResultContainer, list[ComplexPower]],
     title: str,
-    hourly_mean: bool,
+    hourly_mean: bool = False,
     stack=False,
     with_residual=False,
     resolution: Resolution | None = None,
@@ -347,9 +347,7 @@ def _get_complex_power_from_union(
         if isinstance(participants, list)
         else [
             participant.sum()
-            for participant in participants.to_list(
-                include_em=False, include_flex=False
-            )
+            for participant in participants.participants_to_list(include_em=False)
             if participant
         ]
     )

tests/models/result/container/test_participants.py

@@ -1,5 +1,6 @@
 import pandas as pd
 
+from pypsdm import FlexOption
 from pypsdm.models.enums import SystemParticipantsEnum
 from pypsdm.models.result.container.participants import (
     SystemParticipantsResultContainer,
@@ -27,11 +28,33 @@ def get_power_data(with_soc=False):
     return ComplexPower(data)
 
 
-def get_entities_dict(with_soc=False):
+def get_flex_data():
+    data = pd.DataFrame(
+        {
+            TIME_COLUMN_NAME: [
+                "2021-01-01",
+                "2021-01-02",
+                "2021-01-03",
+                "2021-01-04",
+            ],
+            "p_min": [0.0, -1.0, 1.0, 2.0],
+            "p_max": [0.0, 0.0, 2.0, 3.0],
+            "q_ref": [0.0, 1.0, 2.0, 3.0],
+        },
+    )
+    return FlexOption(data)
+
+
+def get_entities_dict(key):
+    if key == SystemParticipantsEnum.FLEX_OPTIONS:
+        data = get_flex_data()
+    else:
+        data = get_power_data(with_soc=key.has_soc())
+
     dct = {
-        EntityKey("a"): get_power_data(with_soc),
-        EntityKey("b"): get_power_data(with_soc),
-        EntityKey("c"): get_power_data(with_soc),
+        EntityKey("a"): data.copy(),
+        EntityKey("b"): data.copy(),
+        EntityKey("c"): data.copy(),
     }
     return dct
 
@@ -40,7 +63,7 @@ def get_container() -> SystemParticipantsResultContainer:
     dcts = {}
     for key in SystemParticipantsResultContainer.entity_keys():
         dict_type = key.get_result_dict_type()
-        dcts[key] = dict_type(get_entities_dict(key.has_soc()))
+        dcts[key] = dict_type(get_entities_dict(key))
     return SystemParticipantsResultContainer(dcts)