Merge branch 'features/#377-grid-separation' into merge/powermodels_i…

…nterface_split_grid
openego · May 9, 2023 · 2b7c2ad · 2b7c2ad
2 parents 94b2878 + ba00bc9
commit 2b7c2ad
Show file tree

Hide file tree

Showing 3 changed files with 35 additions and 40 deletions.
diff --git a/edisgo/flex_opt/reinforce_grid.py b/edisgo/flex_opt/reinforce_grid.py
@@ -1029,58 +1029,44 @@ def run_separate_lv_grids(edisgo_obj: EDisGo, threshold: int | float = 2) -> Non
         n_grids_init = len(lv_grids)
 
         for lv_grid in lv_grids:
-            tech_dict = {}
+            active_power_dict = {}
+            reactive_power_dict = {}
 
             for tech in techs:
                 units = getattr(lv_grid, tech_str.format(tech)).index
-                active_power = (
+                active_power_dict[tech] = (
                     getattr(
                         edisgo_obj.timeseries,
                         active_str.format(tech),
                     )
                     .loc[:, units]
                     .astype(float)
+                    .sum(axis=1)
                 )
 
-                reactive_power = (
+                reactive_power_dict[tech] = (
                     getattr(
                         edisgo_obj.timeseries,
                         reactive_str.format(tech),
                     )
                     .loc[:, units]
                     .astype(float)
+                    .sum(axis=1)
                 )
 
-                if tech == "storage_units":
-                    tech_dict[tech + "_loads"] = np.hypot(
-                        active_power.clip(upper=0.0),
-                        reactive_power.clip(upper=0.0),
-                    )
-
-                    tech_dict[tech + "_generators"] = np.hypot(
-                        active_power.clip(lower=0.0),
-                        reactive_power.clip(lower=0.0),
-                    )
-                else:
-                    tech_dict[tech] = np.hypot(active_power, reactive_power)
-
-            load = pd.concat(
-                [
-                    tech_dict["loads"],
-                    tech_dict["storage_units_loads"],
-                ],
-                axis=1,
-            ).sum(axis=1)
+            active_power = (
+                active_power_dict["loads"]
+                - active_power_dict["generators"]
+                - active_power_dict["storage_units"]
+            )
 
-            gen = pd.concat(
-                [
-                    tech_dict["generators"],
-                    tech_dict["storage_units_generators"],
-                ],
-                axis=1,
-            ).sum(axis=1)
+            reactive_power = (
+                reactive_power_dict["loads"]
+                - reactive_power_dict["generators"]
+                - reactive_power_dict["storage_units"]
+            )
 
-            worst_case = (gen - load).abs().max()
+            worst_case = np.hypot(active_power, reactive_power).max()
 
             transformers_s_nom = lv_grid.transformers_df.s_nom.sum()
 

diff --git a/edisgo/flex_opt/reinforce_measures.py b/edisgo/flex_opt/reinforce_measures.py
@@ -415,7 +415,6 @@ def reinforce_lines_voltage_issues(edisgo_obj, grid, crit_nodes):
 
     lines_changes = {}
     for repr_node in nodes_feeder.keys():
-
         # find node farthest away
         get_weight = lambda u, v, data: data["length"]  # noqa: E731
         path_length = 0
@@ -923,12 +922,16 @@ def add_standard_transformer(
     G = grid.graph
 
     # main station
-    station_node = list(G.nodes)[0]
+    station_node = grid.transformers_df.bus1.iat[0]
 
     relevant_lines = grid.lines_df.loc[
         (grid.lines_df.bus0 == station_node) | (grid.lines_df.bus1 == station_node)
     ]
 
+    first_nodes = set(relevant_lines.bus0).union(set(relevant_lines.bus1)) - {
+        station_node,
+    }
+
     if len(relevant_lines) <= 1:
         logger.warning(
             f"{grid} has only {len(relevant_lines)} feeder and is therefore not "
@@ -942,17 +945,19 @@ def add_standard_transformer(
     paths = {}
     first_nodes_feeders = {}
 
+    # determine ordered shortest path between each node and the station node and each
+    # node per feeder
     for node in G.nodes:
         if node == station_node:
             continue
 
         path = nx.shortest_path(G, station_node, node)
 
-        for first_node in relevant_lines.bus1.values:
+        for first_node in first_nodes:
             if first_node in path:
                 paths[node] = path
 
-                first_nodes_feeders.setdefault(path[1], []).append(
+                first_nodes_feeders.setdefault(first_node, []).append(
                     node  # first nodes and paths
                 )
 
@@ -975,6 +980,7 @@ def add_standard_transformer(
             node: path for node, path in paths.items() if path[1] == first_node
         }
 
+        # identify main feeder by maximum number of nodes in path
         first_nodes_feeders[first_node] = paths_first_node[
             max(paths_first_node, key=lambda x: len(paths_first_node[x]))
         ]
@@ -1041,7 +1047,6 @@ def add_standard_transformer(
             count_inept += 1
 
     if nodes_tb_relocated:
-
         # generate new lv grid id
         n = 0
         lv_grid_id_new = int(f"{grid.id}{n}")
@@ -1158,8 +1163,6 @@ def add_standard_transformer(
                 )
 
     else:
-        logger.warning(
-            f"{grid} was not split because it has too few suitable feeders."
-        )
+        logger.warning(f"{grid} was not split because it has too few suitable feeders.")
 
     return transformers_changes, lines_changes
diff --git a/tests/flex_opt/test_reinforce_measures.py b/tests/flex_opt/test_reinforce_measures.py
@@ -461,6 +461,10 @@ def test_separate_lv_grid(self):
             self.edisgo
         )
 
+        all_lv_grid_ids = [
+            lv_grid.id for lv_grid in self.edisgo.topology.mv_grid.lv_grids
+        ]
+
         lv_grid_ids = (
             self.edisgo.topology.buses_df.loc[
                 self.edisgo.topology.lines_df.loc[crit_lines_lv.index].bus0
@@ -489,8 +493,10 @@ def test_separate_lv_grid(self):
                 new_g_1 = [
                     g
                     for g in self.edisgo.topology.mv_grid.lv_grids
-                    if g.id == int(str(grid_id) + "1001")
+                    if g.id not in all_lv_grid_ids
                 ][0]
+
+                all_lv_grid_ids.append(new_g_1.id)
             except IndexError:
                 continue