Issue 199: One way communication and broadcast action [WIP]

Author: Mark2000

docs/source/release_notes.rst

@@ -26,6 +26,9 @@ Development Version
 * Improve performance of :class:`~bsk_rl.obs.Eclipse` observations by about 95%.
 * Logs a warning if the initial battery charge or buffer level is incompatible with its capacity.
 * Optimize communication when all satellites are communicating with each other.
+* Allows communication to be one-way. Adds a :class:`~bsk_rl.act.Broadcast` action
+  that can be used with :class:`~bsk_rl.comm.BroadcastCommunication` to only communicate
+  data when the action has been called.
 
 
 

src/bsk_rl/act/discrete_actions.py

@@ -17,7 +17,6 @@
 
 
 class DiscreteActionBuilder(ActionBuilder):
-
     def __init__(self, satellite: "Satellite") -> None:
         """Processes actions for a discrete action space.
 
@@ -302,5 +301,34 @@ def set_action_override(
         return self.image(action, prev_action_key)
 
 
+class Broadcast(DiscreteAction):
+    def __init__(
+        self,
+        name: str = "action_broadcast",
+        duration: Optional[float] = None,
+    ):
+        """Action to broadcast data to all satellites in the simulation.
+
+        Args:
+            name: Action name.
+        """
+        super().__init__(name=name, n_actions=1)
+        if duration is None:
+            duration = 1e9
+        self.duration = duration
+
+    def reset_post_sim_init(self) -> None:
+        """Log previous action key."""
+        super().reset_post_sim_init()
+        self.broadcast_pending = False
+
+    def set_action(self, prev_action_key=None) -> str:
+        self.broadcast_pending = True
+        self.satellite.update_timed_terminal_event(
+            self.simulator.sim_time + self.duration, info=f"for broadcast"
+        )
+        return self.name
+
+
 __doc_title__ = "Discrete Backend"
 __all__ = ["DiscreteActionBuilder"]

src/bsk_rl/comm/communication.py

@@ -3,7 +3,7 @@
 import logging
 from abc import ABC, abstractmethod
 from copy import copy
-from itertools import combinations
+from itertools import permutations
 from typing import TYPE_CHECKING
 
 import numpy as np
@@ -47,7 +47,7 @@ def link_satellites(self, satellites: list["Satellite"]) -> None:
 
     @abstractmethod  # pragma: no cover
     def communication_pairs(self) -> list[tuple["Satellite", "Satellite"]]:
-        """List pairs of satellite that should share data.
+        """List pairs of satellite that should share data, in the form (sender, recipient).
 
         To define a new communication type, this method must be implemented.
         """
@@ -68,12 +68,13 @@ def communicate(self) -> None:
                 f"Communicating data between {len(communication_pairs)} pairs of satellites"
             )
 
-        if len(communication_pairs) == comb(len(self.satellites), 2):
+        if len(communication_pairs) == 2 * comb(len(self.satellites), 2):
             self._communicate_all()
         else:
-            for sat_1, sat_2 in communication_pairs:
-                sat_1.data_store.stage_communicated_data(sat_2.data_store.data)
-                sat_2.data_store.stage_communicated_data(sat_1.data_store.data)
+            for sat_sender, sat_receiver in communication_pairs:
+                sat_receiver.data_store.stage_communicated_data(
+                    sat_sender.data_store.data
+                )
             for satellite in self.satellites:
                 satellite.data_store.update_with_communicated_data()
 
@@ -116,7 +117,7 @@ def __init__(self, *args, **kwargs) -> None:
 
     def communication_pairs(self) -> list[tuple["Satellite", "Satellite"]]:
         """Return all possible communication pairs."""
-        return list(combinations(self.satellites, 2))
+        return list(permutations(self.satellites, 2))
 
 
 class LOSCommunication(CommunicationMethod):
@@ -177,6 +178,7 @@ def communication_pairs(self) -> list[tuple["Satellite", "Satellite"]]:
             for sat_2, logger in logs.items():
                 if any(logger.hasAccess):
                     pairs.append((sat_1, sat_2))
+                    pairs.append((sat_2, sat_1))
         return pairs
 
     def communicate(self) -> None:
@@ -208,7 +210,7 @@ def communication_pairs(self) -> list[tuple["Satellite", "Satellite"]]:
         pairs = []
         n_components, labels = connected_components(graph, directed=False)
         for comp in range(n_components):
-            for i_sat_1, i_sat_2 in combinations(np.where(labels == comp)[0], 2):
+            for i_sat_1, i_sat_2 in permutations(np.where(labels == comp)[0], 2):
                 pairs.append((self.satellites[i_sat_1], self.satellites[i_sat_2]))
         return pairs
 
@@ -222,4 +224,30 @@ class LOSMultiCommunication(MultiDegreeCommunication, LOSCommunication):
     pass
 
 
+class BroadcastCommunication(CommunicationMethod):
+    def communication_pairs(self) -> list[tuple["Satellite", "Satellite"]]:
+        """Return pairs of satellites that used broadcast action."""
+        broadcasters = []
+        for satellite in self.satellites:
+            if any(
+                hasattr(act, "broadcast_pending") and act.broadcast_pending
+                for act in satellite.action_builder.action_spec
+            ):
+                broadcasters.append(satellite)
+
+        pairs = super().communication_pairs()
+        pairs = [
+            (sat_sender, sat_receiver)
+            for sat_sender, sat_receiver in pairs
+            if sat_sender in broadcasters
+        ]
+
+        for satellite in broadcasters:
+            for act in satellite.action_builder.action_spec:
+                if hasattr(act, "broadcast_pending"):
+                    act.broadcast_pending = False
+
+        return pairs
+
+
 __all__ = []

tests/unittest/comm/test_communication.py

@@ -21,12 +21,9 @@ def test_communicate(self):
         comms.last_communication_time = 0.0
         comms.link_satellites(mock_sats)
         comms.communication_pairs = MagicMock(
-            return_value=[(mock_sats[1], mock_sats[0])]
+            return_value=[(mock_sats[0], mock_sats[1])]
         )
         comms.communicate()
-        mock_sats[0].data_store.stage_communicated_data.assert_called_once_with(
-            mock_sats[1].data_store.data
-        )
         mock_sats[1].data_store.stage_communicated_data.assert_called_once_with(
             mock_sats[0].data_store.data
         )