Feat: add detailed ROADM impairments per roadm-path

Signed-off-by: EstherLerouzic <[email protected]>
Change-Id: I09c55dcff53ffb264609654cde0f1d8b9dc7fe9b

gnpy/core/elements.py

@@ -30,9 +30,10 @@
 
 from gnpy.core.utils import lin2db, db2lin, arrange_frequencies, snr_sum, per_label_average, pretty_summary_print, \
  watt2dbm, psd2powerdbm
-from gnpy.core.parameters import RoadmParams, FusedParams, FiberParams, PumpParams, EdfaParams, EdfaOperational
+from gnpy.core.parameters import RoadmParams, FusedParams, FiberParams, PumpParams, EdfaParams, EdfaOperational, \
+ RoadmPath, RoadmImpairment
 from gnpy.core.science_utils import NliSolver, RamanSolver
-from gnpy.core.info import SpectralInformation, ReferenceCarrier
+from gnpy.core.info import SpectralInformation
 from gnpy.core.exceptions import NetworkTopologyError, SpectrumError, ParametersError
 
 
@@ -259,6 +260,17 @@ def __init__(self, *args, params=None, **kwargs):
  self.per_degree_pch_psw = self.params.per_degree_pch_psw
  self.ref_pch_in_dbm = {}
  self.ref_carrier = None
+ # Define the nature of from-to internal connection: express-path, drop-path, add-path
+ # roadm_paths contains a list of RoadmPath object for each path crossing the ROADM
+ self.roadm_paths = []
+ # roadm_path_impairments contains a dictionnary of impairments profiles corresponding to type_variety
+ # first listed add, drop an express constitute the default
+ self.roadm_path_impairments = self.params.roadm_path_impairments
+ # per degree definitions, in case some degrees have particular deviations with respect to default.
+ self.per_degree_impairments = {f'{i["from_degree"]}-{i["to_degree"]}': {"from_degree": i["from_degree"],
+ "to_degree": i["to_degree"],
+ "impairment_id": i["impairment_id"]}
+ for i in self.params.per_degree_impairments}
 
  @property
  def to_json(self):
@@ -289,6 +301,9 @@ def to_json(self):
  to_json['params']['per_degree_psd_out_mWperGHz'] = self.per_degree_pch_psd
  if self.per_degree_pch_psw:
  to_json['params']['per_degree_psd_out_mWperSlotWidth'] = self.per_degree_pch_psw
+ if self.per_degree_impairments:
+ to_json['per_degree_impairments'] = list(self.per_degree_impairments.values())
+
  return to_json
 
  def __repr__(self):
@@ -404,11 +419,68 @@ def propagate(self, spectral_info, degree, from_degree):
  delta_power = watt2dbm(input_power) - new_target
 
  spectral_info.apply_attenuation_db(delta_power)
- spectral_info.pmd = sqrt(spectral_info.pmd ** 2 + self.params.pmd ** 2)
- spectral_info.pdl = sqrt(spectral_info.pdl ** 2 + self.params.pdl ** 2)
+ spectral_info.pmd = sqrt(spectral_info.pmd ** 2
+ + self.get_roadm_path(from_degree=from_degree, to_degree=degree).impairment.pmd ** 2)
+ spectral_info.pdl = sqrt(spectral_info.pdl ** 2
+ + self.get_roadm_path(from_degree=from_degree, to_degree=degree).impairment.pdl ** 2)
  self.pch_out_dbm = watt2dbm(spectral_info.signal + spectral_info.nli + spectral_info.ase)
  self.propagated_labels = spectral_info.label
 
+ def set_roadm_paths(self, from_degree, to_degree, path_type, impairment_id=None):
+ """set internal path type: express, drop or add with corresponding impairment
+
+ If no impairment id is defined, then use the first profile that matches the path_type in the
+ profile dictionnary.
+ """
+ # initialize impairment with params.pmd, params.cd
+ # if more detailed parameters are available for the Roadm, the use them instead
+ roadm_global_impairment = {'roadm-pmd': self.params.pmd,
+ 'roadm-pdl': self.params.pdl}
+ if path_type in ['add', 'drop']:
+ # without detailed imparments, we assume that add OSNR contribution is the same as drop contribution
+ # add_drop_osnr_db = - 10log10(1/add_osnr + 1/drop_osnr) with add_osnr = drop_osnr
+ # = add_osnr_db + 10log10(2)
+ roadm_global_impairment['roadm-osnr'] = self.params.add_drop_osnr + lin2db(2)
+ impairment = RoadmImpairment(roadm_global_impairment)
+
+ if impairment_id is None:
+ # get the first item in the type variety that matches the path_type
+ for path_impairment_id, path_impairment in self.roadm_path_impairments.items():
+ if path_impairment.path_type == path_type:
+ impairment = path_impairment
+ impairment_id = path_impairment_id
+ break
+ # at this point, path_type is not part of roadm_path_impairment, impairment and impairment_id are None
+ else:
+ if impairment_id in self.roadm_path_impairments:
+ impairment = self.roadm_path_impairments[impairment_id]
+ else:
+ msg = f'ROADM {self.uid}: impairment profile id {impairment_id} is not defined in library'
+ raise NetworkTopologyError(msg)
+ # print(from_degree, to_degree, path_type)
+ self.roadm_paths.append(RoadmPath(from_degree=from_degree, to_degree=to_degree, path_type=path_type,
+ impairment_id=impairment_id, impairment=impairment))
+
+ def get_roadm_path(self, from_degree, to_degree):
+ """Get internal path type impairment"""
+ for roadm_path in self.roadm_paths:
+ if roadm_path.from_degree == from_degree and roadm_path.to_degree == to_degree:
+ return roadm_path
+ msg = f'Could not find from_degree-to_degree {from_degree}-{to_degree} path in ROADM {self.uid}'
+ raise NetworkTopologyError(msg)
+
+ def get_per_degree_impairment_id(self, from_degree, to_degree):
+ """returns the id of the impairment if the degrees are in the per_degree tab"""
+ if f'{from_degree}-{to_degree}' in self.per_degree_impairments.keys():
+ return self.per_degree_impairments[f'{from_degree}-{to_degree}']["impairment_id"]
+ return None
+
+ def get_path_type_per_id(self, impairment_id):
+ """returns the path_type of the impairment if the is is defined"""
+ if impairment_id in self.roadm_path_impairments.keys():
+ return self.roadm_path_impairments[impairment_id].path_type
+ return None
+
  def __call__(self, spectral_info, degree, from_degree):
  self.propagate(spectral_info, degree=degree, from_degree=from_degree)
  return spectral_info

gnpy/core/network.py

@@ -530,6 +530,62 @@ def set_fiber_input_power(network, fiber, equipment, pref_ch_db):
  fiber.ref_pch_in_dbm = pref_ch_db - loss
 
 
+def set_roadm_internal_paths(roadm, network):
+ """Set ROADM path types (express, add, drop)
+
+ Uses implicit guess if no information is set in ROADM
+ """
+ next_oms = [n.uid for n in network.successors(roadm) if not isinstance(n, elements.Transceiver)]
+ previous_oms = [n.uid for n in network.predecessors(roadm) if not isinstance(n, elements.Transceiver)]
+ drop_port = [n.uid for n in network.successors(roadm) if isinstance(n, elements.Transceiver)]
+ add_port = [n.uid for n in network.predecessors(roadm) if isinstance(n, elements.Transceiver)]
+
+ default_express = 'express'
+ default_add = 'add'
+ default_drop = 'drop'
+ # take user defined element impairment id if it exists
+ correct_from_degrees = []
+ correct_add = []
+ correct_to_degrees = []
+ correct_drop = []
+ for from_degree in previous_oms:
+ correct_from_degrees.append(from_degree)
+ for to_degree in next_oms:
+ correct_to_degrees.append(to_degree)
+ impairment_id = roadm.get_per_degree_impairment_id(from_degree, to_degree)
+ roadm.set_roadm_paths(from_degree=from_degree, to_degree=to_degree, path_type=default_express,
+ impairment_id=impairment_id)
+ for drop in drop_port:
+ correct_drop.append(drop)
+ impairment_id = roadm.get_per_degree_impairment_id(from_degree, drop)
+ path_type = roadm.get_path_type_per_id(impairment_id)
+ # a degree connected to a transceiver MUST be add or drop
+ # but a degree connected to something else could be an express, add or drop
+ # (for example case of external shelves)
+ if path_type and path_type != 'drop':
+ msg = f'Roadm {roadm.uid} path_type is defined as {path_type} but it should be drop'
+ raise NetworkTopologyError(msg)
+ roadm.set_roadm_paths(from_degree=from_degree, to_degree=drop, path_type=default_drop,
+ impairment_id=impairment_id)
+ for to_degree in next_oms:
+ for add in add_port:
+ correct_add.append(add)
+ impairment_id = roadm.get_per_degree_impairment_id(add, to_degree)
+ path_type = roadm.get_path_type_per_id(impairment_id)
+ if path_type and path_type != 'add':
+ msg = f'Roadm {roadm.uid} path_type is defined as {path_type} but it should be add'
+ raise NetworkTopologyError(msg)
+ roadm.set_roadm_paths(from_degree=add, to_degree=to_degree, path_type=default_add,
+ impairment_id=impairment_id)
+ # sanity check: raise an error if per_degree from or to degrees are not in the correct list
+ # raise an error if user defined path_type is not consistent with inferred path_type:
+ for item in roadm.per_degree_impairments.values():
+ if item['from_degree'] not in correct_from_degrees + correct_add or \
+ item['to_degree'] not in correct_to_degrees + correct_drop:
+ msg = f'Roadm {roadm.uid} has wrong from-to degree uid {item["from_degree"]} - {item["to_degree"]}'
+ raise NetworkTopologyError(msg)
+
+
 def add_roadm_booster(network, roadm):
  next_nodes = [n for n in network.successors(roadm)
  if not (isinstance(n, elements.Transceiver) or isinstance(n, elements.Fused)
@@ -777,6 +833,7 @@ def build_network(network, equipment, pref_ch_db, pref_total_db, set_connector_l
  set_egress_amplifier(network, roadm, equipment, pref_ch_db, pref_total_db, verbose)
  for roadm in roadms:
  set_roadm_input_powers(network, roadm, equipment, pref_ch_db)
+ set_roadm_internal_paths(roadm, network)
  for fiber in [f for f in network.nodes() if isinstance(f, (elements.Fiber, elements.RamanFiber))]:
  set_fiber_input_power(network, fiber, equipment, pref_ch_db)
 

gnpy/core/parameters.py

@@ -113,8 +113,68 @@ def __init__(self, **kwargs):
  self.pmd = kwargs['pmd']
  self.pdl = kwargs['pdl']
  self.restrictions = kwargs['restrictions']
+ self.roadm_path_impairments = self.get_roadm_path_impairments(kwargs['roadm-path-impairments'])
  except KeyError as e:
  raise ParametersError(f'ROADM configurations must include {e}. Configuration: {kwargs}')
+ self.per_degree_impairments = kwargs.get('per_degree_impairments', [])
+
+ def get_roadm_path_impairments(self, path_impairments_list):
+ """Get the ROADM list of profiles for impairments definition
+
+ transform the ietf model into gnpy internal model: add a path-type in the attributes
+ """
+ if not path_impairments_list:
+ return {}
+ authorized_path_types = {
+ 'roadm-express-path': 'express',
+ 'roadm-add-path': 'add',
+ 'roadm-drop-path': 'drop',
+ }
+ roadm_path_impairments = {}
+ for path_impairment in path_impairments_list:
+ index = path_impairment['roadm-path-impairments-id']
+ path_type = next(key for key in path_impairment if key in authorized_path_types.keys())
+ impairment_dict = dict({'path-type': authorized_path_types[path_type]}, **path_impairment[path_type])
+ roadm_path_impairments[index] = RoadmImpairment(impairment_dict)
+ return roadm_path_impairments
+
+
+class RoadmPath:
+ def __init__(self, from_degree, to_degree, path_type, impairment_id=None, impairment=None):
+ """Records roadm internal paths, types and impairment
+
+ path_type must be in "express", "add", "drop"
+ impairment_id must be one of the id detailed in equipement
+ """
+ self.from_degree = from_degree
+ self.to_degree = to_degree
+ self.path_type = path_type
+ self.impairment_id = impairment_id
+ self.impairment = impairment
+
+
+class RoadmImpairment:
+ """Generic definition of impairments for express, add and drop"""
+ def __init__(self, params):
+ """Records roadm internal paths and types"""
+ self.path_type = params.get('path-type')
+ self.pmd = params.get('roadm-pmd')
+ self.cd = params.get('roadm-cd')
+ self.pdl = params.get('roadm-pdl')
+ self.inband_crosstalk = params.get('roadm-inband-crosstalk')
+ self.maxloss = params.get('roadm-maxloss', 0)
+ if params.get('frequency-range') is not None:
+ self.fmin = params.get('frequency-range')['lower-frequency']
+ self.fmax = params.get('frequency-range')['upper-frequency']
+ else:
+ self.fmin, self.fmax = None, None
+ self.osnr = params.get('roadm-osnr', None)
+ self.pmax = params.get('roadm-pmax', None)
+ self.nf = params.get('roadm-noise-figure', None)
+ self.minloss = params.get('minloss', None)
+ self.typloss = params.get('typloss', None)
+ self.pmin = params.get('pmin', None)
+ self.ptyp = params.get('ptyp', None)
 
 
 class FusedParams(Parameters):

gnpy/example-data/eqpt_config.json

@@ -217,7 +217,70 @@
  "restrictions": {
  "preamp_variety_list": [],
  "booster_variety_list": []
- }
+ },
+ "roadm-path-impairments": []
+ }, {
+ "type_variety": "detailed_impairments",
+ "target_pch_out_db": -20,
+ "add_drop_osnr": 38,
+ "pmd": 0,
+ "pdl": 0,
+ "restrictions": {
+ "preamp_variety_list":[],
+ "booster_variety_list":[]
+ },
+ "roadm-path-impairments": [
+ {
+ "roadm-path-impairments-id": 0,
+ "roadm-express-path": {
+ "frequency-range": {
+ "lower-frequency": 191.3e12,
+ "upper-frequency": 196.1e12
+ },
+ "roadm-pmd": 0,
+ "roadm-cd": 0,
+ "roadm-pdl": 0,
+ "roadm-inband-crosstalk": 0,
+ "roadm-maxloss": 16.5
+ }
+ }, {
+ "roadm-path-impairments-id": 1,
+ "roadm-add-path": {
+ "frequency-range": {
+ "lower-frequency": 191.3e12,
+ "upper-frequency": 196.1e12
+ },
+ "roadm-pmd": 0,
+ "roadm-cd": 0,
+ "roadm-pdl": 0,
+ "roadm-inband-crosstalk": 0,
+ "roadm-maxloss": 11.5,
+ "roadm-pmax": 2.5,
+ "roadm-osnr": 41,
+ "roadm-noise-figure": 23
+ }
+ }, {
+ "roadm-path-impairments-id": 2,
+ "roadm-drop-path": {
+ "frequency-range": {
+ "lower-frequency": 191.3e12,
+ "upper-frequency": 196.1e12
+ },
+ "roadm-pmd": 0,
+ "roadm-cd": 0,
+ "roadm-pdl": 0,
+ "roadm-inband-crosstalk": 0,
+ "roadm-maxloss": 11.5,
+ "roadm-minloss": 7.5,
+ "roadm-typloss": 10,
+ "roadm-pmin": -13.5,
+ "roadm-pmax": -9.5,
+ "roadm-ptyp": -12,
+ "roadm-osnr": 41,
+ "roadm-noise-figure": 15
+ }
+ }
+ ]
  }
  ],
  "SI": [{

gnpy/tools/json_io.py

@@ -102,7 +102,8 @@ class Roadm(_JsonThing):
  'restrictions': {
  'preamp_variety_list': [],
  'booster_variety_list': []
- }
+ },
+ 'roadm-path-impairments': []
  }
 
  def __init__(self, **kwargs):