Support PV configurations with no or only some meters (#584)

- Put frequently used code in base function.
- 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.

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/_consumer_power_formula.py

@@ -37,20 +37,9 @@ def generate(self) -> FormulaEngine[Power]:
         builder = self._get_builder(
             "consumer-power", ComponentMetricId.ACTIVE_POWER, Power.from_watts
         )
-        component_graph = connection_manager.get().component_graph
-        grid_component = next(
-            (
-                comp
-                for comp in component_graph.components()
-                if comp.category == ComponentCategory.GRID
-            ),
-            None,
-        )
 
-        if grid_component is None:
-            raise ComponentNotFound("Grid component not found in the component graph.")
+        grid_successors = self._get_grid_component_successors()
 
-        grid_successors = component_graph.successors(grid_component.component_id)
         if not grid_successors:
             raise ComponentNotFound("No components found in the component graph.")
 

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

@@ -15,6 +15,7 @@
 from frequenz.channels import Sender
 
 from ....actor import ChannelRegistry, ComponentMetricRequest
+from ....microgrid import component, connection_manager
 from ....microgrid.component import ComponentMetricId
 from ..._quantities import QuantityT
 from .._formula_engine import FormulaEngine, FormulaEngine3Phase
@@ -100,6 +101,36 @@ def _get_builder(
         )
         return builder
 
+    def _get_grid_component_successors(self) -> set[component.Component]:
+        """Get the set of grid component successors in the component graph.
+
+        Returns:
+            A set of grid component successors.
+
+        Raises:
+            ComponentNotFound: If the grid component is not found in the component graph.
+            ComponentNotFound: If no successor components are found in the component graph.
+        """
+        component_graph = connection_manager.get().component_graph
+        grid_component = next(
+            iter(
+                component_graph.components(
+                    component_category={component.ComponentCategory.GRID}
+                )
+            ),
+            None,
+        )
+
+        if grid_component is None:
+            raise ComponentNotFound("Grid component not found in the component graph.")
+
+        grid_successors = component_graph.successors(grid_component.component_id)
+
+        if not grid_successors:
+            raise ComponentNotFound("No components found in the component graph.")
+
+        return grid_successors
+
     @abstractmethod
     def generate(
         self,

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

@@ -5,11 +5,10 @@
 
 from typing import Set
 
-from ....microgrid import connection_manager
 from ....microgrid.component import Component, ComponentCategory, ComponentMetricId
 from ..._quantities import Current
 from .._formula_engine import FormulaEngine, FormulaEngine3Phase
-from ._formula_generator import ComponentNotFound, FormulaGenerator
+from ._formula_generator import FormulaGenerator
 
 
 class GridCurrentFormula(FormulaGenerator[Current]):
@@ -24,22 +23,7 @@ def generate(self) -> FormulaEngine3Phase[Current]:
         Raises:
             ComponentNotFound: when the component graph doesn't have a `GRID` component.
         """
-        component_graph = connection_manager.get().component_graph
-        grid_component = next(
-            (
-                comp
-                for comp in component_graph.components()
-                if comp.category == ComponentCategory.GRID
-            ),
-            None,
-        )
-
-        if grid_component is None:
-            raise ComponentNotFound(
-                "Unable to find a GRID component from the component graph."
-            )
-
-        grid_successors = component_graph.successors(grid_component.component_id)
+        grid_successors = self._get_grid_component_successors()
 
         return FormulaEngine3Phase(
             "grid-current",

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

@@ -3,11 +3,10 @@
 
 """Formula generator from component graph for Grid Power."""
 
-from ....microgrid import connection_manager
 from ....microgrid.component import ComponentCategory, ComponentMetricId
 from ..._quantities import Power
 from .._formula_engine import FormulaEngine
-from ._formula_generator import ComponentNotFound, FormulaGenerator, FormulaType
+from ._formula_generator import FormulaGenerator, FormulaType
 
 
 class GridPowerFormula(FormulaGenerator[Power]):
@@ -27,22 +26,7 @@ def generate(
         builder = self._get_builder(
             "grid-power", ComponentMetricId.ACTIVE_POWER, Power.from_watts
         )
-        component_graph = connection_manager.get().component_graph
-        grid_component = next(
-            (
-                comp
-                for comp in component_graph.components()
-                if comp.category == ComponentCategory.GRID
-            ),
-            None,
-        )
-
-        if grid_component is None:
-            raise ComponentNotFound(
-                "Unable to find a GRID component from the component graph."
-            )
-
-        grid_successors = component_graph.successors(grid_component.component_id)
+        grid_successors = self._get_grid_component_successors()
 
         # generate a formula that just adds values from all commponents that are
         # directly connected to the grid.  If the requested formula type is

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

@@ -9,11 +9,7 @@
 from ....microgrid.component import ComponentCategory, ComponentMetricId
 from ..._quantities import Power
 from .._formula_engine import FormulaEngine
-from ._formula_generator import (
-    NON_EXISTING_COMPONENT_ID,
-    ComponentNotFound,
-    FormulaGenerator,
-)
+from ._formula_generator import NON_EXISTING_COMPONENT_ID, FormulaGenerator
 
 
 class ProducerPowerFormula(FormulaGenerator[Power]):
@@ -39,19 +35,7 @@ def generate(self) -> FormulaEngine[Power]:
             "producer_power", ComponentMetricId.ACTIVE_POWER, Power.from_watts
         )
         component_graph = connection_manager.get().component_graph
-        grid_component = next(
-            iter(
-                component_graph.components(component_category={ComponentCategory.GRID})
-            ),
-            None,
-        )
-
-        if grid_component is None:
-            raise ComponentNotFound("Grid component not found in the component graph.")
-
-        grid_successors = component_graph.successors(grid_component.component_id)
-        if not grid_successors:
-            raise ComponentNotFound("No components found in the component graph.")
+        grid_successors = self._get_grid_component_successors()
 
         if len(grid_successors) == 1:
             grid_meter = next(iter(grid_successors))

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)