sequence 0.8.5.dev81472917__tar.gz → 0.8.5.dev217420613__tar.gz

{sequence-0.8.5.dev81472917 → sequence-0.8.5.dev217420613}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sequence
-Version: 0.8.5.dev81472917
+Version: 0.8.5.dev217420613
 Summary: Simulator of QUantum Network Communication (SeQUeNCe) is an open-source tool that allows modeling of quantum networks including photonic network components, control protocols, and applications.
 Keywords: quantum,network,discrete,event,simulator
 Author: Xiaoliang Wu, Joaquin Chung, Alexander Kolar, Alexander Kiefer, Eugene Wang, Tian Zhong, Rajkumar Kettimuthu, Martin Suchara, Robert Hayek, Ansh Singal, Caitao Zhan

{sequence-0.8.5.dev81472917 → sequence-0.8.5.dev217420613}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sequence"
-version = "0.8.5.dev81472917"
+version = "0.8.5.dev217420613"
 authors = [
     { name = "Xiaoliang Wu, Joaquin Chung, Alexander Kolar, Alexander Kiefer, Eugene Wang, Tian Zhong, Rajkumar Kettimuthu, Martin Suchara, Robert Hayek, Ansh Singal, Caitao Zhan", email = "czhan@anl.gov" }
 ]

{sequence-0.8.5.dev81472917 → sequence-0.8.5.dev217420613}/sequence/components/bsm.py

@@ -678,8 +678,8 @@ class SingleHeraldedBSM(BSM):
                 log.logger.debug(f'{self.name}: photonic BSM failed')
             else:
                 p0, p1 = self.photons
-                # if both memory successfully emit the photon in this round (consider memory emission inefficiency)
                 if self.get_generator().random() > p0.loss and self.get_generator().random() > p1.loss:
+                    # if both photons successfully arrive (not lost in memory or optical fiber) and the BSM is successful
                     for idx, photon in enumerate(self.photons):
                         detector = self.detectors[idx]
                         detector.get(photon)

{sequence-0.8.5.dev81472917 → sequence-0.8.5.dev217420613}/sequence/components/memory.py

@@ -128,7 +128,7 @@ class MemoryArray(Entity):
         
         Args:
             name (str): name of memory
-        Return:
+        Returns:
             (Memory): the memory object
         """
         index = self.memory_name_to_index.get(name, -1)
@@ -463,7 +463,7 @@ class Memory(Entity):
     def get_bds_fidelity(self) -> float:
         """Will get the fidelity from the BDS state
 
-        Return:
+        Returns:
             (float): the fidelity of the BDS state
         """
         state_obj = self.timeline.quantum_manager.get(self.qstate_key)

{sequence-0.8.5.dev81472917 → sequence-0.8.5.dev217420613}/sequence/entanglement_management/generation/single_heralded.py

@@ -22,13 +22,29 @@ if TYPE_CHECKING:
 
 @EntanglementGenerationA.register(SINGLE_HERALDED)
 class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
+    """
+    Class for single heralded entanglement generation protocol A.
+    This protocol is used on the two end nodes of the entanglement generation process.
+
+    Attributes:
+        owner (Node): node that protocol instance is attached to.
+        name (str): label for protocol instance.
+        middle (str): name of the middle BSM node.
+        other (str): name of the other end node.
+        memory (Memory): memory object used for entanglement generation.
+        raw_fidelity (float): the raw fidelity of generated entangled pair.
+        raw_epr_errors (list[float]): the raw EPR pair Pauli error rates in X, Y, Z order.
+        bsm_res (list[int]): the BSM measurement results from the middle BSM node.
+    """
     def __init__(self, owner: Node, name: str, middle: str, other: str, memory: Memory,
                  raw_fidelity: float = None, raw_epr_errors: list[float] = None):
         super().__init__(owner, name, middle, other, memory)
 
         self.protocol_type = SINGLE_HERALDED
-        assert QuantumManager.get_active_formalism() == BELL_DIAGONAL_STATE_FORMALISM, \
-            f"Single Heralded Entanglement generation protocol only supports Bell diagonal state formalism; got {QuantumManager.get_active_formalism()}"
+        active_formalism = QuantumManager.get_active_formalism()
+        assert_message = ("Single Heralded Entanglement generation protocol only" 
+                          f"supports Bell diagonal state formalism; got {active_formalism}")
+        assert active_formalism == BELL_DIAGONAL_STATE_FORMALISM, assert_message
 
         if raw_fidelity:
             self.raw_fidelity = raw_fidelity
@@ -40,8 +56,7 @@ class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
         if self.raw_epr_errors is None:
             self.raw_epr_errors = [1 / 3, 1 / 3, 1 / 3]
         if self.raw_epr_errors:
-            assert len(self.raw_epr_errors) == 3, \
-                "Raw EPR pair pauli error list should have three elements in X, Y, Z order."
+            assert len(self.raw_epr_errors) == 3, "Raw EPR pair pauli error list should have three elements in X, Y, Z order."
 
         self.bsm_res = [0, 0]
 
@@ -130,8 +145,7 @@ class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
 
         msg_type = msg.msg_type
 
-        log.logger.debug("{} {} received message from node {} of type {}, round={}".format(
-            self.owner.name, self.name, src, msg.msg_type, self.ent_round))
+        log.logger.debug(f"{self.owner.name} {self.name} received message from node {src} of type {msg.msg_type}, round={self.ent_round}")
 
         if msg_type is GenerationMsgType.NEGOTIATE:  # primary -> non-primary
             # configure params
@@ -141,8 +155,7 @@ class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
 
             # get time for first excite event
             memory_excite_time = self.memory.next_excite_time
-            min_time = max(self.owner.timeline.now(),
-                           memory_excite_time) + other_qc_delay - self.qc_delay + cc_delay  # cc_delay time for NEGOTIATE_ACK
+            min_time = max(self.owner.timeline.now(), memory_excite_time) + other_qc_delay - self.qc_delay + cc_delay  # cc_delay time for NEGOTIATE_ACK
             emit_time = self.owner.schedule_qubit(self.middle, min_time)  # used to send memory
             self.expected_time = emit_time + self.qc_delay  # expected time for middle BSM node to receive the photon
 
@@ -154,17 +167,13 @@ class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
 
             # send negotiate_ack
             other_emit_time = emit_time + self.qc_delay - other_qc_delay
-            message = EntanglementGenerationMessage(GenerationMsgType.NEGOTIATE_ACK,
-                                                    self.remote_protocol_name,
-                                                    protocol_type=self.protocol_type,
-                                                    emit_time=other_emit_time)
+            message = EntanglementGenerationMessage(GenerationMsgType.NEGOTIATE_ACK, self.remote_protocol_name,
+                                                    self.protocol_type, emit_time=other_emit_time)
             self.owner.send_message(src, message)
 
-            # schedule start if necessary (current is first round, need second round),
-            # else schedule update_memory (currently second round)
+            # schedule start if necessary (current is first round, need second round), else schedule update_memory (currently second round)
             # TODO: base future start time on resolution
-            future_start_time = self.expected_time + self.owner.cchannels[
-                self.middle].delay + 10  # delay is for sending the BSM_RES to end nodes, 10 is a small gap
+            future_start_time = self.expected_time + self.owner.cchannels[self.middle].delay + 10  # delay is for sending the BSM_RES to end nodes, 10 is a small gap
             if self.ent_round == 1:
                 process = Process(self, "start", [])  # for the second round
             else:
@@ -183,8 +192,7 @@ class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
 
             # schedule emit
             emit_time = self.owner.schedule_qubit(self.middle, msg.emit_time)
-            assert emit_time == msg.emit_time, \
-                f"Invalid eg emit times {emit_time} {msg.emit_time} {self.owner.timeline.now()}"
+            assert emit_time == msg.emit_time, f"Invalid eg emit times {emit_time} {msg.emit_time} {self.owner.timeline.now()}"
 
             process = Process(self, "emit_event", [])
             event = Event(msg.emit_time, process)
@@ -210,7 +218,7 @@ class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
             resolution = msg.resolution
 
             log.logger.debug("{} received MEAS_RES={} at time={:,}, expected={:,}, resolution={}, round={}".format(
-                self.owner.name, detector, time, self.expected_time, resolution, self.ent_round))
+                              self.owner.name, detector, time, self.expected_time, resolution, self.ent_round))
 
             if valid_trigger_time(time, self.expected_time, resolution):
                 self.bsm_res[detector] += 1
@@ -244,9 +252,7 @@ class SingleHeraldedB(EntanglementGenerationB):
             bsm (SingleAtomBSM or SingleHeraldedBSM): bsm object calling method.
             info (Dict[str, any]): information passed from bsm.
         """
-        assert bsm.encoding == SINGLE_HERALDED, \
-            "SingleHeraldedB should only be used with SingleHeraldedBSM."
-
+        assert bsm.encoding == SINGLE_HERALDED, "SingleHeraldedB should only be used with SingleHeraldedBSM."
         assert info['info_type'] == 'BSM_res'
 
         res = info['res']
@@ -254,10 +260,6 @@ class SingleHeraldedB(EntanglementGenerationB):
         resolution = bsm.resolution
 
         for node in self.others:
-            message = EntanglementGenerationMessage(GenerationMsgType.MEAS_RES,
-                                                    receiver=None,
-                                                    protocol_type=self.protocol_type,
-                                                    detector=res,
-                                                    time=time,
-                                                    resolution=resolution)
+            message = EntanglementGenerationMessage(GenerationMsgType.MEAS_RES, None, self.protocol_type,
+                                                    detector=res, time=time, resolution=resolution)
             self.owner.send_message(node, message)

{sequence-0.8.5.dev81472917 → sequence-0.8.5.dev217420613}/sequence/kernel/quantum_manager.py

@@ -551,8 +551,8 @@ class QuantumManagerDensity(QuantumManager):
                 key = keys[0]
                 num_states = len(all_keys)
                 state_index = all_keys.index(key)
-                state_0, state_1, prob_0 = \
-                    measure_entangled_state_with_cache_density(tuple(map(tuple, state)), state_index, num_states)
+                state_0, state_1, prob_0 = measure_entangled_state_with_cache_density(tuple(map(tuple, state)), 
+                                                                                      state_index, num_states)
                 if meas_samp < prob_0:
                     new_state = array(state_0, dtype=complex)
                     result = 0
@@ -795,15 +795,13 @@ class QuantumManagerDensityFock(QuantumManager):
                 key = keys[0]
                 num_states = len(all_keys)
                 state_index = all_keys.index(key)
-                states, probs = \
-                    measure_entangled_state_with_cache_fock_density(state_tuple, state_index, num_states, povm_tuple,
-                                                                    self.truncation)
+                states, probs = measure_entangled_state_with_cache_fock_density(state_tuple, state_index, num_states, 
+                                                                                povm_tuple, self.truncation)
 
         else:
             indices = tuple([all_keys.index(key) for key in keys])
-            states, probs = \
-                measure_multiple_with_cache_fock_density(state_tuple, indices, len(all_keys), povm_tuple,
-                                                         self.truncation)
+            states, probs = measure_multiple_with_cache_fock_density(state_tuple, indices, len(all_keys), 
+                                                                     povm_tuple, self.truncation)
 
         # calculate result based on measurement sample.
         prob_sum = cumsum(probs)

{sequence-0.8.5.dev81472917 → sequence-0.8.5.dev217420613}/sequence/kernel/quantum_utils.py

@@ -5,11 +5,12 @@ These should not be used directly, but accessed by a QuantumManager instance or
 """
 
 from functools import lru_cache
+import warnings
 from math import sqrt
 import random
 import math
 from numpy import array, kron, identity, zeros, trace, outer, eye, clip
-from scipy.linalg import sqrtm
+from scipy.linalg import LinAlgWarning, sqrtm
 from ..constants import EPSILON
 
 
@@ -34,8 +35,8 @@ def measure_state_with_cache(state: tuple[complex, complex], basis: tuple[tuple[
 
 
 @lru_cache(maxsize=1000)
-def measure_entangled_state_with_cache(state: tuple[complex], basis: tuple[tuple[complex]], state_index: int, num_states: int) \
-        -> tuple[array, array, float]:
+def measure_entangled_state_with_cache(state: tuple[complex], basis: tuple[tuple[complex]], 
+                                       state_index: int, num_states: int) -> tuple[array, array, float]:
 
     state = array(state)
     u = array(basis[0], dtype=complex)
@@ -72,8 +73,8 @@ def measure_entangled_state_with_cache(state: tuple[complex], basis: tuple[tuple
 
 
 @lru_cache(maxsize=1000)
-def measure_multiple_with_cache(state: tuple[complex], basis: tuple[tuple[complex]], length_diff: int) \
-        -> tuple[list[array], list[float]]:
+def measure_multiple_with_cache(state: tuple[complex], basis: tuple[tuple[complex]], 
+                                length_diff: int) -> tuple[list[array], list[float]]:
 
     state = array(state)
     # construct measurement operators, projectors, and probabilities of measurement
@@ -109,8 +110,8 @@ def measure_state_with_cache_ket(state: tuple[complex, complex]) -> float:
 
 
 @lru_cache(maxsize=1000)
-def measure_entangled_state_with_cache_ket(state: tuple[complex], state_index: int, num_states: int) \
-        -> tuple[array, array, float]:
+def measure_entangled_state_with_cache_ket(state: tuple[complex], state_index: int, 
+                                           num_states: int) -> tuple[array, array, float]:
 
     state = array(state)
     # generate measurement operators. measure qubit at state_index, with the measured qubit traced out
@@ -136,8 +137,8 @@ def measure_entangled_state_with_cache_ket(state: tuple[complex], state_index: i
 
 
 @lru_cache(maxsize=1000)
-def measure_multiple_with_cache_ket(state: tuple[complex], num_states: int, length_diff: int) \
-        -> tuple[list[array], list[float]]:
+def measure_multiple_with_cache_ket(state: tuple[complex], num_states: int, 
+                                    length_diff: int) -> tuple[list[array], list[float]]:
 
     state = array(state)
     basis_count = 2 ** num_states
@@ -178,8 +179,8 @@ def measure_state_with_cache_density(state: tuple[tuple[complex, complex]]) -> f
 
 
 @lru_cache(maxsize=1000)
-def measure_entangled_state_with_cache_density(state: tuple[tuple[complex]], state_index: int, num_states: int) \
-        -> tuple[array, array, float]:
+def measure_entangled_state_with_cache_density(state: tuple[tuple[complex]], state_index: int, 
+                                               num_states: int) -> tuple[array, array, float]:
 
     state = array(state)
 
@@ -211,8 +212,8 @@ def measure_entangled_state_with_cache_density(state: tuple[tuple[complex]], sta
 
 
 @lru_cache(maxsize=1000)
-def measure_multiple_with_cache_density(state: tuple[tuple[complex]], num_states: int, length_diff: int) \
-        -> tuple[list[array], list[float]]:
+def measure_multiple_with_cache_density(state: tuple[tuple[complex]], 
+                                        num_states: int, length_diff: int) -> tuple[list[array], list[float]]:
 
     state = array(state)
     basis_count = 2 ** num_states
@@ -242,8 +243,8 @@ def measure_multiple_with_cache_density(state: tuple[tuple[complex]], num_states
 
 
 @lru_cache(maxsize=1000)
-def measure_state_with_cache_fock_density(state: tuple[tuple[complex]], povms: tuple[tuple[tuple[complex]]]) \
-        -> tuple[list[array], list[float]]:
+def measure_state_with_cache_fock_density(state: tuple[tuple[complex]], 
+                                          povms: tuple[tuple[tuple[complex]]]) -> tuple[list[array], list[float]]:
     state = array(state)
     povms = [array(povm) for povm in povms]
 
@@ -256,7 +257,9 @@ def measure_state_with_cache_fock_density(state: tuple[tuple[complex]], povms: t
         if prob_list[i] <= 0:
             state_post_meas = None
         else:
-            measure_op = sqrtm(povms[i])
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore", category=LinAlgWarning)
+                measure_op = sqrtm(povms[i])
             state_post_meas = (measure_op @ state @ measure_op) / prob_list[i]
 
         state_list.append(state_post_meas)
@@ -265,9 +268,9 @@ def measure_state_with_cache_fock_density(state: tuple[tuple[complex]], povms: t
 
 
 @lru_cache(maxsize=1000)
-def measure_entangled_state_with_cache_fock_density(state: tuple[tuple[complex]], system_index: int, num_systems: int,
-                                                    povms: tuple[tuple[tuple[complex]]], truncation: int = 1) \
-        -> tuple[list[array], list[float]]:
+def measure_entangled_state_with_cache_fock_density(state: tuple[tuple[complex]], system_index: int, 
+                                                    num_systems: int, povms: tuple[tuple[tuple[complex]]], 
+                                                    truncation: int = 1) -> tuple[list[array], list[float]]:
 
     """Measure one subsystem of a larger composite system.
 
@@ -306,7 +309,9 @@ def measure_entangled_state_with_cache_fock_density(state: tuple[tuple[complex]]
         if prob_list[i] <= 0:
             state_post_meas = None
         else:
-            measure_op = sqrtm(povm_list[i])
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore", category=LinAlgWarning)
+                measure_op = sqrtm(povm_list[i])
             state_post_meas = (measure_op @ state @ measure_op) / prob_list[i]
 
         state_list.append(state_post_meas)
@@ -315,9 +320,9 @@ def measure_entangled_state_with_cache_fock_density(state: tuple[tuple[complex]]
 
 
 @lru_cache(maxsize=1000)
-def measure_multiple_with_cache_fock_density(state: tuple[tuple[complex]], indices: tuple[int], num_systems: int,
-                                             povms: tuple[tuple[tuple[complex]]], truncation: int = 1) \
-        -> tuple[list[array], list[float]]:
+def measure_multiple_with_cache_fock_density(state: tuple[tuple[complex]], indices: tuple[int], 
+                                             num_systems: int, povms: tuple[tuple[tuple[complex]]], 
+                                             truncation: int = 1) -> tuple[list[array], list[float]]:
 
     """Measure multiple subsystems of a larger composite system.
 
@@ -372,7 +377,9 @@ def measure_multiple_with_cache_fock_density(state: tuple[tuple[complex]], indic
         if prob_list[i] <= 0:
             state_post_meas = None
         else:
-            measure_op = sqrtm(povm_list[i])
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore", category=LinAlgWarning)
+                measure_op = sqrtm(povm_list[i])
             state_post_meas = (measure_op @ state @ measure_op) / prob_list[i]
 
         state_list.append(state_post_meas)
@@ -382,8 +389,8 @@ def measure_multiple_with_cache_fock_density(state: tuple[tuple[complex]], indic
 
 
 @lru_cache(maxsize=1000)
-def density_partial_trace(state: tuple[tuple[complex]], indices: tuple[int], num_systems: int, truncation: int = 1) \
-        -> array:
+def density_partial_trace(state: tuple[tuple[complex]], indices: tuple[int], 
+                          num_systems: int, truncation: int = 1) -> array:
 
     """Traces out subsystems systems at given indices.
 

sequence-0.8.5.dev217420613/sequence/network_management/__init__.py

@@ -0,0 +1,4 @@
+__all__ = ['routing_static', 'routing_distributed', 'forwarding', 'reservation', 'network_manager']
+
+def __dir__():
+    return sorted(__all__)

sequence-0.8.5.dev217420613/sequence/network_management/forwarding.py

@@ -0,0 +1,102 @@
+"""Forwarding protocol and forwarding message.
+
+This module defines the `ForwardingProtocol` and `ForwardingMessage` classes.
+"""
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from ..topology.node import Node
+
+from enum import Enum
+from ..protocol import StackProtocol
+from ..message import Message
+from ..utils import log
+
+
+class ForwardingMessage(Message):
+    """Message used for communications between forwarding protocol instances.
+
+    Attributes:
+        msg_type (Enum): type of message, required by base `Message` class.
+        receiver (str): name of destination protocol instance.
+        payload (Message): message to be delivered to destination.
+    """
+
+    def __init__(self, msg_type: Enum, receiver: str, payload: Message):
+        super().__init__(msg_type, receiver)
+        self.payload = payload
+
+    def __str__(self):
+        return f"type={self.msg_type}, receiver={self.receiver}, payload={self.payload}"
+
+
+class ForwardingProtocol(StackProtocol):
+    """Class to forward messages based on the forwarding table (from the `NetworkManager`) in the routing protocol.
+
+    Attributes:
+        owner (Node): node that protocol instance is attached to.
+        name (str): label for protocol instance.
+    """
+
+    def __init__(self, owner: "Node", name: str):
+        """Constructor for forwarding protocol.
+
+        Args:
+            owner (Node): node protocol is attached to.
+            name (str): name of protocol instance.
+        """
+        super().__init__(owner, name)
+
+    @property
+    def forwarding_table(self) -> dict[str, str]:
+        """Returns the forwarding table."""
+        return self.owner.network_manager.get_forwarding_table()
+
+    def received_message(self, src: str, msg: Message):
+        """Method to directly receive messages from node (should not be used)."""
+
+        raise Exception("Forwarding protocol should not call this function")
+
+    def init(self):
+        pass
+
+    def push(self, dst: str, msg: Message, next_hop: str = None):
+        """Method to receive message from upper protocols.
+
+        Routing packages the message and forwards it to the next node in the optimal path (determined by the forwarding table).
+
+        Args:
+            dst (str): name of destination node. If not None, resort to the forwarding table to get the next hop.
+            msg (Message): message to relay.
+            next_hop (str): name of next hop. If dst is None, next_hop shouldn't be None. next_hop directly tells the next hop.
+
+        Side Effects:
+            Will invoke `push` method of lower protocol or network manager.
+        """
+        assert dst != self.owner.name
+        forwarding_table = self.forwarding_table
+        new_msg = ForwardingMessage(Enum, self.name, msg)
+        if dst:                                     # if dst is not None, use the forwarding table
+            next_hop = forwarding_table.get(dst, None)
+            if next_hop:
+                self._push(dst=next_hop, msg=new_msg)
+            else:
+                log.logger.error(f'No forwarding rule for dst {dst} at node {self.owner.name}')
+        elif next_hop:                              # if next_hop is not None, use next_hop
+            self._push(dst=next_hop, msg=new_msg)  
+        else:
+            raise Exception('Both dst and next_hop are None!')
+
+    def pop(self, src: str, msg: ForwardingMessage):
+        """Message to receive reservation messages.
+
+        Messages are forwarded to the upper protocol.
+
+        Args:
+            src (str): node sending the message.
+            msg (ForwardingMessage): message received.
+
+        Side Effects:
+            Will call `pop` method of higher protocol.
+        """
+        self._pop(src=src, msg=msg.payload)

{sequence-0.8.5.dev81472917 → sequence-0.8.5.dev217420613}/sequence/network_management/network_manager.py

@@ -12,7 +12,10 @@ if TYPE_CHECKING:
     from ..protocol import StackProtocol
 
 from ..message import Message
-from .routing import StaticRoutingProtocol
+from ..protocol import Protocol
+from .routing_distributed import DistributedRoutingProtocol
+from .routing_static import StaticRoutingProtocol
+from .forwarding import ForwardingProtocol
 from .reservation import ResourceReservationProtocol, ResourceReservationMessage, RSVPMsgType
 from ..utils import log
 
@@ -44,6 +47,8 @@ class NetworkManager:
         name (str): name of the network manager instance.
         owner (QuantumRouter): node that protocol instance is attached to.
         protocol_stack (list[StackProtocol]): network manager protocol stack.
+        forwarding_table (dict[str, str]): mapping of destination node names to name of node for next hop.
+        routing_protocol (Protocol): routing protocol
     """
 
     def __init__(self, owner: "QuantumRouter", protocol_stack: "list[StackProtocol]"):
@@ -59,6 +64,8 @@ class NetworkManager:
         self.owner = owner
         self.protocol_stack = protocol_stack
         self.load_stack(protocol_stack)
+        self.forwarding_table = {}
+        self.routing_protocol = None
 
     def load_stack(self, stack: "list[StackProtocol]"):
         """Method to load a defined protocol stack.
@@ -143,17 +150,24 @@ class NetworkManager:
 
         self.protocol_stack[-1].push(responder, start_time, end_time, memory_size, target_fidelity, entanglement_number, identity)
 
-    def update_forwarding_table(self, forwarding_table: dict) -> None:
-        """Method to set the forwarding table in the routing_protocol in the network manager's protocol stack.
+    def set_forwarding_table(self, forwarding_table: dict) -> None:
+        """Method to set the forwarding table in the network manager
 
         Args:
             forwarding_table (dict): the forwarding table for this node, where the key is the destination node name
                                      and the value is the next hop
         """
-        log.logger.info(f"{self.owner.name} update forwarding table: {forwarding_table}")
-        static_routing_protocol = self.protocol_stack[0]   # [0] is the static routing protocol
-        for dst, next_hop in forwarding_table.items():
-            static_routing_protocol.update_forwarding_rule(dst, next_hop)
+        log.logger.info(f"{self.owner.name} set forwarding table: {forwarding_table}")
+        self.forwarding_table = forwarding_table
+
+    def get_forwarding_table(self) -> dict[str, str]:
+        """Method to get the forwarding table in the network manager.
+
+        Returns:
+            dict[str, str]: the forwarding table for this node, where the key is the destination node name
+                            and the value is the next hop
+        """
+        return self.forwarding_table
 
     def get_reservation_protocol(self) -> ResourceReservationProtocol:
         """Method to get the resource reservation protocol in the network manager's protocol stack.
@@ -166,8 +180,24 @@ class NetworkManager:
                 return protocol
         raise ValueError("No resource reservation protocol found in the network manager's protocol stack")
 
+    def set_routing_protocol(self, routing_protocol: Protocol) -> None:
+        """Method to set the routing protocol in the network manager.
+
+        Args:
+            routing_protocol (Protocol): the routing protocol to set
+        """
+        self.routing_protocol = routing_protocol
+
+    def get_routing_protocol(self) -> Protocol:
+        """Method to get the routing protocol in the network manager.
+
+        Returns:
+            Protocol: the routing protocol in the network manager
+        """
+        return self.routing_protocol
+
 
-def NewNetworkManager(owner: "QuantumRouter", memory_array_name: str) -> "NetworkManager":
+def NewNetworkManager(owner: "QuantumRouter", memory_array_name: str, component_templates: dict = {}) -> "NetworkManager":
     """Function to create a new network manager.
 
     Will create a network manager with default protocol stack.
@@ -176,16 +206,27 @@ def NewNetworkManager(owner: "QuantumRouter", memory_array_name: str) -> "Networ
     Args:
         owner (QuantumRouter): node to attach network manager to.
         memory_array_name (str): name of the memory array component on owner.
+        routing_protocol_cls (type[Protocol]): routing protocol class to use for control plane.
 
     Returns:
         NetworkManager: network manager object created.
     """
     swapping_success_rate = 0.5
     manager = NetworkManager(owner, [])
-    routing = StaticRoutingProtocol(owner, owner.name + ".StaticRoutingProtocol", {})
+    routing = component_templates.get("routing", "static")
+    match routing:
+        case "static":
+            routing_protocol_cls = StaticRoutingProtocol
+        case "distributed":
+            routing_protocol_cls = DistributedRoutingProtocol
+        case _:
+            raise NotImplementedError(f"Routing protocol {routing} not implemented.")   
+    routing = routing_protocol_cls(owner, f"{routing_protocol_cls.__name__}")
+    manager.set_routing_protocol(routing)
+    forwarding_protocol = ForwardingProtocol(owner, owner.name + ".ForwardingProtocol")
     rsvp = ResourceReservationProtocol(owner, owner.name + ".RSVP", memory_array_name)
     rsvp.set_swapping_success_rate(swapping_success_rate)
-    routing.upper_protocols.append(rsvp)
-    rsvp.lower_protocols.append(routing)
-    manager.load_stack([routing, rsvp])
+    forwarding_protocol.upper_protocols.append(rsvp)
+    rsvp.lower_protocols.append(forwarding_protocol)
+    manager.load_stack([forwarding_protocol, rsvp])
     return manager

{sequence-0.8.5.dev81472917 → sequence-0.8.5.dev217420613}/sequence/network_management/reservation.py

@@ -101,7 +101,7 @@ def eg_req_func(protocols: list["EntanglementProtocol"], args: Arguments) -> Ent
     Args:
         protocols: the waiting protocols (wait for request)
         args: arguments from the node who sent the request
-    Return:
+    Returns:
         the selected protocol
     """
     name = args["name"]
@@ -155,7 +155,7 @@ def ep_req_func1(protocols, args: Arguments) -> BBPSSWProtocol:
     Args:
         protocols (list): a list of waiting protocols
         args (dict): the arguments
-    Return:
+    Returns:
         the selected protocol
     """
     remote0 = args["remote0"]
@@ -268,7 +268,7 @@ def es_req_func(protocols: list["EntanglementProtocol"], args: Arguments) -> Ent
     Args:
         protocols (list): a list of waiting protocols
         args (dict): the arguments
-    Return:
+    Returns:
         the selected protocol
     """
     target_memo = args["target_memo"]
@@ -472,7 +472,7 @@ class ResourceReservationProtocol(StackProtocol):
 
         Args:
             path (list[str]): a list of router names that goes from initiator to responder
-        Return:
+        Returns:
             str: the name of the next hop
         '''
         cur_index = path.index(self.owner.name)