WIP: Add Splitter() element

mnoptical/dataplane.py

@@ -338,7 +338,7 @@ def configTx( self, txNum, channel=None, power=None ):
         if channel is not None:
             self.txChannel[ txNum ] = channel
         if power is not None:
-            transceiver.operation_power = db_to_abs(power)
+            self.model.tx_config(transceiver, operational_power_dBm=power)
 
     def txnum( self, wdmPort ):
         "Return a tx number for wdmPort number"

mnoptical/link.py

@@ -43,12 +43,17 @@ def __init__(self, src_node, dst_node, src_out_port=-1, dst_in_port=-1,
         if boost_amp:
             self.boost_amp.set_input_port(self.src_node, self, input_port=0)
             self.boost_amp.set_output_port(spans[0][0], self, output_port=0)
+            if self.boost_amp.prev_component:
+                raise Exception(f"{self.boost_amp} already connected to "
+                                f"{self.boost_amp.prev_component}")
             self.boost_amp.prev_component = src_node
             self.boost_amp.next_component = spans[0][0]
 
         prev_amp = None
         for i, span in enumerate(spans):
             prev_span = span[0]
+            if getattr(prev_span, 'link', None) is not None:
+                raise Exception(f"span {prev_span} is already used in {prev_span.link}")
             prev_span.link = self
             amplifier = span[1]
 
@@ -58,6 +63,10 @@ def __init__(self, src_node, dst_node, src_out_port=-1, dst_in_port=-1,
                 prev_span.prev_component = prev_amp
 
             if amplifier:
+                if amplifier.link:
+                    raise Exception(
+                        f"{amplifier} is already used in {amplifier.link}")
+
                 amplifier.link = self
                 amplifier.set_input_port(prev_span, self, input_port=0)
 
@@ -91,6 +100,8 @@ def describe(self):
 
     def __repr__(self):
         """String representation"""
+        dport = self.dst_node.link_to_port_in[self]        
+        was: "(%s->%s:%s)" % (self.src_node, self.dst_node, dport)
         return "(%s->%s)" % (self.src_node, self.dst_node)
 
     def reset(self):
@@ -159,15 +170,17 @@ def propagate(self, is_last_port=False, safe_switch=False):
         if self.boost_amp:
             for optical_signal in self.optical_signals:
                 # associate boost_amp to optical signal at input interface
-                self.boost_amp.include_optical_signal_in(optical_signal,
-                                                         in_port=0)
+                state = optical_signal.loc_in_to_state[self]
+                self.boost_amp.include_optical_signal_in(
+                    optical_signal, **state, in_port=0)
             self.boost_amp.propagate(self.optical_signals,
                                      is_last_port=is_last_port,
                                      safe_switch=safe_switch)
         else:
             first_span = self.spans[0][0]
             for optical_signal in self.optical_signals:
-                first_span.include_optical_signal_in(optical_signal)
+                state = optical_signal.loc_in_to_state[self]                
+                first_span.include_optical_signal_in(optical_signal, **state)
             first_span.propagate(is_last_port=is_last_port,
                                  safe_switch=safe_switch)
 
@@ -294,7 +307,7 @@ def propagate(self, is_last_port=False, safe_switch=False):
                     nli_noise=optical_signal.loc_out_to_state[self]['nli_noise'],
                     in_port=in_port)
                 self.next_component.receiver(optical_signal, in_port)
-            elif isinstance(self.next_component, Roadm):
+            elif hasattr(self.next_component, 'include_optical_signal_in_roadm'):
                 self.next_component.include_optical_signal_in_roadm(
                     optical_signal,
                     power=optical_signal.loc_out_to_state[self]['power'],
@@ -308,10 +321,12 @@ def propagate(self, is_last_port=False, safe_switch=False):
                     ase_noise=optical_signal.loc_out_to_state[self]['ase_noise'],
                     nli_noise=optical_signal.loc_out_to_state[self]['nli_noise'],
                     in_port=0)
+            else:
+                print(f"{self} NOT PROPAGATING SIGNAL")
 
         if isinstance(self.next_component, Amplifier):
             self.next_component.propagate(self.optical_signals, is_last_port=is_last_port, safe_switch=safe_switch)
-        elif isinstance(self.next_component, Roadm) and is_last_port:
+        elif hasattr(self.next_component, 'switch') and is_last_port:
             in_port = self.next_component.link_to_port_in[self.link]
             self.next_component.switch(in_port, self.link.src_node, 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