Minor adjustments

Author: t-ober

pypsdm/models/gwr.py

@@ -31,6 +31,10 @@ def participants(self):
     def raw_grid(self):
         return self.grid.raw_grid
 
+    @property
+    def primary_data(self):
+        return self.grid.primary_data
+
     @property
     def nodes(self):
         return self.grid.nodes
@@ -322,9 +326,9 @@ def empty(cls):
         return GridWithResults(GridContainer.empty(), GridResultContainer.empty())
 
     @staticmethod
-    def _calc_pq(uuid, nodal_result: GridResultContainer):
+    def _calc_complex_power(uuid, nodal_result: GridResultContainer):
         """
         NOTE: Utility function for parallel processing of building ExtendedNodesResult
         """
-        pq = nodal_result.participants.sum()
-        return uuid, pq
+        complex_power = nodal_result.participants.sum()
+        return uuid, complex_power

pypsdm/models/input/utils.py

@@ -0,0 +1,30 @@
+from pypsdm import RawGridContainer, Transformers2W
+
+
+def find_slack_downstream(rg: RawGridContainer) -> str:
+    """
+    Find the downstream node of the slack node, which is the node on the transformer's
+    lower voltage side.
+    """
+    slack_node = rg.nodes.get_slack_nodes()
+    if len(slack_node.data) != 1:
+        raise ValueError("Currently only implemented for singular slack nodes.")
+    transformers = rg.transformers_2_w
+    slack_transformers = Transformers2W(
+        transformers.data[
+            (transformers.node_a.isin(slack_node.uuid.to_list()))
+            | (transformers.node_b.isin(slack_node.uuid.to_list()))
+        ]
+    )
+    slack_connected_node = (
+        set(slack_transformers.node_a)
+        .union(slack_transformers.node_b)
+        .difference(slack_node.uuid)
+    )
+    if len(slack_connected_node) > 1:
+        raise ValueError(
+            "There are multiple nodes connected to the slack node via a transformer."
+        )
+    elif len(slack_connected_node) == 0:
+        raise ValueError("Did not find a slack node!")
+    return slack_connected_node.pop()

pypsdm/models/result/participant/flex_options.py

@@ -39,15 +39,15 @@ def p_ref(self):
         return self.data["p_ref"]
 
     def p_max_as_power(self) -> ComplexPower:
-        return self._p_to_pq_res(self.p_max())
+        return self._p_to_complex_power(self.p_max())
 
     def p_ref_as_power(self) -> ComplexPower:
-        return self._p_to_pq_res(self.p_ref())
+        return self._p_to_complex_power(self.p_ref())
 
     def p_min_as_pq(self) -> ComplexPower:
-        return self._p_to_pq_res(self.p_min())
+        return self._p_to_complex_power(self.p_min())
 
-    def _p_to_pq_res(self, p_series: Series) -> ComplexPower:
+    def _p_to_complex_power(self, p_series: Series) -> ComplexPower:
         data = p_series.rename("p").to_frame()
         data["q"] = 0
         return ComplexPower(data)

pypsdm/plots/results/power.py

@@ -49,10 +49,10 @@ def plot_apparent_power_components(
 ):
     """
     Plots apparent power components (magnitude, active, reactive, angle) for a given
-    pq result.
+    complex power.
 
     Args
-        pq: ComplexPower
+        power: ComplexPower
         resolution: Resolution of the plot
         title: Optional title of the plot
     """
@@ -256,9 +256,9 @@ def plot_aggregated_load_and_generation(
 ):
     if with_residual:
         fig, axs = plt.subplots(2, 1, figsize=(10, 5), sharex=True, sharey=True)
-        pq_results = _get_pq_results_from_union(participants)
+        complex_powers = _get_complex_power_from_union(participants)
         all_load, all_generation = zip(
-            *[pq_result.divide_load_generation() for pq_result in pq_results]
+            *[cp.divide_load_generation() for cp in complex_powers]
         )
         agg_load = ComplexPower.sum(all_load)
         agg_generation = ComplexPower.sum(all_generation)
@@ -339,7 +339,7 @@ def plot_all_participants(
     return fig, axs
 
 
-def _get_pq_results_from_union(
+def _get_complex_power_from_union(
     participants: Union[SystemParticipantsResultContainer, list[ComplexPower]],
 ) -> list[ComplexPower]:
     return (
@@ -363,27 +363,31 @@ def ax_plot_participants(
     resolution: Resolution | None = None,
     **kwargs,
 ):
-    pq_results = _get_pq_results_from_union(participants)
+    complex_powers = _get_complex_power_from_union(participants)
     if stack:
-        plot_kwargs = [kwargs for _ in range(len(pq_results))]
-        ax_plot_stacked_pq(
+        plot_kwargs = [kwargs for _ in range(len(complex_powers))]
+        ax_plot_stacked_power(
             ax,
-            pq_results,
+            complex_powers,
             hourly_mean=hourly_mean,
             resolution=resolution,
             plot_kwargs=plot_kwargs,
         )
     else:
         [
             ax_plot_active_power(
-                ax, pq_result, hourly_mean=hourly_mean, resolution=resolution, **kwargs
+                ax,
+                complex_power,
+                hourly_mean=hourly_mean,
+                resolution=resolution,
+                **kwargs,
             )
-            for pq_result in pq_results
+            for complex_power in complex_powers
         ]
     legend_with_distinct_labels(ax)
 
 
-def ax_plot_stacked_pq(
+def ax_plot_stacked_power(
     ax: Axes,
     results: list[ComplexPower],
     hourly_mean: bool = False,