Add new method to stream grid reactive power

Implement new formula GridReactivePowerFormula
to calculate `reactive_power`.
Add new method microgrid.grid().reactive_power to stream
reactive power at the grid connection point.

Signed-off-by: Elzbieta Kotulska <[email protected]>

Author: ela-kotulska-frequenz

RELEASE_NOTES.md

@@ -18,6 +18,8 @@ and adapt your imports if you are using these types.
   - `force_polling`: Whether to force file polling to check for changes. Default is `True`.
   - `polling_interval`: The interval to check for changes. Only relevant if polling is enabled. Default is 1 second.
 
+- Add a new method `microgrid.grid().reactive_power` to stream reactive power at the grid connection point.
+
 ## Bug Fixes
 
 - Many long running async tasks including metric streamers in the BatteryPool now have automatic recovery in case of exceptions.

src/frequenz/sdk/timeseries/formula_engine/_formula_generators/__init__.py

@@ -17,6 +17,7 @@
 from ._grid_current_formula import GridCurrentFormula
 from ._grid_power_3_phase_formula import GridPower3PhaseFormula
 from ._grid_power_formula import GridPowerFormula
+from ._grid_reactive_power_formula import GridReactivePowerFormula
 from ._producer_power_formula import ProducerPowerFormula
 from ._pv_power_formula import PVPowerFormula
 
@@ -33,6 +34,7 @@
     "ConsumerPowerFormula",
     "GridPower3PhaseFormula",
     "GridPowerFormula",
+    "GridReactivePowerFormula",
     "BatteryPowerFormula",
     "EVChargerPowerFormula",
     "PVPowerFormula",

src/frequenz/sdk/timeseries/formula_engine/_formula_generators/_grid_reactive_power_formula.py

@@ -0,0 +1,34 @@
+# License: MIT
+# Copyright © 2024 Frequenz Energy-as-a-Service GmbH
+
+"""Formula generator from component graph for Grid Reactive Power."""
+
+
+from frequenz.client.microgrid import ComponentMetricId
+from frequenz.quantities import Power
+
+from .._formula_engine import FormulaEngine
+from ._grid_power_formula_base import GridPowerFormulaBase
+
+
+class GridReactivePowerFormula(GridPowerFormulaBase):
+    """Creates a formula engine from the component graph for calculating grid reactive power."""
+
+    def generate(  # noqa: DOC502
+        # * ComponentNotFound is raised indirectly by _get_grid_component_successors
+        self,
+    ) -> FormulaEngine[Power]:
+        """Generate a formula for calculating grid reactive power from the component graph.
+
+        Returns:
+            A formula engine that will calculate grid reactive power values.
+
+        Raises:
+            ComponentNotFound: when the component graph doesn't have a `GRID` component.
+        """
+        builder = self._get_builder(
+            f"grid-{ComponentMetricId.REACTIVE_POWER.value}",
+            ComponentMetricId.REACTIVE_POWER,
+            Power.from_watts,
+        )
+        return self._generate(builder)

src/frequenz/sdk/timeseries/grid.py

@@ -13,7 +13,7 @@
 from dataclasses import dataclass
 
 from frequenz.channels import Sender
-from frequenz.client.microgrid._component import ComponentCategory
+from frequenz.client.microgrid._component import ComponentCategory, ComponentMetricId
 from frequenz.quantities import Current, Power
 
 from .._internal._channels import ChannelRegistry
@@ -26,6 +26,7 @@
     GridCurrentFormula,
     GridPower3PhaseFormula,
     GridPowerFormula,
+    GridReactivePowerFormula,
 )
 
 _logger = logging.getLogger(__name__)
@@ -95,6 +96,28 @@ def power(self) -> FormulaEngine[Power]:
         assert isinstance(engine, FormulaEngine)
         return engine
 
+    @property
+    def reactive_power(self) -> FormulaEngine[Power]:
+        """Fetch the grid reactive power for the microgrid.
+
+        This formula produces values that are in the Passive Sign Convention (PSC).
+
+        If a formula engine to calculate grid power is not already running, it will be
+        started.
+
+        A receiver from the formula engine can be created using the `new_receiver`
+        method.
+
+        Returns:
+            A FormulaEngine that will calculate and stream grid reactive power.
+        """
+        engine = self._formula_pool.from_power_formula_generator(
+            f"grid-{ComponentMetricId.REACTIVE_POWER.value}",
+            GridReactivePowerFormula,
+        )
+        assert isinstance(engine, FormulaEngine)
+        return engine
+
     @property
     def _power_per_phase(self) -> FormulaEngine3Phase[Power]:
         """Fetch the per-phase grid power for the microgrid.

tests/microgrid/test_grid.py

@@ -192,6 +192,102 @@ async def test_grid_power_2(mocker: MockerFixture) -> None:
     assert equal_float_lists(results, meter_sums)
 
 
+async def test_grid_reactive_power_1(mocker: MockerFixture) -> None:
+    """Test the grid power formula with a grid side meter."""
+    mockgrid = MockMicrogrid(grid_meter=True, mocker=mocker)
+    mockgrid.add_batteries(2)
+    mockgrid.add_solar_inverters(1)
+
+    results = []
+    grid_meter_data = []
+    async with mockgrid, AsyncExitStack() as stack:
+        grid = microgrid.grid()
+        assert grid, "Grid is not initialized"
+        stack.push_async_callback(grid.stop)
+
+        grid_power_recv = grid.reactive_power.new_receiver()
+
+        grid_meter_recv = get_resampled_stream(
+            grid._formula_pool._namespace,  # pylint: disable=protected-access
+            mockgrid.meter_ids[0],
+            client.ComponentMetricId.REACTIVE_POWER,
+            Power.from_watts,
+        )
+
+        for count in range(10):
+            await mockgrid.mock_resampler.send_meter_reactive_power(
+                [20.0 + count, 12.0, -13.0, -5.0]
+            )
+            val = await grid_meter_recv.receive()
+            assert (
+                val is not None
+                and val.value is not None
+                and val.value.as_watts() != 0.0
+            )
+            grid_meter_data.append(val.value)
+
+            val = await grid_power_recv.receive()
+            assert val is not None and val.value is not None
+            results.append(val.value)
+
+    assert equal_float_lists(results, grid_meter_data)
+
+
+async def test_grid_reactive_power_2(mocker: MockerFixture) -> None:
+    """Test the grid power formula without a grid side meter."""
+    mockgrid = MockMicrogrid(grid_meter=False, mocker=mocker)
+    mockgrid.add_consumer_meters(1)
+    mockgrid.add_batteries(1, no_meter=False)
+    mockgrid.add_batteries(1, no_meter=True)
+    mockgrid.add_solar_inverters(1)
+
+    results: list[Quantity] = []
+    meter_sums: list[Quantity] = []
+    async with mockgrid, AsyncExitStack() as stack:
+        grid = microgrid.grid()
+        assert grid, "Grid is not initialized"
+        stack.push_async_callback(grid.stop)
+
+        grid_power_recv = grid.reactive_power.new_receiver()
+
+        component_receivers = [
+            get_resampled_stream(
+                grid._formula_pool._namespace,  # pylint: disable=protected-access
+                component_id,
+                client.ComponentMetricId.REACTIVE_POWER,
+                Power.from_watts,
+            )
+            for component_id in [
+                *mockgrid.meter_ids,
+                # The last battery has no meter, so we get the power from the inverter
+                mockgrid.battery_inverter_ids[-1],
+            ]
+        ]
+
+        for count in range(10):
+            await mockgrid.mock_resampler.send_meter_reactive_power(
+                [20.0 + count, 12.0, -13.0]
+            )
+            await mockgrid.mock_resampler.send_bat_inverter_reactive_power([0.0, -5.0])
+            meter_sum = 0.0
+            for recv in component_receivers:
+                val = await recv.receive()
+                assert (
+                    val is not None
+                    and val.value is not None
+                    and val.value.as_watts() != 0.0
+                )
+                meter_sum += val.value.as_watts()
+
+            val = await grid_power_recv.receive()
+            assert val is not None and val.value is not None
+            results.append(val.value)
+            meter_sums.append(Quantity(meter_sum))
+
+    assert len(results) == 10
+    assert equal_float_lists(results, meter_sums)
+
+
 async def test_grid_power_3_phase_side_meter(mocker: MockerFixture) -> None:
     """Test the grid 3-phase power with a grid side meter."""
     mockgrid = MockMicrogrid(grid_meter=True, mocker=mocker)

tests/timeseries/mock_microgrid.py

@@ -275,6 +275,7 @@ def _start_meter_streaming(self, meter_id: int) -> None:
                     lambda value, ts: MeterDataWrapper(
                         component_id=meter_id,
                         timestamp=ts,
+                        reactive_power=2 * value,
                         active_power=value,
                         current_per_phase=(value + 100.0, value + 101.0, value + 102.0),
                         voltage_per_phase=(value + 200.0, value + 199.8, value + 200.2),
@@ -307,7 +308,10 @@ def _start_inverter_streaming(self, inv_id: int) -> None:
                 self._comp_data_send_task(
                     inv_id,
                     lambda value, ts: InverterDataWrapper(
-                        component_id=inv_id, timestamp=ts, active_power=value
+                        component_id=inv_id,
+                        timestamp=ts,
+                        active_power=value,
+                        reactive_power=2 * value,
                     ),
                 ),
             )
@@ -325,6 +329,7 @@ def _start_ev_charger_streaming(self, evc_id: int) -> None:
                         component_id=evc_id,
                         timestamp=ts,
                         active_power=value,
+                        reactive_power=2 * value,
                         current_per_phase=(value + 10.0, value + 11.0, value + 12.0),
                         component_state=self.evc_component_states[evc_id],
                         cable_state=self.evc_cable_states[evc_id],

tests/timeseries/mock_resampler.py

@@ -67,29 +67,44 @@ def metric_senders(
                 ]
             return senders
 
+        # Active power senders
         self._bat_inverter_power_senders = metric_senders(
             bat_inverter_ids, ComponentMetricId.ACTIVE_POWER
         )
-        self._bat_inverter_frequency_senders = metric_senders(
-            bat_inverter_ids, ComponentMetricId.FREQUENCY
-        )
         self._pv_inverter_power_senders = metric_senders(
             pv_inverter_ids, ComponentMetricId.ACTIVE_POWER
         )
         self._ev_power_senders = metric_senders(evc_ids, ComponentMetricId.ACTIVE_POWER)
+
         self._chp_power_senders = metric_senders(
             chp_ids, ComponentMetricId.ACTIVE_POWER
         )
         self._meter_power_senders = metric_senders(
             meter_ids, ComponentMetricId.ACTIVE_POWER
         )
-        self._meter_frequency_senders = metric_senders(
-            meter_ids, ComponentMetricId.FREQUENCY
-        )
         self._non_existing_component_sender = metric_senders(
             [NON_EXISTING_COMPONENT_ID], ComponentMetricId.ACTIVE_POWER
         )[0]
 
+        # Frequency senders
+        self._bat_inverter_frequency_senders = metric_senders(
+            bat_inverter_ids, ComponentMetricId.FREQUENCY
+        )
+        self._meter_frequency_senders = metric_senders(
+            meter_ids, ComponentMetricId.FREQUENCY
+        )
+
+        # Reactive power senders
+        self._meter_reactive_power_senders = metric_senders(
+            meter_ids, ComponentMetricId.REACTIVE_POWER
+        )
+        self._bat_inverter_reactive_power_senders = metric_senders(
+            bat_inverter_ids, ComponentMetricId.REACTIVE_POWER
+        )
+        self._ev_reactive_power_senders = metric_senders(
+            evc_ids, ComponentMetricId.REACTIVE_POWER
+        )
+
         def multi_phase_senders(
             ids: list[int],
             metrics: tuple[ComponentMetricId, ComponentMetricId, ComponentMetricId],
@@ -301,6 +316,29 @@ async def send_bat_inverter_power(self, values: list[float | None]) -> None:
             sample = self.make_sample(value)
             await chan.send(sample)
 
+    async def send_meter_reactive_power(self, values: list[float | None]) -> None:
+        """Send the given values as resampler output for meter reactive power."""
+        assert len(values) == len(self._meter_reactive_power_senders)
+        for chan, value in zip(self._meter_reactive_power_senders, values):
+            sample = self.make_sample(value)
+            await chan.send(sample)
+
+    async def send_bat_inverter_reactive_power(
+        self, values: list[float | None]
+    ) -> None:
+        """Send the given values as resampler output for battery inverter reactive power."""
+        assert len(values) == len(self._bat_inverter_reactive_power_senders)
+        for chan, value in zip(self._bat_inverter_reactive_power_senders, values):
+            sample = self.make_sample(value)
+            await chan.send(sample)
+
+    async def send_evc_reactive_power(self, values: list[float | None]) -> None:
+        """Send the given values as resampler output for EV Charger reactive power."""
+        assert len(values) == len(self._ev_reactive_power_senders)
+        for chan, value in zip(self._ev_reactive_power_senders, values):
+            sample = self.make_sample(value)
+            await chan.send(sample)
+
     async def send_non_existing_component_value(self) -> None:
         """Send a value for a non existing component."""
         sample = self.make_sample(None)