EDFA Parameters restructuring

The parameters of the EDFA are explicitely retrieved in the EDFAParams class.
All the defaults are set instead in the gnpy.tool.json_io.AMP class.
Where required, the AMP.default_values are used instead of an empty dictionary.

Change-Id: Iba80a6a56bc89feb7e959b54b9bd424ec9b0bf06
Co-authored-by: Vittorio Gatto <[email protected]>

gnpy/core/network.py

@@ -9,12 +9,14 @@
 """
 
 from operator import attrgetter
+from collections import namedtuple
+from logging import getLogger
+
 from gnpy.core import elements
 from gnpy.core.exceptions import ConfigurationError, NetworkTopologyError
 from gnpy.core.utils import round2float, convert_length
 from gnpy.core.info import ReferenceCarrier
-from collections import namedtuple
-from logging import getLogger
+from gnpy.tools.json_io import Amp
 
 
 logger = getLogger(__name__)
@@ -361,7 +363,7 @@ def add_roadm_booster(network, roadm):
         network.remove_edge(roadm, next_node)
         amp = elements.Edfa(
             uid=f'Edfa_booster_{roadm.uid}_to_{next_node.uid}',
-            params={},
+            params=Amp.default_values,
             metadata={
                 'location': {
                     'latitude': roadm.lat,
@@ -387,7 +389,7 @@ def add_roadm_preamp(network, roadm):
         network.remove_edge(prev_node, roadm)
         amp = elements.Edfa(
             uid=f'Edfa_preamp_{roadm.uid}_from_{prev_node.uid}',
-            params={},
+            params=Amp.default_values,
             metadata={
                 'location': {
                     'latitude': roadm.lat,
@@ -416,7 +418,7 @@ def add_inline_amplifier(network, fiber):
         network.remove_edge(fiber, next_node)
         amp = elements.Edfa(
             uid=f'Edfa_{fiber.uid}',
-            params={},
+            params=Amp.default_values,
             metadata={
                 'location': {
                     'latitude': (fiber.lat + next_node.lat) / 2,

gnpy/core/parameters.py

@@ -10,7 +10,7 @@
 from collections import namedtuple
 
 from scipy.constants import c, pi
-from numpy import asarray, array, exp, sqrt, log, outer, ones, squeeze, append, flip
+from numpy import asarray, array, exp, sqrt, log, outer, ones, squeeze, append, flip, linspace, full
 
 from gnpy.core.utils import convert_length
 from gnpy.core.exceptions import ParametersError
@@ -356,20 +356,99 @@ def asdict(self):
 
 class EdfaParams:
     def __init__(self, **params):
-        self.update_params(params)
-        if params == {}:
-            self.type_variety = ''
-            self.type_def = ''
-            # self.gain_flatmax = 0
-            # self.gain_min = 0
-            # self.p_max = 0
-            # self.nf_model = None
-            # self.nf_fit_coeff = None
-            # self.nf_ripple = None
-            # self.dgt = None
-            # self.gain_ripple = None
-            # self.out_voa_auto = False
-            # self.allowed_for_design = None
+        try:
+            self.type_variety = params['type_variety']
+            self.type_def = params['type_def']
+
+            # Bandwidth
+            self.f_min = params['f_min']
+            self.f_max = params['f_max']
+            self.bandwidth = self.f_max - self.f_min
+            self.f_cent = (self.f_max + self.f_min) / 2
+            self.f_ripple_ref = params['f_ripple_ref']
+
+            # Gain
+            self.gain_flatmax = params['gain_flatmax']
+            self.gain_min = params['gain_min']
+
+            gain_ripple = params['gain_ripple']
+            if gain_ripple == 0:
+                self.gain_ripple = asarray([0, 0])
+                self.f_ripple_ref = asarray([self.f_min, self.f_max])
+            else:
+                self.gain_ripple = asarray(gain_ripple)
+                if self.f_ripple_ref is not None:
+                    if (self.f_ripple_ref[0] != self.f_min) or (self.f_ripple_ref[-1] != self.f_max):
+                        raise ParametersError("The reference ripple frequency maximum and minimum have to coincide "
+                                              "with the EDFA frequency maximum and minimum.")
+                    elif self.gain_ripple.size != self.f_ripple_ref.size:
+                        raise ParametersError("The reference ripple frequency and the gain ripple must have the same "
+                                              "size.")
+                else:
+                    self.f_ripple_ref = linspace(self.f_min, self.f_max, self.gain_ripple.size)
+
+            tilt_ripple = params['tilt_ripple']
+
+            if tilt_ripple == 0:
+                self.tilt_ripple = full(self.gain_ripple.size, 0)
+            else:
+                self.tilt_ripple = asarray(tilt_ripple)
+                if self.tilt_ripple.size != self.gain_ripple.size:
+                    raise ParametersError("The tilt ripple and the gain ripple must have the same size.")
+
+            # Power
+            self.p_max = params['p_max']
+
+            # Noise Figure
+            self.nf_model = params['nf_model']
+            self.nf_min = params['nf_min']
+            self.nf_max = params['nf_max']
+            self.nf_coef = params['nf_coef']
+            self.nf0 = params['nf0']
+            self.nf_fit_coeff = params['nf_fit_coeff']
+
+            nf_ripple = params['nf_ripple']
+            if nf_ripple == 0:
+                self.nf_ripple = full(self.gain_ripple.size, 0)
+            else:
+                self.nf_ripple = asarray(nf_ripple)
+                if self.nf_ripple.size != self.gain_ripple.size:
+                    raise ParametersError("The noise figure ripple and the gain ripple must have the same size.")
+
+            # VOA
+            self.out_voa_auto = params['out_voa_auto']
+
+            # Dual Stage
+            self.dual_stage_model = params['dual_stage_model']
+            if self.dual_stage_model is not None:
+                # Preamp
+                self.preamp_variety = params['preamp_variety']
+                self.preamp_type_def = params['preamp_type_def']
+                self.preamp_nf_model = params['preamp_nf_model']
+                self.preamp_nf_fit_coeff = params['preamp_nf_fit_coeff']
+                self.preamp_gain_min = params['preamp_gain_min']
+                self.preamp_gain_flatmax = params['preamp_gain_flatmax']
+
+                # Booster
+                self.booster_variety = params['booster_variety']
+                self.booster_type_def = params['booster_type_def']
+                self.booster_nf_model = params['booster_nf_model']
+                self.booster_nf_fit_coeff = params['booster_nf_fit_coeff']
+                self.booster_gain_min = params['booster_gain_min']
+                self.booster_gain_flatmax = params['booster_gain_flatmax']
+
+            # Others
+            self.pmd = params['pmd']
+            self.pdl = params['pdl']
+            self.raman = params['raman']
+            self.dgt = params['dgt']
+            self.advance_configurations_from_json = params['advance_configurations_from_json']
+
+            # Design
+            self.allowed_for_design = params['allowed_for_design']
+
+        except KeyError as e:
+            raise ParametersError(f'Edfa configurations json must include {e}. Configuration: {params}')
 
     def update_params(self, kwargs):
         for k, v in kwargs.items():

gnpy/tools/json_io.py

@@ -189,15 +189,24 @@ class Amp(_JsonThing):
         'p_max': None,
         'nf_model': None,
         'dual_stage_model': None,
+        'preamp_variety': None,
+        'booster_variety': None,
+        'nf_min': None,
+        'nf_max': None,
+        'nf_coef': None,
+        'nf0': None,
         'nf_fit_coeff': None,
-        'nf_ripple': None,
+        'nf_ripple': 0,
         'dgt': None,
-        'gain_ripple': None,
+        'gain_ripple': 0,
+        'tilt_ripple': 0,
+        'f_ripple_ref': None,
         'out_voa_auto': False,
         'allowed_for_design': False,
         'raman': False,
         'pmd': 0,
-        'pdl': 0
+        'pdl': 0,
+        'advance_configurations_from_json': None
     }
 
     def __init__(self, **kwargs):
@@ -499,10 +508,15 @@ def network_from_json(json_data, equipment):
             temp = merge_amplifier_restrictions(temp, extra_params)
             el_config['params'] = temp
             el_config['type_variety'] = variety
-        elif (typ in ['Fiber', 'RamanFiber']) or (typ == 'Edfa' and variety not in ['default', '']):
-            msg = f'The {typ} of variety type {variety} was not recognized: please check it is properly defined ' \
-                  + 'in the eqpt_config json file'
-            raise ConfigurationError(msg)
+        elif (typ in ['Fiber', 'RamanFiber']):
+            raise ConfigurationError(f'The {typ} of variety type {variety} was not recognized:'
+                                     '\nplease check it is properly defined in the eqpt_config json file')
+        elif typ == 'Edfa':
+            if variety in ['default', '']:
+                el_config['params'] = Amp.default_values
+            else:
+                raise ConfigurationError(f'The Edfa of variety type {variety} was not recognized:'
+                                         '\nplease check it is properly defined in the eqpt_config json file')
         el = cls(**el_config)
         g.add_node(el)
 

tests/invocation/logs_path_request

@@ -1,5 +1,5 @@
 INFO     gnpy.tools.cli_examples:cli_examples.py:326 Computing path requests meshTopologyExampleV2.xls into JSON format
-INFO     gnpy.tools.json_io:json_io.py:554 Automatically converting requests from XLS to JSON
+INFO     gnpy.tools.json_io:json_io.py:568 Automatically converting requests from XLS to JSON
 INFO     gnpy.topology.request:request.py:1104 
 	request 0
 	Computing path from trx Lorient_KMA to trx Vannes_KBE