mirror of
https://github.com/Telecominfraproject/oopt-gnpy.git
synced 2025-11-02 19:18:02 +00:00
0813332adc
Introduce a design_band parameter in ROADM and Transceiver. - if nothing is defined, use SI band(s) - if design band is defined in ROADM, use this one for all degrees - if per degree design band is defined, use this one instead unsupported case: single band OMS with default multiband design band. Check that these definitions are consistent with actual amplifiers Signed-off-by: EstherLerouzic <esther.lerouzic@orange.com> Change-Id: Ibea4ce6e72d2b1e96ef8cf4efaf499530d24179c
681 lines
30 KiB
Python
681 lines
30 KiB
Python
#!/usr/bin/env python3
|
||
# -*- coding: utf-8 -*-
|
||
|
||
"""
|
||
gnpy.core.parameters
|
||
====================
|
||
|
||
This module contains all parameters to configure standard network elements.
|
||
"""
|
||
from collections import namedtuple
|
||
from copy import deepcopy
|
||
from dataclasses import dataclass
|
||
from scipy.constants import c, pi
|
||
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
|
||
|
||
|
||
class Parameters:
|
||
def asdict(self):
|
||
class_dict = self.__class__.__dict__
|
||
instance_dict = self.__dict__
|
||
new_dict = {}
|
||
for key in class_dict:
|
||
if isinstance(class_dict[key], property):
|
||
new_dict[key] = instance_dict['_' + key]
|
||
return new_dict
|
||
|
||
|
||
class PumpParams(Parameters):
|
||
def __init__(self, power, frequency, propagation_direction):
|
||
self.power = power
|
||
self.frequency = frequency
|
||
self.propagation_direction = propagation_direction.lower()
|
||
|
||
|
||
class RamanParams(Parameters):
|
||
def __init__(self, flag=False, result_spatial_resolution=10e3, solver_spatial_resolution=50):
|
||
"""Simulation parameters used within the Raman Solver
|
||
|
||
:params flag: boolean for enabling/disable the evaluation of the Raman power profile in frequency and position
|
||
:params result_spatial_resolution: spatial resolution of the evaluated Raman power profile
|
||
:params solver_spatial_resolution: spatial step for the iterative solution of the first order ode
|
||
"""
|
||
self.flag = flag
|
||
self.result_spatial_resolution = result_spatial_resolution # [m]
|
||
self.solver_spatial_resolution = solver_spatial_resolution # [m]
|
||
|
||
def to_json(self):
|
||
return {"flag": self.flag,
|
||
"result_spatial_resolution": self.result_spatial_resolution,
|
||
"solver_spatial_resolution": self.solver_spatial_resolution}
|
||
|
||
|
||
class NLIParams(Parameters):
|
||
def __init__(self, method='gn_model_analytic', dispersion_tolerance=1, phase_shift_tolerance=0.1,
|
||
computed_channels=None, computed_number_of_channels=None):
|
||
"""Simulation parameters used within the Nli Solver
|
||
|
||
:params method: formula for NLI calculation
|
||
:params dispersion_tolerance: tuning parameter for ggn model solution
|
||
:params phase_shift_tolerance: tuning parameter for ggn model solution
|
||
:params computed_channels: the NLI is evaluated for these channels and extrapolated for the others
|
||
:params computed_number_of_channels: the NLI is evaluated for this number of channels equally distributed
|
||
in the spectrum and extrapolated for the others
|
||
"""
|
||
self.method = method.lower()
|
||
self.dispersion_tolerance = dispersion_tolerance
|
||
self.phase_shift_tolerance = phase_shift_tolerance
|
||
self.computed_channels = computed_channels
|
||
self.computed_number_of_channels = computed_number_of_channels
|
||
|
||
def to_json(self):
|
||
return {"method": self.method,
|
||
"dispersion_tolerance": self.dispersion_tolerance,
|
||
"phase_shift_tolerance": self.phase_shift_tolerance,
|
||
"computed_channels": self.computed_channels,
|
||
"computed_number_of_channels": self.computed_number_of_channels}
|
||
|
||
|
||
class SimParams(Parameters):
|
||
_shared_dict = {'nli_params': NLIParams(), 'raman_params': RamanParams()}
|
||
|
||
@classmethod
|
||
def set_params(cls, sim_params):
|
||
cls._shared_dict['nli_params'] = NLIParams(**sim_params.get('nli_params', {}))
|
||
cls._shared_dict['raman_params'] = RamanParams(**sim_params.get('raman_params', {}))
|
||
|
||
@property
|
||
def nli_params(self):
|
||
return self._shared_dict['nli_params']
|
||
|
||
@property
|
||
def raman_params(self):
|
||
return self._shared_dict['raman_params']
|
||
|
||
|
||
class RoadmParams(Parameters):
|
||
def __init__(self, **kwargs):
|
||
self.target_pch_out_db = kwargs.get('target_pch_out_db')
|
||
self.target_psd_out_mWperGHz = kwargs.get('target_psd_out_mWperGHz')
|
||
self.target_out_mWperSlotWidth = kwargs.get('target_out_mWperSlotWidth')
|
||
equalisation_type = ['target_pch_out_db', 'target_psd_out_mWperGHz', 'target_out_mWperSlotWidth']
|
||
temp = [kwargs.get(k) is not None for k in equalisation_type]
|
||
if sum(temp) > 1:
|
||
raise ParametersError('ROADM config contains more than one equalisation type.'
|
||
+ 'Please choose only one', kwargs)
|
||
self.per_degree_pch_out_db = kwargs.get('per_degree_pch_out_db', {})
|
||
self.per_degree_pch_psd = kwargs.get('per_degree_psd_out_mWperGHz', {})
|
||
self.per_degree_pch_psw = kwargs.get('per_degree_psd_out_mWperSlotWidth', {})
|
||
try:
|
||
self.add_drop_osnr = kwargs['add_drop_osnr']
|
||
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', [])
|
||
self.design_bands = kwargs.get('design_bands', [])
|
||
self.per_degree_design_bands = kwargs.get('per_degree_design_bands', {})
|
||
|
||
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][0])
|
||
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):
|
||
def __init__(self, **kwargs):
|
||
self.loss = kwargs['loss'] if 'loss' in kwargs else 1
|
||
|
||
|
||
DEFAULT_RAMAN_COEFFICIENT = {
|
||
# SSMF Raman coefficient profile in terms of mode intensity (g0 * A_ff_overlap)
|
||
'gamma_raman': array(
|
||
[0.0, 8.524419934705497e-16, 2.643567866245371e-15, 4.410548410941305e-15, 6.153422961291078e-15,
|
||
7.484924703044943e-15, 8.452060808349209e-15, 9.101549322698156e-15, 9.57837595158966e-15,
|
||
1.0008642675474562e-14, 1.0865773569905647e-14, 1.1300776305865833e-14, 1.2143238647099625e-14,
|
||
1.3231065750676068e-14, 1.4624900971525384e-14, 1.6013330554840492e-14, 1.7458119359310242e-14,
|
||
1.9320241330434762e-14, 2.1720395392873534e-14, 2.4137337406734775e-14, 2.628163218460466e-14,
|
||
2.8041019963285974e-14, 2.9723155447089933e-14, 3.129353531005888e-14, 3.251796163324624e-14,
|
||
3.3198839487612773e-14, 3.329527690685666e-14, 3.313155691238456e-14, 3.289013852154548e-14,
|
||
3.2458917188506916e-14, 3.060684277937575e-14, 3.2660349473783173e-14, 2.957419109657689e-14,
|
||
2.518894321396672e-14, 1.734560485857344e-14, 9.902860761605233e-15, 7.219176385099358e-15,
|
||
6.079565990401311e-15, 5.828373065963427e-15, 7.20580801091692e-15, 7.561924351387493e-15,
|
||
7.621152352332206e-15, 6.8859886780643254e-15, 5.629181047471162e-15, 3.679727598966185e-15,
|
||
2.7555869742500355e-15, 2.4810133942597675e-15, 2.2160080532403624e-15, 2.1440626024765557e-15,
|
||
2.33873070799544e-15, 2.557317929858713e-15, 3.039839048226572e-15, 4.8337165515610065e-15,
|
||
5.4647431818257436e-15, 5.229187813711269e-15, 4.510768525811313e-15, 3.3213473130607794e-15,
|
||
2.2602577027996455e-15, 1.969576495866441e-15, 1.5179853954188527e-15, 1.2953988551200156e-15,
|
||
1.1304672156251838e-15, 9.10004390675213e-16, 8.432919922183503e-16, 7.849224069008326e-16,
|
||
7.827568196032024e-16, 9.000514440646232e-16, 1.3025926460013665e-15, 1.5444108938497558e-15,
|
||
1.8795594063060786e-15, 1.7796130169921014e-15, 1.5938159865046653e-15, 1.1585522355108287e-15,
|
||
8.507044444633358e-16, 7.625404663756823e-16, 8.14510750925789e-16, 9.047944693473188e-16,
|
||
9.636431901702084e-16, 9.298633899602105e-16, 8.349739503637023e-16, 7.482901278066085e-16,
|
||
6.240794767134268e-16, 5.00652535687506e-16, 3.553373263685851e-16, 2.0344217706119682e-16,
|
||
1.4267522642294203e-16, 8.980016576743517e-17, 2.9829068181832594e-17, 1.4861959129014824e-17,
|
||
7.404482113326137e-18]
|
||
), # m/W
|
||
# SSMF Raman coefficient profile
|
||
'g0': array(
|
||
[0.00000000e+00, 1.12351610e-05, 3.47838074e-05, 5.79356636e-05, 8.06921680e-05, 9.79845709e-05, 1.10454361e-04,
|
||
1.18735302e-04, 1.24736889e-04, 1.30110053e-04, 1.41001273e-04, 1.46383247e-04, 1.57011792e-04, 1.70765865e-04,
|
||
1.88408911e-04, 2.05914127e-04, 2.24074028e-04, 2.47508283e-04, 2.77729174e-04, 3.08044243e-04, 3.34764439e-04,
|
||
3.56481704e-04, 3.77127256e-04, 3.96269124e-04, 4.10955175e-04, 4.18718761e-04, 4.19511263e-04, 4.17025384e-04,
|
||
4.13565369e-04, 4.07726048e-04, 3.83671291e-04, 4.08564283e-04, 3.69571936e-04, 3.14442090e-04, 2.16074535e-04,
|
||
1.23097823e-04, 8.95457457e-05, 7.52470400e-05, 7.19806145e-05, 8.87961158e-05, 9.30812065e-05, 9.37058268e-05,
|
||
8.45719619e-05, 6.90585286e-05, 4.50407159e-05, 3.36521245e-05, 3.02292475e-05, 2.69376939e-05, 2.60020897e-05,
|
||
2.82958958e-05, 3.08667558e-05, 3.66024657e-05, 5.80610307e-05, 6.54797937e-05, 6.25022715e-05, 5.37806442e-05,
|
||
3.94996621e-05, 2.68120644e-05, 2.33038554e-05, 1.79140757e-05, 1.52472424e-05, 1.32707565e-05, 1.06541760e-05,
|
||
9.84649374e-06, 9.13999627e-06, 9.08971012e-06, 1.04227525e-05, 1.50419271e-05, 1.77838232e-05, 2.15810815e-05,
|
||
2.03744008e-05, 1.81939341e-05, 1.31862121e-05, 9.65352116e-06, 8.62698322e-06, 9.18688016e-06, 1.01737784e-05,
|
||
1.08017817e-05, 1.03903588e-05, 9.30040333e-06, 8.30809173e-06, 6.90650401e-06, 5.52238029e-06, 3.90648708e-06,
|
||
2.22908227e-06, 1.55796177e-06, 9.77218716e-07, 3.23477236e-07, 1.60602454e-07, 7.97306386e-08]
|
||
), # [1 / (W m)]
|
||
|
||
# Note the non-uniform spacing of this range; this is required for properly capturing the Raman peak shape.
|
||
'frequency_offset': array([
|
||
0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5, 4., 4.5, 5., 5.5, 6., 6.5, 7., 7.5, 8., 8.5, 9., 9.5, 10., 10.5, 11., 11.5,
|
||
12., 12.5, 12.75, 13., 13.25, 13.5, 14., 14.5, 14.75, 15., 15.5, 16., 16.5, 17., 17.5, 18., 18.25, 18.5, 18.75,
|
||
19., 19.5, 20., 20.5, 21., 21.5, 22., 22.5, 23., 23.5, 24., 24.5, 25., 25.5, 26., 26.5, 27., 27.5, 28., 28.5,
|
||
29., 29.5, 30., 30.5, 31., 31.5, 32., 32.5, 33., 33.5, 34., 34.5, 35., 35.5, 36., 36.5, 37., 37.5, 38., 38.5,
|
||
39., 39.5, 40., 40.5, 41., 41.5, 42.]) * 1e12, # [Hz]
|
||
|
||
# Raman profile reference frequency
|
||
'reference_frequency': 206.184634112792e12, # [Hz] (1454 nm)
|
||
|
||
# Raman profile reference effective area
|
||
'reference_effective_area': 75.74659443542413e-12 # [m^2] (@1454 nm)
|
||
}
|
||
|
||
|
||
class RamanGainCoefficient(namedtuple('RamanGainCoefficient', 'normalized_gamma_raman frequency_offset')):
|
||
""" Raman Gain Coefficient Parameters
|
||
|
||
Based on:
|
||
Andrea D’Amico, Bruno Correia, Elliot London, Emanuele Virgillito, Giacomo Borraccini, Antonio Napoli,
|
||
and Vittorio Curri, "Scalable and Disaggregated GGN Approximation Applied to a C+L+S Optical Network,"
|
||
J. Lightwave Technol. 40, 3499-3511 (2022)
|
||
Section III.D
|
||
"""
|
||
|
||
|
||
class FiberParams(Parameters):
|
||
def __init__(self, **kwargs):
|
||
try:
|
||
self._length = convert_length(kwargs['length'], kwargs['length_units'])
|
||
# fixed attenuator for padding
|
||
self._att_in = kwargs.get('att_in', 0)
|
||
# if not defined in the network json connector loss in/out
|
||
# the None value will be updated in network.py[build_network]
|
||
# with default values from eqpt_config.json[Spans]
|
||
self._con_in = kwargs.get('con_in')
|
||
self._con_out = kwargs.get('con_out')
|
||
|
||
# Reference frequency (unique for all parameters: beta2, beta3, gamma, effective_area)
|
||
if 'ref_wavelength' in kwargs:
|
||
self._ref_wavelength = kwargs['ref_wavelength']
|
||
self._ref_frequency = c / self._ref_wavelength
|
||
elif 'ref_frequency' in kwargs:
|
||
self._ref_frequency = kwargs['ref_frequency']
|
||
self._ref_wavelength = c / self._ref_frequency
|
||
else:
|
||
self._ref_wavelength = 1550e-9 # conventional central C band wavelength [m]
|
||
self._ref_frequency = c / self._ref_wavelength
|
||
|
||
# Chromatic Dispersion
|
||
if 'dispersion_per_frequency' in kwargs:
|
||
# Frequency-dependent dispersion
|
||
self._dispersion = asarray(kwargs['dispersion_per_frequency']['value']) # s/m/m
|
||
self._f_dispersion_ref = asarray(kwargs['dispersion_per_frequency']['frequency']) # Hz
|
||
self._dispersion_slope = None
|
||
elif 'dispersion' in kwargs:
|
||
# Single value dispersion
|
||
self._dispersion = asarray(kwargs['dispersion']) # s/m/m
|
||
self._dispersion_slope = kwargs.get('dispersion_slope') # s/m/m/m
|
||
self._f_dispersion_ref = asarray(self._ref_frequency) # Hz
|
||
else:
|
||
# Default single value dispersion
|
||
self._dispersion = asarray(1.67e-05) # s/m/m
|
||
self._dispersion_slope = None
|
||
self._f_dispersion_ref = asarray(self.ref_frequency) # Hz
|
||
|
||
# Effective Area and Nonlinear Coefficient
|
||
self._effective_area = kwargs.get('effective_area') # m^2
|
||
self._n1 = 1.468
|
||
self._core_radius = 4.2e-6 # m
|
||
self._n2 = 2.6e-20 # m^2/W
|
||
if self._effective_area is not None:
|
||
default_gamma = 2 * pi * self._n2 / (self._ref_wavelength * self._effective_area)
|
||
self._gamma = kwargs.get('gamma', default_gamma) # 1/W/m
|
||
elif 'gamma' in kwargs:
|
||
self._gamma = kwargs['gamma'] # 1/W/m
|
||
self._effective_area = 2 * pi * self._n2 / (self._ref_wavelength * self._gamma) # m^2
|
||
else:
|
||
self._effective_area = 83e-12 # m^2
|
||
self._gamma = 2 * pi * self._n2 / (self._ref_wavelength * self._effective_area) # 1/W/m
|
||
self._contrast = 0.5 * (c / (2 * pi * self._ref_frequency * self._core_radius * self._n1) * exp(
|
||
pi * self._core_radius ** 2 / self._effective_area)) ** 2
|
||
|
||
# Raman Gain Coefficient
|
||
raman_coefficient = kwargs.get('raman_coefficient')
|
||
if raman_coefficient is None:
|
||
self._raman_reference_frequency = DEFAULT_RAMAN_COEFFICIENT['reference_frequency']
|
||
frequency_offset = asarray(DEFAULT_RAMAN_COEFFICIENT['frequency_offset'])
|
||
gamma_raman = asarray(DEFAULT_RAMAN_COEFFICIENT['gamma_raman'])
|
||
stokes_wave = self._raman_reference_frequency - frequency_offset
|
||
normalized_gamma_raman = gamma_raman / self._raman_reference_frequency # 1 / m / W / Hz
|
||
self._g0 = gamma_raman / self.effective_area_overlap(stokes_wave, self._raman_reference_frequency)
|
||
else:
|
||
self._raman_reference_frequency = raman_coefficient['reference_frequency']
|
||
frequency_offset = asarray(raman_coefficient['frequency_offset'])
|
||
stokes_wave = self._raman_reference_frequency - frequency_offset
|
||
self._g0 = asarray(raman_coefficient['g0'])
|
||
gamma_raman = self._g0 * self.effective_area_overlap(stokes_wave, self._raman_reference_frequency)
|
||
normalized_gamma_raman = gamma_raman / self._raman_reference_frequency # 1 / m / W / Hz
|
||
|
||
# Raman gain coefficient array of the frequency offset constructed such that positive frequency values
|
||
# represent a positive power transfer from higher frequency and vice versa
|
||
frequency_offset = append(-flip(frequency_offset[1:]), frequency_offset)
|
||
normalized_gamma_raman = append(- flip(normalized_gamma_raman[1:]), normalized_gamma_raman)
|
||
self._raman_coefficient = RamanGainCoefficient(normalized_gamma_raman, frequency_offset)
|
||
|
||
# Polarization Mode Dispersion
|
||
self._pmd_coef = kwargs['pmd_coef'] # s/sqrt(m)
|
||
|
||
# Loss Coefficient
|
||
if isinstance(kwargs['loss_coef'], dict):
|
||
self._loss_coef = asarray(kwargs['loss_coef']['value']) * 1e-3 # lineic loss dB/m
|
||
self._f_loss_ref = asarray(kwargs['loss_coef']['frequency']) # Hz
|
||
else:
|
||
self._loss_coef = asarray(kwargs['loss_coef']) * 1e-3 # lineic loss dB/m
|
||
self._f_loss_ref = asarray(self._ref_frequency) # Hz
|
||
# Lumped Losses
|
||
self._lumped_losses = kwargs['lumped_losses'] if 'lumped_losses' in kwargs else array([])
|
||
self._latency = self._length / (c / self._n1) # s
|
||
except KeyError as e:
|
||
raise ParametersError(f'Fiber configurations json must include {e}. Configuration: {kwargs}')
|
||
|
||
@property
|
||
def length(self):
|
||
return self._length
|
||
|
||
@length.setter
|
||
def length(self, length):
|
||
"""length must be in m"""
|
||
self._length = length
|
||
|
||
@property
|
||
def att_in(self):
|
||
return self._att_in
|
||
|
||
@att_in.setter
|
||
def att_in(self, att_in):
|
||
self._att_in = att_in
|
||
|
||
@property
|
||
def con_in(self):
|
||
return self._con_in
|
||
|
||
@con_in.setter
|
||
def con_in(self, con_in):
|
||
self._con_in = con_in
|
||
|
||
@property
|
||
def con_out(self):
|
||
return self._con_out
|
||
|
||
@property
|
||
def lumped_losses(self):
|
||
return self._lumped_losses
|
||
|
||
@con_out.setter
|
||
def con_out(self, con_out):
|
||
self._con_out = con_out
|
||
|
||
@property
|
||
def dispersion(self):
|
||
return self._dispersion
|
||
|
||
@property
|
||
def f_dispersion_ref(self):
|
||
return self._f_dispersion_ref
|
||
|
||
@property
|
||
def dispersion_slope(self):
|
||
return self._dispersion_slope
|
||
|
||
@property
|
||
def gamma(self):
|
||
return self._gamma
|
||
|
||
def effective_area_scaling(self, frequency):
|
||
V = 2 * pi * frequency / c * self._core_radius * self._n1 * sqrt(2 * self._contrast)
|
||
w = self._core_radius / sqrt(log(V))
|
||
return asarray(pi * w ** 2)
|
||
|
||
def effective_area_overlap(self, frequency_stokes_wave, frequency_pump):
|
||
effective_area_stokes_wave = self.effective_area_scaling(frequency_stokes_wave)
|
||
effective_area_pump = self.effective_area_scaling(frequency_pump)
|
||
return squeeze(outer(effective_area_stokes_wave, ones(effective_area_pump.size)) + outer(
|
||
ones(effective_area_stokes_wave.size), effective_area_pump)) / 2
|
||
|
||
def gamma_scaling(self, frequency):
|
||
return asarray(2 * pi * self._n2 * frequency / (c * self.effective_area_scaling(frequency)))
|
||
|
||
@property
|
||
def pmd_coef(self):
|
||
return self._pmd_coef
|
||
|
||
@property
|
||
def ref_wavelength(self):
|
||
return self._ref_wavelength
|
||
|
||
@property
|
||
def ref_frequency(self):
|
||
return self._ref_frequency
|
||
|
||
@property
|
||
def loss_coef(self):
|
||
return self._loss_coef
|
||
|
||
@property
|
||
def f_loss_ref(self):
|
||
return self._f_loss_ref
|
||
|
||
@property
|
||
def raman_coefficient(self):
|
||
return self._raman_coefficient
|
||
|
||
@property
|
||
def latency(self):
|
||
return self._latency
|
||
|
||
def asdict(self):
|
||
dictionary = super().asdict()
|
||
dictionary['loss_coef'] = self.loss_coef * 1e3
|
||
dictionary['length_units'] = 'm'
|
||
if len(self.lumped_losses) == 0:
|
||
dictionary.pop('lumped_losses')
|
||
if not self.raman_coefficient:
|
||
dictionary.pop('raman_coefficient')
|
||
else:
|
||
raman_frequency_offset = \
|
||
self.raman_coefficient.frequency_offset[self.raman_coefficient.frequency_offset >= 0]
|
||
dictionary['raman_coefficient'] = {'g0': self._g0.tolist(),
|
||
'frequency_offset': raman_frequency_offset.tolist(),
|
||
'reference_frequency': self._raman_reference_frequency}
|
||
return dictionary
|
||
|
||
|
||
class EdfaParams:
|
||
default_values = {
|
||
'f_min': None,
|
||
'f_max': None,
|
||
'multi_band': None,
|
||
'bands': None,
|
||
'type_variety': '',
|
||
'type_def': '',
|
||
'gain_flatmax': None,
|
||
'gain_min': None,
|
||
'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': 0,
|
||
'dgt': 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,
|
||
'advance_configurations_from_json': None
|
||
}
|
||
|
||
def __init__(self, **params):
|
||
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 if self.f_max and self.f_min else None
|
||
self.f_cent = (self.f_max + self.f_min) / 2 if self.f_max and self.f_min else None
|
||
self.f_ripple_ref = params['f_ripple_ref']
|
||
self.bands = [{'f_min': params['f_min'],
|
||
'f_max': params['f_max']}]
|
||
|
||
# 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():
|
||
setattr(self, k, v)
|
||
|
||
|
||
class EdfaOperational:
|
||
default_values = {
|
||
'gain_target': None,
|
||
'delta_p': None,
|
||
'out_voa': None,
|
||
'tilt_target': 0
|
||
}
|
||
|
||
def __init__(self, **operational):
|
||
self.update_attr(operational)
|
||
|
||
def update_attr(self, kwargs):
|
||
clean_kwargs = {k: v for k, v in kwargs.items() if v != ''}
|
||
for k, v in self.default_values.items():
|
||
setattr(self, k, clean_kwargs.get(k, v))
|
||
|
||
def __repr__(self):
|
||
return (f'{type(self).__name__}('
|
||
f'gain_target={self.gain_target!r}, '
|
||
f'tilt_target={self.tilt_target!r})')
|
||
|
||
|
||
class MultiBandParams:
|
||
default_values = {
|
||
'bands': [],
|
||
'type_variety': '',
|
||
'type_def': None,
|
||
'allowed_for_design': False
|
||
}
|
||
|
||
def __init__(self, **params):
|
||
try:
|
||
self.update_attr(params)
|
||
except KeyError as e:
|
||
raise ParametersError(f'Multiband configurations json must include {e}. Configuration: {params}')
|
||
|
||
def update_attr(self, kwargs):
|
||
clean_kwargs = {k: v for k, v in kwargs.items() if v != ''}
|
||
for k, v in self.default_values.items():
|
||
# use deepcopy to avoid sharing same object amongst all instance when v is a list or a dict!
|
||
if isinstance(v, (list, dict)):
|
||
setattr(self, k, clean_kwargs.get(k, deepcopy(v)))
|
||
else:
|
||
setattr(self, k, clean_kwargs.get(k, v))
|
||
|
||
|
||
class TransceiverParams:
|
||
def __init__(self, **params):
|
||
self.design_bands = params.get('design_bands', [])
|
||
self.per_degree_design_bands = params.get('per_degree_design_bands', {})
|
||
|
||
|
||
@dataclass
|
||
class FrequencyBand:
|
||
"""Frequency band
|
||
"""
|
||
f_min: float
|
||
f_max: float
|
||
|
||
|
||
DEFAULT_BANDS_DEFINITION = {
|
||
"LBAND": FrequencyBand(f_min=187e12, f_max=189e12),
|
||
"CBAND": FrequencyBand(f_min=191.3e12, f_max=196.0e12)
|
||
}
|
||
# use this definition to index amplifiers'element of a multiband amplifier.
|
||
# this is not the design band
|
||
|
||
|
||
def find_band_name(band: FrequencyBand) -> str:
|
||
"""return the default band name (CBAND, LBAND, ...) that corresponds to the band frequency range
|
||
Use the band center frequency: if center frequency is inside the band then returns CBAND.
|
||
This is to flexibly encompass all kind of bands definitions.
|
||
returns the first matching band name.
|
||
"""
|
||
for band_name, frequency_range in DEFAULT_BANDS_DEFINITION.items():
|
||
center_frequency = (band.f_min + band.f_max) / 2
|
||
if center_frequency >= frequency_range.f_min and center_frequency <= frequency_range.f_max:
|
||
return band_name
|
||
return 'unknown_band'
|