Add node.Splitter()

mnoptical/link.py

@@ -41,9 +41,15 @@ def __init__(self, src_node, dst_node, src_out_port=-1, dst_in_port=-1,
         def connect(prev, component):
             "Connect previous component to component"
             if prev != src_node:
+                if prev.next_component:
+                    raise ValueError(
+                        f'{self}: {prev} already connected to {prev.next_component}')
                 prev.next_component = component
                 prev.set_output_port(component, self, output_port=0)
             if component != dst_node:
+                if component.link:
+                    raise ValueError(
+                        f'{self}: {component} already used in {component.link}')
                 component.link = self
                 component.prev_component =  prev
                 component.set_input_port(prev, self, input_port=0)
@@ -145,7 +151,8 @@ def propagate(self, is_last_port=False, safe_switch=False):
         """
         first_component = self.boost_amp or self.spans[0][0]
         for optical_signal in self.optical_signals:
-            first_component.include_optical_signal_in(optical_signal, in_port=0)
+            state = optical_signal.loc_in_to_state[self]
+            first_component.include_optical_signal_in(optical_signal, **state, in_port=0)
         first_component.propagate(optical_signals=self.optical_signals,
                                   is_last_port=is_last_port,
                                   safe_switch=safe_switch)

mnoptical/network.py

@@ -18,59 +18,56 @@ def __init__(self):
 
         self.name_to_node = {}
 
-    def add_lt(self, name, transceivers=None, **params):
+    def add_node(self, name, cls, *args, nodes=None, **params):
+        """
+        Add node to network
+        :param name: name of node
+        :param cls: node class/constructor
+        :param nodes: list that node will be appended to
+        """
+        if nodes is None: nodes = []
+        if name in self.name_to_node:
+            raise ValueError(f"Network.add_node: node {name} already exists!")
+        node = cls(name, *args, **params)
+        self.name_to_node[name] = node
+        nodes.append(node)
+        self.topology[node] = []
+        return node
+
+    def add_lt(self, name, *args, cls=LineTerminal, **params):
         """
         Add lt node
         :param name: name of lt
         :param transceivers: transceivers of LT for automated instantiation
+        :param cls: optional LineTerminal class/constructor
         :return: added lt
         """
-        if name in self.name_to_node:
-            raise ValueError("Network.add_lt: lt with this name already exist!")
-        configs = {'name': name,
-                   'transceivers': transceivers}
-        configs.update(params)
-        lt = LineTerminal(**configs)
-        self.name_to_node[name] = lt
-        self.line_terminals.append(lt)
-        self.topology[lt] = []
-        return lt
+        return self.add_node(name, cls, *args, nodes=self.line_terminals,
+                             **params)
 
-    def add_roadm(self, name, **params):
+    def add_roadm(self, name, *args, cls=Roadm, **params):
         """
         Add a ROADM node.
         :param name: name of ROADM
+        :cls: optional Roadm class/constructor
         :return: added ROADM
         """
-        if name in self.name_to_node:
-            raise ValueError("Network.add_roadm: ROADM with this name already exist!!")
-        configs = {'name': name}
-        configs.update(params)
-        roadm = Roadm(**configs)
-        self.name_to_node[name] = roadm
-        self.roadms.append(roadm)
-        self.topology[roadm] = []
-        return roadm
+        return self.add_node(name, cls, *args, nodes=self.roadms,
+                             **params)
 
-    def add_amplifier(self, name, amplifier_type='EDFA', **params):
+    def add_amplifier(self, name, *args, cls=Amplifier, **params):
         """
         Add an Amplifier node.
         :param name: name of Amplifier
         :param amplifier_type: amplifier type (currently supporting only EDFA)
+        :param cls: optional Amplifier class/constructor
         :return: added Amplifier
         """
-        if name in self.name_to_node:
-            raise ValueError("Network.add_amplifier: Amplifier with this name already exist!! %s" % str(name))
-        configs = {'name': name,
-                   'amplifier_type': amplifier_type}
-        configs.update(params)
-        amplifier = Amplifier(**configs)
-        self.name_to_node[name] = amplifier
-        self.amplifiers.append(amplifier)
-        return amplifier
+        return self.add_node(name, cls, *args, nodes=self.amplifiers,
+                             **params)
 
     def add_link(self, src_node, dst_node, src_out_port=-1,
-                 dst_in_port=-1, boost_amp=None, spans=None):
+                 dst_in_port=-1, boost_amp=None, spans=None, cls=Link):
         """
         Add a uni-directional link
         :param src_node: source node in link
@@ -79,14 +76,14 @@ def add_link(self, src_node, dst_node, src_out_port=-1,
         :param dst_in_port: dst_node input port
         :param boost_amp: optional amplifier object for boost_amplification
         :param spans:
+        :param cls: optional Link class/constructor
         :return: created and added link
         """
-        link = Link(src_node, dst_node,
-                    src_out_port=src_out_port,
-                    dst_in_port=dst_in_port,
-                    boost_amp=boost_amp,
-                    spans=spans)
-
+        link = cls(src_node, dst_node,
+                   src_out_port=src_out_port,
+                   dst_in_port=dst_in_port,
+                   boost_amp=boost_amp,
+                   spans=spans)
         self.links.append(link)
         self.topology[src_node].append((dst_node, link))
         return link