Forward zero power requests always to the microgrid API

Only non-zero requests should be rejected if they fall within the
exclusion bounds.

Sending zero requests to the api informs the api that we are not
interested in these batteries, and it is free to start its pulse
heating algorithm, etc. immediately, if necessary.

Signed-off-by: Sahas Subramanian <[email protected]>

Author: shsms

src/frequenz/sdk/actor/power_distributing/_distribution_algorithm/_distribution_algorithm.py

@@ -401,6 +401,8 @@ def _distribute_power(  # pylint: disable=too-many-arguments
 
         for inverter_id, deficit in deficits.items():
             while not is_close_to_zero(deficit) and deficit < 0.0:
+                if not excess_reserved:
+                    break
                 take_from = max(excess_reserved.items(), key=lambda item: item[1])
                 if is_close_to_zero(take_from[1]) or take_from[1] < 0.0:
                     break

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

@@ -26,6 +26,7 @@
 import grpc
 from frequenz.channels import Peekable, Receiver, Sender
 
+from ..._internal._math import is_close_to_zero
 from ...actor import ChannelRegistry
 from ...actor._decorator import actor
 from ...microgrid import ComponentGraph, connection_manager
@@ -329,6 +330,7 @@ async def run(self) -> None:
             try:
                 distribution = self._get_power_distribution(request, pairs_data)
             except ValueError as err:
+                _logger.exception("Couldn't distribute power")
                 error_msg = f"Couldn't distribute power, error: {str(err)}"
                 await self._send_result(
                     request.namespace, Error(request=request, msg=str(error_msg))
@@ -475,6 +477,12 @@ def _check_request(
                 return Error(request=request, msg=msg)
 
         bounds = self._get_bounds(pairs_data)
+
+        # Zero power requests are always forwarded to the microgrid API, even if they
+        # are outside the exclusion bounds.
+        if is_close_to_zero(request.power):
+            return None
+
         if request.adjust_power:
             # Automatic power adjustments can only bring down the requested power down
             # to the inclusion bounds.

tests/actor/power_distributing/test_power_distributing.py

@@ -155,6 +155,103 @@ async def test_power_distributor_one_user(self, mocker: MockerFixture) -> None:
         assert result.excess_power == approx(200.0)
         assert result.request == request
 
+    async def test_power_distributor_exclusion_bounds(
+        self, mocker: MockerFixture
+    ) -> None:
+        """Test if power distributing actor rejects non-zero requests in exclusion bounds."""
+        mockgrid = MockMicrogrid(grid_meter=False)
+        mockgrid.add_batteries(2)
+        await mockgrid.start(mocker)
+        await self.init_component_data(mockgrid)
+
+        await mockgrid.mock_client.send(
+            battery_msg(
+                9,
+                soc=Metric(60, Bound(20, 80)),
+                capacity=Metric(98000),
+                power=PowerBounds(-1000, -300, 300, 1000),
+            )
+        )
+        await mockgrid.mock_client.send(
+            battery_msg(
+                19,
+                soc=Metric(60, Bound(20, 80)),
+                capacity=Metric(98000),
+                power=PowerBounds(-1000, -300, 300, 1000),
+            )
+        )
+
+        channel = Broadcast[Request]("power_distributor")
+        channel_registry = ChannelRegistry(name="power_distributor")
+
+        attrs = {
+            "get_working_batteries.return_value": microgrid.battery_pool().battery_ids
+        }
+        mocker.patch(
+            "frequenz.sdk.actor.power_distributing.power_distributing.BatteryPoolStatus",
+            return_value=MagicMock(spec=BatteryPoolStatus, **attrs),
+        )
+
+        mocker.patch("asyncio.sleep", new_callable=AsyncMock)
+        battery_status_channel = Broadcast[BatteryStatus]("battery_status")
+        distributor = PowerDistributingActor(
+            requests_receiver=channel.new_receiver(),
+            channel_registry=channel_registry,
+            battery_status_sender=battery_status_channel.new_sender(),
+        )
+
+        ## zero power requests should pass through despite the exclusion bounds.
+        request = Request(
+            namespace=self._namespace,
+            power=0.0,
+            batteries={9, 19},
+            request_timeout_sec=SAFETY_TIMEOUT,
+        )
+
+        await channel.new_sender().send(request)
+        result_rx = channel_registry.new_receiver(self._namespace)
+
+        done, pending = await asyncio.wait(
+            [asyncio.create_task(result_rx.receive())],
+            timeout=SAFETY_TIMEOUT,
+        )
+
+        assert len(pending) == 0
+        assert len(done) == 1
+
+        result: Result = done.pop().result()
+        assert isinstance(result, Success)
+        assert result.succeeded_power == approx(0.0)
+        assert result.excess_power == approx(0.0)
+        assert result.request == request
+
+        ## non-zero power requests that fall within the exclusion bounds should be
+        ## rejected.
+        request = Request(
+            namespace=self._namespace,
+            power=300.0,
+            batteries={9, 19},
+            request_timeout_sec=SAFETY_TIMEOUT,
+        )
+
+        await channel.new_sender().send(request)
+        result_rx = channel_registry.new_receiver(self._namespace)
+
+        done, pending = await asyncio.wait(
+            [asyncio.create_task(result_rx.receive())],
+            timeout=SAFETY_TIMEOUT,
+        )
+
+        assert len(pending) == 0
+        assert len(done) == 1
+
+        result = done.pop().result()
+        assert isinstance(result, OutOfBounds)
+        assert result.bounds == PowerBounds(-1000, -600, 600, 1000)
+        assert result.request == request
+
+        await distributor._stop_actor()
+
     async def test_battery_soc_nan(self, mocker: MockerFixture) -> None:
         """Test if battery with SoC==NaN is not used."""
         mockgrid = MockMicrogrid(grid_meter=False)