Feature/time series load update and sgen update

src/power_grid_model_io/converters/pandapower_converter.py

@@ -46,12 +46,19 @@ def __init__(self, system_frequency: float = 50.0, trafo_loading: str = "current
         self.pgm_input_data: SingleDataset = {}
         self.pp_output_data: PandaPowerData = {}
         self.pgm_output_data: SingleDataset = {}
+        self.pp_update_data: PandaPowerData = {}
+        self.pgm_update_data: SingleDataset = {}
         self.pgm_nodes_lookup: pd.DataFrame = pd.DataFrame()
         self.idx: Dict[Tuple[str, Optional[str]], pd.Series] = {}
         self.idx_lookup: Dict[Tuple[str, Optional[str]], pd.Series] = {}
         self.next_idx = 0
 
-    def _parse_data(self, data: PandaPowerData, data_type: str, extra_info: Optional[ExtraInfo] = None) -> Dataset:
+    def _parse_data(
+        self,
+        data: PandaPowerData,
+        data_type: str,
+        extra_info: Optional[ExtraInfo] = None,
+    ) -> Dataset:
         """
         Set up for conversion from PandaPower to power-grid-model
 
@@ -65,18 +72,21 @@ def _parse_data(self, data: PandaPowerData, data_type: str, extra_info: Optional
         Returns:
             Converted power-grid-model data
         """
-
         # Clear pgm data
         self.pgm_input_data = {}
         self.idx_lookup = {}
         self.next_idx = 0
 
-        # Set pandas data
-        self.pp_input_data = data
+        self.pgm_update_data = {}
 
         # Convert
         if data_type == "input":
+            # Set pandas data
+            self.pp_input_data = data
             self._create_input_data()
+        elif data_type == "update":
+            self.pp_update_data = data
+            self._update_input_data()
         else:
             raise ValueError(f"Data type: '{data_type}' is not implemented")
 
@@ -115,7 +125,7 @@ def _serialize_data(self, data: Dataset, extra_info: Optional[ExtraInfo]) -> Pan
         def pgm_output_dtype_checker(check_type: str) -> bool:
             return all(
                 (
-                    comp_array.dtype == power_grid_meta_data[check_type][component]
+                    comp_array.dtype == power_grid_meta_data[check_type][component]["dtype"]
                     for component, comp_array in self.pgm_output_data.items()
                 )
             )
@@ -247,7 +257,7 @@ def _extra_info_to_pgm_input_data(self, extra_info: ExtraInfo):  # pylint: disab
         nan = np.iinfo(dtype).min
         all_other_cols = ["i_n"]
         for component, data in self.pgm_output_data.items():
-            input_cols = power_grid_meta_data["input"][component].dtype.names
+            input_cols = power_grid_meta_data["input"][component]["dtype"].names
             node_cols = [col for col in input_cols if NODE_REF_RE.fullmatch(col)]
             other_cols = [col for col in input_cols if col in all_other_cols]
             if not node_cols + other_cols:
@@ -332,6 +342,10 @@ def _create_output_data_3ph(self):
         self._pp_asym_gens_output_3ph()
         self._pp_asym_loads_output_3ph()
 
+    def _update_input_data(self):
+        self._pp_update_loads()
+        self._pp_update_sgens()
+
     def _create_pgm_input_nodes(self):
         """
         This function converts a Bus Dataframe of PandaPower to a power-grid-model Node input array.
@@ -2045,6 +2059,273 @@ def _pp_asym_gens_output_3ph(self):
         assert "res_asymmetric_sgen_3ph" not in self.pp_output_data
         self.pp_output_data["res_asymmetric_sgen_3ph"] = pp_output_asym_gens_3ph
 
+    # pylint: disable-msg=too-many-locals
+    def _pp_update_loads(self):  # pragma: no cover
+        pp_upd_data = self.pp_update_data["controller"]["object"]
+
+        scaling = self._get_pp_attr("load", "scaling", 1.0)
+        all_load_ids = self.pp_update_data["load"].index.values
+        const_i_multiplier = self._get_pp_attr("load", "const_i_percent", 0) * scaling * (1e-2 * 1e6)
+        const_z_multiplier = self._get_pp_attr("load", "const_z_percent", 0) * scaling * (1e-2 * 1e6)
+        const_p_multiplier = (1e6 - const_i_multiplier - const_z_multiplier) * scaling
+
+        load_controller_ids = []
+        pp_load_ids = set()
+        # Loop over all controllers
+        for count, control in enumerate(pp_upd_data):
+            # If the element of a controller is a load, we save the controller id and load id
+            if control.element == "load":
+                load_controller_ids.append(count)
+                pp_load_ids.add(pp_upd_data[count].element_index[0])
+        # If there are no controllers for loads, we stop here
+        if len(load_controller_ids) < 1:
+            return  # Whether to crash or not
+
+        # Convert it to a list, debugger was complaining
+        pp_load_ids = list(pp_load_ids)
+
+        # Every constcontroller uses the same df, so we take the df of the first constcontroller?
+        data = pp_upd_data[load_controller_ids[0]].data_source.df
+
+        # Time steps are Dataframe indexes
+        time_steps = len(data)
+
+        # Profiles are Dataframe columns
+        profiles = len(pp_load_ids)
+
+        pgm_load_profile = initialize_array("update", "sym_load", (time_steps, profiles * 3))
+
+        pgm_load_profile["id"] = self._get_timeseries_load_ids(pp_load_ids)
+
+        # Loop through controller IDs which are responsible for loads
+        for controller_id in load_controller_ids:
+
+            load_id_const_power = self._get_pgm_ids(
+                "load", np.array(pp_upd_data[controller_id].element_index), name="const_power"
+            ).iloc[0]
+
+            load_id_const_impedance = self._get_pgm_ids(
+                "load", np.array(pp_upd_data[controller_id].element_index), name="const_impedance"
+            ).iloc[0]
+
+            load_id_const_current = self._get_pgm_ids(
+                "load", np.array(pp_upd_data[controller_id].element_index), name="const_current"
+            ).iloc[0]
+
+            scaling_index = np.where(all_load_ids == pp_upd_data[controller_id].element_index[0])[0]
+
+            # If the current controller is reponsilbe for the p_mw attribute, set p_specified
+            if pp_upd_data[controller_id].variable == "p_mw":
+                p_mw = data.iloc[:, controller_id].to_numpy()
+
+                pgm_load_profile["p_specified"][pgm_load_profile["id"] == load_id_const_power] = (
+                    p_mw * const_p_multiplier[scaling_index]
+                )
+                pgm_load_profile["p_specified"][pgm_load_profile["id"] == load_id_const_impedance] = (
+                    p_mw * const_z_multiplier[scaling_index]
+                )
+                pgm_load_profile["p_specified"][pgm_load_profile["id"] == load_id_const_current] = (
+                    p_mw * const_i_multiplier[scaling_index]
+                )
+
+            # If the current controller is reponsilbe for the q_mvar attribute, set q_specified
+            if pp_upd_data[controller_id].variable == "q_mvar":
+                q_mvar = data.iloc[:, controller_id].to_numpy()
+
+                pgm_load_profile["q_specified"][pgm_load_profile["id"] == load_id_const_power] = (
+                    q_mvar * const_p_multiplier[scaling_index]
+                )
+                pgm_load_profile["q_specified"][pgm_load_profile["id"] == load_id_const_impedance] = (
+                    q_mvar * const_z_multiplier[scaling_index]
+                )
+                pgm_load_profile["q_specified"][pgm_load_profile["id"] == load_id_const_current] = (
+                    q_mvar * const_i_multiplier[scaling_index]
+                )
+
+        self.pgm_update_data["sym_load"] = pgm_load_profile
+
+        #
+        #     # If there hasn't yet been a controller responsible for a load with this id
+        #     # If the controller is responsible for the p_mw attribute, assign it to p_specified
+        #     # then assign a nan value to q_specified, later on PGM will take an input value instead of nan
+        #     if not np.isin(load_id_const_power,
+        #     pgm_load_profile["id"]) and pp_upd_data[controller_id].variable == "p_mw":
+        #         p_mw = data.iloc[:, controller_id].to_numpy()
+        #
+        #         pgm_load_profile["id"] = np.append(pgm_load_profile["id"], load_id_const_power)
+        #         pgm_load_profile["p_specified"] = np.append(
+        #         pgm_load_profile["p_specified"], p_mw * const_p_multiplier)
+        #         pgm_load_profile["q_specified"] = np.append(np.nan)
+        #
+        #         pgm_load_profile["id"] = np.append(pgm_load_profile["id"], np.array(load_id_const_impedance))
+        #         pgm_load_profile["p_specified"] = np.append(
+        #         pgm_load_profile["p_specified"], p_mw * const_z_multiplier)
+        #         pgm_load_profile["q_specified"] = np.append(np.nan)
+        #
+        #         pgm_load_profile["id"] = np.append(pgm_load_profile["id"], np.array(load_id_const_current))
+        #         pgm_load_profile["p_specified"] = np.append(
+        #         pgm_load_profile["p_specified"], p_mw * const_i_multiplier)
+        #         pgm_load_profile["q_specified"] = np.append(np.nan)
+        #
+        #         # If the controller is responsible for the q_mvar attribute, assign it to q_specified
+        #         # then assign a nan value to p_specified, later on PGM will take an input value instead of nan
+        #     if load_id_const_power not in pgm_load_profile["id"] and pp_upd_data[controller_id].variable == "q_mvar":
+        #         q_mvar = data.iloc[:, controller_id].to_numpy()
+        #
+        #         pgm_load_profile["id"] = np.append(pgm_load_profile["id"], load_id_const_power)
+        #         pgm_load_profile["q_specified"] = np.append(
+        #         pgm_load_profile["q_specified"], q_mvar * const_p_multiplier)
+        #         pgm_load_profile["p_specified"] = np.append(np.nan)
+        #
+        #         pgm_load_profile["id"] = np.append(pgm_load_profile["id"], load_id_const_impedance)
+        #         pgm_load_profile["q_specified"] = np.append(
+        #         pgm_load_profile["q_specified"], q_mvar * const_z_multiplier)
+        #         pgm_load_profile["p_specified"] = np.append(np.nan)
+        #
+        #         pgm_load_profile["id"] = np.append(pgm_load_profile["id"], load_id_const_current)
+        #         pgm_load_profile["q_specified"] = np.append(
+        #         pgm_load_profile["q_specified"], q_mvar * const_i_multiplier)
+        #         pgm_load_profile["p_specified"] = np.append(np.nan)
+        #
+
+        # if "load.p_mw" not in pp_upd_data and "load.q_mvar" not in pp_upd_data:
+        #     return
+        #
+        # if "load.p_mw" in pp_upd_data and "load.q_mvar" in pp_upd_data:
+        #     p_mw_ids = np.array(pp_upd_data["load.p_mw"].columns)
+        #     q_mvar_ids = np.array(pp_upd_data["load.q_mvar"].columns)
+        #     # Should we sort the DF columns initially?
+        #     if p_mw_ids.sort() != q_mvar_ids.sort():
+        #         raise Exception("The IDs of load p_mw Datasource and load q_mvar Datasource are different!")
+        #
+        # if "load.p_mw" in pp_upd_data:
+        #     load_pmw_profile = pp_upd_data["load.p_mw"]
+        #     # Length of a DF represents time steps
+        #     time_steps = len(load_pmw_profile)
+        #     # Length of columns of a DF represents number of profiles
+        #     profiles = len(load_pmw_profile.columns)
+        #
+        #     pgm_load_profile = initialize_array("update", "sym_load", (time_steps, profiles))
+        #
+        #     pgm_load_profile["id"] = self._get_pgm_ids("load", np.array(load_pmw_profile.columns))
+        #
+        #     pgm_load_profile["p_specified"] = load_pmw_profile.to_numpy() * 1e6
+        #
+        #     if "load.q_mvar" in pp_upd_data:
+        #         pgm_load_profile["q_specified"] = pp_upd_data["load.q_mvar"].to_numpy() * 1e6
+        #
+        #     self.pgm_update_data["sym_load"] = pgm_load_profile
+        #
+        # if "load.q_mvar" in pp_upd_data and "load.p_mw" not in pp_upd_data:
+        #     load_qmvar_profile = pp_upd_data["load.q_mvar"]
+        #
+        #     time_steps = len(load_qmvar_profile)
+        #     profiles = len(load_qmvar_profile.columns)
+        #
+        #     pgm_load_profile = initialize_array("update", "sym_load", (time_steps, profiles))
+        #
+        #     pgm_load_profile["id"] = self._get_pgm_ids("load", np.array(load_qmvar_profile.columns))
+        #
+        #     pgm_load_profile["q_specified"] = load_qmvar_profile.to_numpy() * 1e6
+        #
+        #     self.pgm_update_data["sym_load"] = pgm_load_profile
+
+    # pylint: disable-msg=too-many-locals
+    def _pp_update_sgens(self):  # pragma: no cover
+        pp_upd_data = self.pp_update_data["controller"]["object"]
+
+        scaling = self._get_pp_attr("sgen", "scaling", 1.0)
+        all_sgen_ids = self.pp_update_data["sgen"].index.values
+
+        sgen_controller_ids = []
+        pp_sgen_ids = set()
+        # Loop over all controllers
+        for count, control in enumerate(pp_upd_data):
+            # If the element of a controller is a load, we save the controller id and load id
+            if control.element == "sgen":
+                sgen_controller_ids.append(count)
+                pp_sgen_ids.add(pp_upd_data[count].element_index[0])
+        # If there are no controllers for sgens, we stop here
+        if len(sgen_controller_ids) < 1:
+            return
+
+        data = pp_upd_data[sgen_controller_ids[0]].data_source.df
+
+        # Time steps are Dataframe indexes
+        time_steps = len(data)
+
+        # Profiles are Dataframe columns
+        profiles = len(pp_sgen_ids)
+
+        pgm_symgen_profile = initialize_array("update", "sym_load", (time_steps, profiles))
+
+        pgm_symgen_profile["id"] = self._get_pgm_ids("sgen", np.array(list(pp_sgen_ids)))
+
+        for controller_id in sgen_controller_ids:
+
+            sym_gen_id = self._get_pgm_ids("sgen", np.array(pp_upd_data[controller_id].element_index)).iloc[0]
+
+            scaling_index = np.where(all_sgen_ids == pp_upd_data[controller_id].element_index[0])[0]
+
+            # If the current controller is reponsilbe for the p_mw attribute, set p_specified
+            if pp_upd_data[controller_id].variable == "p_mw":
+                p_mw = data.iloc[:, controller_id].to_numpy()
+                pgm_symgen_profile["p_specified"][pgm_symgen_profile["id"] == sym_gen_id] = p_mw * (
+                    1e6 * scaling[scaling_index]
+                )
+
+            # If the current controller is reponsilbe for the q_mvar attribute, set q_specified
+            if pp_upd_data[controller_id].variable == "q_mvar":
+                q_mvar = data.iloc[:, controller_id].to_numpy()
+                pgm_symgen_profile["q_specified"][pgm_symgen_profile["id"] == sym_gen_id] = q_mvar * (
+                    1e6 * scaling[scaling_index]
+                )
+
+        self.pgm_update_data["sym_gen"] = pgm_symgen_profile
+
+        # if "sgen.p_mw" not in pp_upd_data and "sgen.q_mvar" not in pp_upd_data:
+        #     return
+        #
+        # if "sgen.p_mw" in pp_upd_data and "sgen.q_mvar" in pp_upd_data:
+        #     p_mw_ids = np.array(pp_upd_data["sgen.p_mw"].columns)
+        #     q_mvar_ids = np.array(pp_upd_data["sgen.q_mvar"].columns)
+        #     # Should we sort the DF columns initially?
+        #     if p_mw_ids.sort() != q_mvar_ids.sort():
+        #         raise Exception("The IDs of sgen p_mw Datasource and sgen q_mvar Datasource are different!")
+        #
+        # if "sgen.p_mw" in pp_upd_data:
+        #     sgen_pmw_profile = pp_upd_data["sgen.p_mw"]
+        #
+        #     time_steps = len(sgen_pmw_profile)
+        #
+        #     profiles = len(sgen_pmw_profile.columns)
+        #
+        #     sgen_profile = initialize_array("update", "sym_gen", (time_steps, profiles))
+        #
+        #     sgen_profile["id"] = self._get_pgm_ids("sgen", np.array(sgen_pmw_profile.columns))
+        #
+        #     sgen_profile["p_specified"] = sgen_pmw_profile.to_numpy() * 1e6
+        #
+        #     if "sgen.q_mvar" in pp_upd_data:
+        #         sgen_profile["q_specified"] = pp_upd_data["sgen.q_mvar"].to_numpy() * 1e6
+        #
+        #     self.pgm_update_data["sym_gen"] = sgen_profile
+        #
+        # if "sgen.q_mvar" in pp_upd_data and "sgen.p_mw" not in pp_upd_data:
+        #     sgen_qmvar_profile = pp_upd_data["sgen.q_mvar"]
+        #
+        #     time_steps = len(sgen_qmvar_profile)
+        #
+        #     profiles = len(sgen_qmvar_profile)
+        #
+        #     sgen_profile = initialize_array("update", "sym_gen", (time_steps, profiles))
+        #
+        #     sgen_profile["id"] = self._get_pgm_ids("sgen", np.array(sgen_qmvar_profile.columns))
+        #
+        #     sgen_profile["q_specified"] = sgen_qmvar_profile.to_numpy() * 1e6
+        #
+        #     self.pgm_update_data["sym_gen"] = sgen_profile
+
     def _generate_ids(self, pp_table: str, pp_idx: pd.Index, name: Optional[str] = None) -> np.ndarray:
         """
         Generate numerical power-grid-model IDs for a PandaPower component
@@ -2103,6 +2384,18 @@ def _get_pp_ids(self, pp_table: str, pgm_idx: Optional[pd.Series] = None, name:
             return self.idx_lookup[key]
         return self.idx_lookup[key][pgm_idx]
 
+    def _get_timeseries_load_ids(self, pp_load_ids):
+
+        load_id_const_power = self._get_pgm_ids("load", np.array(pp_load_ids), name="const_power")
+
+        load_id_const_impedance = self._get_pgm_ids("load", np.array(pp_load_ids), name="const_impedance")
+
+        load_id_const_current = self._get_pgm_ids("load", np.array(pp_load_ids), name="const_current")
+
+        pgm_ids = pd.concat([load_id_const_power, load_id_const_impedance, load_id_const_current])
+
+        return pgm_ids
+
     @staticmethod
     def _get_tap_size(pp_trafo: pd.DataFrame) -> np.ndarray:
         """