Add a PVPool implementation (#914)

Author: shsms

RELEASE_NOTES.md

@@ -18,10 +18,14 @@
 
 - New `propose_power` and `power_status` methods have been added to the `EVChargerPool` similar to the `BatteryPool`.  These method interface with the `PowerManager` and `PowerDistributor`, which currently uses a first-come-first-serve algorithm to distribute power to EVs.
 
+- PV Power is now available from `microgrid.pv_pool().power`, and no longer from `microgrid.logical_meter().pv_power`.
+
 ## New Features
 
 - Warning messages are logged when multiple instances of `*Pool`s are created for the same set of batteries, with the same priority values.
 
+- A PV Pool, with `propose_power`, `power_status` and `power` methods similar to Battery and EV Pools.
+
 ## Bug Fixes
 
 - A bug was fixed where the grid fuse was not created properly and would end up with a `max_current` with type `float` instead of `Current`.

benchmarks/power_distribution/power_distributor.py

@@ -116,6 +116,7 @@ async def run_test(  # pylint: disable=too-many-locals
     power_result_channel = Broadcast[Result](name="power-result")
     async with PowerDistributingActor(
         component_category=ComponentCategory.BATTERY,
+        component_type=None,
         requests_receiver=power_request_channel.new_receiver(),
         results_sender=power_result_channel.new_sender(),
         component_pool_status_sender=battery_status_channel.new_sender(),

src/frequenz/sdk/_internal/_channels.py

@@ -9,6 +9,8 @@
 
 from frequenz.channels import Receiver
 
+from ._asyncio import cancel_and_await
+
 T_co = typing.TypeVar("T_co", covariant=True)
 
 
@@ -72,3 +74,7 @@ def has_value(self) -> bool:
     async def _run(self) -> None:
         async for value in self._receiver:
             self._latest_value = value
+
+    async def stop(self) -> None:
+        """Stop the cache."""
+        await cancel_and_await(self._task)

src/frequenz/sdk/actor/_power_managing/_power_managing_actor.py

@@ -12,7 +12,7 @@
 
 from frequenz.channels import Receiver, Sender, select, selected_from
 from frequenz.channels.timer import SkipMissedAndDrift, Timer
-from frequenz.client.microgrid import ComponentCategory
+from frequenz.client.microgrid import ComponentCategory, ComponentType, InverterType
 from typing_extensions import override
 
 from ...timeseries._base_types import SystemBounds
@@ -32,28 +32,37 @@ class PowerManagingActor(Actor):
 
     def __init__(  # pylint: disable=too-many-arguments
         self,
-        component_category: ComponentCategory,
         proposals_receiver: Receiver[Proposal],
         bounds_subscription_receiver: Receiver[ReportRequest],
         power_distributing_requests_sender: Sender[power_distributing.Request],
         power_distributing_results_receiver: Receiver[power_distributing.Result],
         channel_registry: ChannelRegistry,
+        *,
+        component_category: ComponentCategory,
+        component_type: ComponentType | None = None,
         # arguments to actors need to serializable, so we pass an enum for the algorithm
         # instead of an instance of the algorithm.
         algorithm: Algorithm = Algorithm.MATRYOSHKA,
     ):
         """Create a new instance of the power manager.
 
         Args:
-            component_category: The category of the component this power manager
-                instance is going to support.
             proposals_receiver: The receiver for proposals.
             bounds_subscription_receiver: The receiver for bounds subscriptions.
             power_distributing_requests_sender: The sender for power distribution
                 requests.
             power_distributing_results_receiver: The receiver for power distribution
                 results.
             channel_registry: The channel registry.
+            component_category: The category of the component this power manager
+                instance is going to support.
+            component_type: The type of the component of the given category that this
+                actor is responsible for.  This is used only when the component category
+                is not enough to uniquely identify the component.  For example, when the
+                category is `ComponentCategory.INVERTER`, the type is needed to identify
+                the inverter as a solar inverter or a battery inverter.  This can be
+                `None` when the component category is enough to uniquely identify the
+                component.
             algorithm: The power management algorithm to use.
 
         Raises:
@@ -65,6 +74,7 @@ def __init__(  # pylint: disable=too-many-arguments
             )
 
         self._component_category = component_category
+        self._component_type = component_type
         self._bounds_subscription_receiver = bounds_subscription_receiver
         self._power_distributing_requests_sender = power_distributing_requests_sender
         self._power_distributing_results_receiver = power_distributing_results_receiver
@@ -141,6 +151,12 @@ def _add_bounds_tracker(self, component_ids: frozenset[int]) -> None:
         elif self._component_category is ComponentCategory.EV_CHARGER:
             ev_charger_pool = microgrid.ev_charger_pool(component_ids)
             bounds_receiver = ev_charger_pool._system_power_bounds.new_receiver()
+        elif (
+            self._component_category is ComponentCategory.INVERTER
+            and self._component_type is InverterType.SOLAR
+        ):
+            pv_pool = microgrid.pv_pool(component_ids)
+            bounds_receiver = pv_pool._system_power_bounds.new_receiver()
         # pylint: enable=protected-access
         else:
             err = (

src/frequenz/sdk/actor/power_distributing/_component_managers/__init__.py

@@ -6,9 +6,11 @@
 from ._battery_manager import BatteryManager
 from ._component_manager import ComponentManager
 from ._ev_charger_manager import EVChargerManager
+from ._pv_inverter_manager import PVManager
 
 __all__ = [
     "BatteryManager",
     "ComponentManager",
     "EVChargerManager",
+    "PVManager",
 ]

src/frequenz/sdk/actor/power_distributing/_component_managers/_battery_manager.py

@@ -188,6 +188,10 @@ async def start(self) -> None:
     @override
     async def stop(self) -> None:
         """Stop the battery data manager."""
+        for bat_cache in self._battery_caches.values():
+            await bat_cache.stop()
+        for inv_cache in self._inverter_caches.values():
+            await inv_cache.stop()
         await self._component_pool_status_tracker.stop()
 
     @override
@@ -668,6 +672,13 @@ def _parse_result(
                     battery_ids,
                     request_timeout.total_seconds(),
                 )
+            except Exception:  # pylint: disable=broad-except
+                failed_power += distribution[inverter_id]
+                failed_batteries = failed_batteries.union(battery_ids)
+                _logger.exception(
+                    "Unknown error while setting power to batteries: %s",
+                    battery_ids,
+                )
 
         return failed_power, failed_batteries
 

src/frequenz/sdk/actor/power_distributing/_component_managers/_ev_charger_manager/_ev_charger_manager.py

@@ -92,6 +92,7 @@ async def distribute_power(self, request: Request) -> None:
     @override
     async def stop(self) -> None:
         """Stop the ev charger manager."""
+        await self._voltage_cache.stop()
         await self._component_pool_status_tracker.stop()
 
     def _get_ev_charger_ids(self) -> collections.abc.Set[int]:
@@ -330,16 +331,21 @@ async def _set_api_power(
                 succeeded_components.add(component_id)
 
             match task.exception():
-                case asyncio.CancelledError:
+                case asyncio.CancelledError():
                     _logger.warning(
                         "Timeout while setting power to EV charger %s", component_id
                     )
-                case grpc.aio.AioRpcError as err:
+                case grpc.aio.AioRpcError() as err:
                     _logger.warning(
                         "Error while setting power to EV charger %s: %s",
                         component_id,
                         err,
                     )
+                case Exception():
+                    _logger.exception(
+                        "Unknown error while setting power to EV charger: %s",
+                        component_id,
+                    )
         if failed_components:
             return PartialFailure(
                 failed_components=failed_components,

src/frequenz/sdk/actor/power_distributing/_component_managers/_pv_inverter_manager/__init__.py

@@ -0,0 +1,8 @@
+# License: MIT
+# Copyright © 2024 Frequenz Energy-as-a-Service GmbH
+
+"""Manage PV inverters for the power distributor."""
+
+from ._pv_inverter_manager import PVManager
+
+__all__ = ["PVManager"]