Properly handle PV power requests when no or only some meters exist.

So far we only had configurations like this: Meter -> Inverter -> PV. However
the scenario with Inverter -> PV is also possible and now handled correctly.

Signed-off-by: Mathias L. Baumann <[email protected]>

Author: Marenz

RELEASE_NOTES.md

@@ -15,3 +15,7 @@
 ## Bug Fixes
 
 - Fixes a bug in the ring buffer updating the end timestamp of gaps when they are outdated.
+- Properly handles PV configurations with no or only some meters before the PV
+  component.
+  So far we only had configurations like this: Meter -> Inverter -> PV. However
+  the scenario with Inverter -> PV is also possible and now handled correctly.

src/frequenz/sdk/timeseries/_formula_engine/_formula_generators/_pv_power_formula.py

@@ -9,15 +9,10 @@
 from collections import abc
 
 from ....microgrid import connection_manager
-from ....microgrid.component import ComponentCategory, ComponentMetricId, InverterType
+from ....microgrid.component import ComponentCategory, ComponentMetricId
 from ..._quantities import Power
 from .._formula_engine import FormulaEngine
-from ._formula_generator import (
-    NON_EXISTING_COMPONENT_ID,
-    FormulaGenerationError,
-    FormulaGenerator,
-    FormulaType,
-)
+from ._formula_generator import NON_EXISTING_COMPONENT_ID, FormulaGenerator, FormulaType
 
 _logger = logging.getLogger(__name__)
 
@@ -38,8 +33,8 @@ def generate(self) -> FormulaEngine[Power]:
             "pv-power", ComponentMetricId.ACTIVE_POWER, Power.from_watts
         )
 
-        pv_meters = self._get_pv_meters()
-        if not pv_meters:
+        pv_components = self._get_pv_power_components()
+        if not pv_components:
             _logger.warning(
                 "Unable to find any PV inverters in the component graph. "
                 "Subscribing to the resampling actor with a non-existing "
@@ -55,7 +50,7 @@ def generate(self) -> FormulaEngine[Power]:
 
         builder.push_oper("(")
         builder.push_oper("(")
-        for idx, comp_id in enumerate(pv_meters):
+        for idx, comp_id in enumerate(pv_components):
             if idx > 0:
                 builder.push_oper("+")
 
@@ -71,39 +66,30 @@ def generate(self) -> FormulaEngine[Power]:
 
         return builder.build()
 
-    def _get_pv_meters(self) -> abc.Set[int]:
-        component_graph = connection_manager.get().component_graph
+    def _get_pv_power_components(self) -> abc.Set[int]:
+        """Get the component ids of the PV inverters or meters in the component graph.
 
-        pv_inverters = list(
-            comp
-            for comp in component_graph.components()
-            if comp.category == ComponentCategory.INVERTER
-            and comp.type == InverterType.SOLAR
-        )
-        pv_meters: set[int] = set()
+        Returns:
+            A set of component ids of the PV inverters or meters in the component graph.
 
-        if not pv_inverters:
-            return pv_meters
+        Raises:
+            RuntimeError: if the grid component has no PV inverters or meters as successors.
+        """
+        component_graph = connection_manager.get().component_graph
+        grid_successors = self._get_grid_component_successors()
 
-        for pv_inverter in pv_inverters:
-            predecessors = component_graph.predecessors(pv_inverter.component_id)
-            if len(predecessors) != 1:
-                raise FormulaGenerationError(
-                    "Expected exactly one predecessor for PV inverter "
-                    f"{pv_inverter.component_id}, but found {len(predecessors)}."
+        if len(grid_successors) == 1:
+            successor = next(iter(grid_successors))
+            if successor.category != ComponentCategory.METER:
+                raise RuntimeError(
+                    "Only grid successor in the component graph is not a meter."
                 )
-            meter = next(iter(predecessors))
-            if meter.category != ComponentCategory.METER:
-                raise FormulaGenerationError(
-                    f"Expected predecessor of PV inverter {pv_inverter.component_id} "
-                    f"to be a meter, but found {meter.category}."
-                )
-            meter_successors = component_graph.successors(meter.component_id)
-            if len(meter_successors) != 1:
-                raise FormulaGenerationError(
-                    f"Expected exactly one successor for meter {meter.component_id}"
-                    f", connected to PV inverter {pv_inverter.component_id}"
-                    f", but found {len(meter_successors)}."
-                )
-            pv_meters.add(meter.component_id)
-        return pv_meters
+            grid_successors = component_graph.successors(successor.component_id)
+
+        pv_meters_or_inverters: set[int] = set()
+
+        for successor in grid_successors:
+            if component_graph.is_pv_chain(successor):
+                pv_meters_or_inverters.add(successor.component_id)
+
+        return pv_meters_or_inverters

tests/timeseries/mock_microgrid.py

@@ -295,26 +295,20 @@ def add_batteries(self, count: int, no_meter: bool = False) -> None:
                 self._connections.add(Connection(meter_id, inv_id))
             self._connections.add(Connection(inv_id, bat_id))
 
-    def add_solar_inverters(self, count: int) -> None:
+    def add_solar_inverters(self, count: int, no_meter: bool = False) -> None:
         """Add pv inverters and connected pv meters to the microgrid.
 
         Args:
             count: number of inverters to add to the microgrid.
+            no_meter: if True, do not add a meter for each inverter.
         """
         for _ in range(count):
             meter_id = self._id_increment * 10 + self.meter_id_suffix
             inv_id = self._id_increment * 10 + self.inverter_id_suffix
             self._id_increment += 1
 
-            self.meter_ids.append(meter_id)
             self.pv_inverter_ids.append(inv_id)
 
-            self._components.add(
-                Component(
-                    meter_id,
-                    ComponentCategory.METER,
-                )
-            )
             self._components.add(
                 Component(
                     inv_id,
@@ -323,9 +317,20 @@ def add_solar_inverters(self, count: int) -> None:
                 )
             )
             self._start_inverter_streaming(inv_id)
-            self._start_meter_streaming(meter_id)
-            self._connections.add(Connection(self._connect_to, meter_id))
-            self._connections.add(Connection(meter_id, inv_id))
+
+            if no_meter:
+                self._connections.add(Connection(self._connect_to, inv_id))
+            else:
+                self.meter_ids.append(meter_id)
+                self._components.add(
+                    Component(
+                        meter_id,
+                        ComponentCategory.METER,
+                    )
+                )
+                self._start_meter_streaming(meter_id)
+                self._connections.add(Connection(self._connect_to, meter_id))
+                self._connections.add(Connection(meter_id, inv_id))
 
     def add_ev_chargers(self, count: int) -> None:
         """Add EV Chargers to the microgrid.

tests/timeseries/mock_resampler.py

@@ -145,6 +145,13 @@ async def send_meter_power(self, values: list[float | None]) -> None:
             sample = Sample(self._next_ts, None if not value else Quantity(value))
             await chan.send(sample)
 
+    async def send_pv_inverter_power(self, values: list[float | None]) -> None:
+        """Send the given values as resampler output for PV Inverter power."""
+        assert len(values) == len(self._pv_inverter_power_senders)
+        for chan, value in zip(self._pv_inverter_power_senders, values):
+            sample = Sample(self._next_ts, None if not value else Quantity(value))
+            await chan.send(sample)
+
     async def send_evc_power(self, values: list[float | None]) -> None:
         """Send the given values as resampler output for EV Charger power."""
         assert len(values) == len(self._ev_power_senders)

tests/timeseries/test_logical_meter.py

@@ -191,6 +191,28 @@ async def test_pv_power(self, mocker: MockerFixture) -> None:
             await pv_consumption_power_receiver.receive()
         ).value == Power.from_watts(0.0)
 
+    async def test_pv_power_no_meter(self, mocker: MockerFixture) -> None:
+        """Test the pv power formula."""
+        mockgrid = MockMicrogrid(grid_side_meter=False)
+        mockgrid.add_solar_inverters(2, no_meter=True)
+        await mockgrid.start(mocker)
+
+        logical_meter = microgrid.logical_meter()
+        pv_power_receiver = logical_meter.pv_power.new_receiver()
+        pv_production_power_receiver = logical_meter.pv_production_power.new_receiver()
+        pv_consumption_power_receiver = (
+            logical_meter.pv_consumption_power.new_receiver()
+        )
+
+        await mockgrid.mock_resampler.send_pv_inverter_power([-1.0, -2.0])
+        assert (await pv_power_receiver.receive()).value == Power.from_watts(-3.0)
+        assert (await pv_production_power_receiver.receive()).value == Power.from_watts(
+            3.0
+        )
+        assert (
+            await pv_consumption_power_receiver.receive()
+        ).value == Power.from_watts(0.0)
+
     async def test_consumer_power_grid_meter(self, mocker: MockerFixture) -> None:
         """Test the consumer power formula with a grid meter."""
         mockgrid = MockMicrogrid(grid_side_meter=True)