package org.opendaylight.transportpce.pce.graph;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Arrays;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.SpectrumAssignment;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.SpectrumAssignmentBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.TerminationPoint1;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.networks.network.node.termination.point.XpdrNetworkAttributes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmLinkType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmNodeType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev210924.OpucnTribSlotDef;
pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
return pceResult;
}
- int spectralWidthSlotNumber = GridConstant.SPECTRAL_WIDTH_SLOT_NUMBER_MAP
- .getOrDefault(serviceType, GridConstant.NB_SLOTS_100G);
+ int spectralWidthSlotNumber =
+ GridConstant.SPECTRAL_WIDTH_SLOT_NUMBER_MAP.getOrDefault(serviceType, GridConstant.NB_SLOTS_100G);
SpectrumAssignment spectrumAssignment = null;
//variable to deal with 1GE (Nb=1) and 10GE (Nb=10) cases
switch (serviceType) {
case StringConstants.SERVICE_TYPE_OTUC3:
case StringConstants.SERVICE_TYPE_OTUC4:
case StringConstants.SERVICE_TYPE_400GE:
- spectralWidthSlotNumber = GridConstant.SPECTRAL_WIDTH_SLOT_NUMBER_MAP
- .getOrDefault(serviceType, GridConstant.NB_SLOTS_400G);
+ spectralWidthSlotNumber =
+ GridConstant.SPECTRAL_WIDTH_SLOT_NUMBER_MAP.getOrDefault(serviceType, GridConstant.NB_SLOTS_400G);
//fallthrough
case StringConstants.SERVICE_TYPE_100GE_T:
case StringConstants.SERVICE_TYPE_OTU4:
} else {
LOG.debug("Spectrum assignment fixedgrid mode");
pceResult.setResultWavelength(
- GridUtils.getWaveLengthIndexFromSpectrumAssigment(spectrumAssignment.getBeginIndex()
- .toJava()));
+ GridUtils.getWaveLengthIndexFromSpectrumAssigment(spectrumAssignment.getBeginIndex().toJava()));
}
pceResult.setMinFreq(GridUtils.getStartFrequencyFromIndex(spectrumAssignment.getBeginIndex().toJava()));
pceResult.setMaxFreq(GridUtils.getStopFrequencyFromIndex(spectrumAssignment.getStopIndex().toJava()));
LOG.info("In PostAlgoPathValidator: Operational mode Catalog not filled, delegate OSNR calculation"
+ " to GNPy and margin set to 0");
}
-
// Check if MaxLatency is defined in the hard constraints
- if ((pceHardConstraints.getMaxLatency() != -1)
- && (!checkLatency(pceHardConstraints.getMaxLatency(), path))) {
+ if (pceHardConstraints.getMaxLatency() != -1
+ && !checkLatency(pceHardConstraints.getMaxLatency(), path)) {
pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
pceResult.setLocalCause(PceResult.LocalCause.TOO_HIGH_LATENCY);
return pceResult;
}
-
// Check if nodes are included in the hard constraints
if (!checkInclude(path, pceHardConstraints)) {
pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
pceResult.setLocalCause(PceResult.LocalCause.HD_NODE_INCLUDE);
return pceResult;
}
-
// TODO here other post algo validations can be added
// more data can be sent to PceGraph module via PceResult structure if required
-
pceResult.setRC(ResponseCodes.RESPONSE_OK);
pceResult.setLocalCause(PceResult.LocalCause.NONE);
- break;
+ return pceResult;
case StringConstants.SERVICE_TYPE_100GE_M:
case StringConstants.SERVICE_TYPE_10GE:
case StringConstants.SERVICE_TYPE_1GE:
- Map<String, Integer> tribSlotNbMap = Map.of(
- StringConstants.SERVICE_TYPE_100GE_M, 20,
- StringConstants.SERVICE_TYPE_10GE, 8,
- StringConstants.SERVICE_TYPE_1GE, 1);
- int tribSlotNb = tribSlotNbMap.get(serviceType);
+ int tribSlotNb = Map.of(
+ StringConstants.SERVICE_TYPE_100GE_M, 20,
+ StringConstants.SERVICE_TYPE_10GE, 8,
+ StringConstants.SERVICE_TYPE_1GE, 1)
+ .get(serviceType);
pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
pceResult.setServiceType(serviceType);
Map<String, List<Uint16>> tribSlot = chooseTribSlot(path, allPceNodes, tribSlotNb);
Map<String, Uint16> tribPort = chooseTribPort(path, allPceNodes, tribSlot, tribSlotNb);
List<OpucnTribSlotDef> resultTribPortTribSlot = getMinMaxTpTs(tribPort, tribSlot);
-
if (resultTribPortTribSlot.get(0) != null && resultTribPortTribSlot.get(1) != null) {
pceResult.setResultTribPortTribSlot(resultTribPortTribSlot);
pceResult.setRC(ResponseCodes.RESPONSE_OK);
LOG.info("In PostAlgoPathValidator: found TribPort {} - tribSlot {} - tribSlotNb {}",
tribPort, tribSlot, tribSlotNb);
}
- break;
+ return pceResult;
case StringConstants.SERVICE_TYPE_ODU4:
case StringConstants.SERVICE_TYPE_ODUC2:
case StringConstants.SERVICE_TYPE_ODUC3:
pceResult.setRC(ResponseCodes.RESPONSE_OK);
pceResult.setServiceType(serviceType);
LOG.info("In PostAlgoPathValidator: ODU4/ODUCn path found {}", path);
- break;
+ return pceResult;
default:
pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
LOG.warn("In PostAlgoPathValidator checkPath: unsupported serviceType {} found {}",
serviceType, path);
- break;
+ return pceResult;
}
- return pceResult;
}
// Check the latency
private boolean checkLatency(Long maxLatency, GraphPath<String, PceGraphEdge> path) {
double latency = 0;
-
for (PceGraphEdge edge : path.getEdgeList()) {
if (edge.link() == null || edge.link().getLatency() == null) {
LOG.warn("- In checkLatency: the link {} does not contain latency field",
if (listToInclude.isEmpty()) {
return true;
}
-
List<PceGraphEdge> pathEdges = path.getEdgeList();
LOG.debug(" in checkInclude vertex list: [{}]", path.getVertexList());
-
List<String> listOfElementsSubNode = new ArrayList<>();
listOfElementsSubNode.add(pathEdges.get(0).link().getsourceNetworkSupNodeId());
- listOfElementsSubNode.addAll(listOfElementsBuild(pathEdges, PceConstraints.ResourceType.NODE,
- pceHardConstraintsInput));
-
+ listOfElementsSubNode.addAll(
+ listOfElementsBuild(pathEdges, PceConstraints.ResourceType.NODE, pceHardConstraintsInput));
List<String> listOfElementsCLLI = new ArrayList<>();
listOfElementsCLLI.add(pathEdges.get(0).link().getsourceCLLI());
- listOfElementsCLLI.addAll(listOfElementsBuild(pathEdges, PceConstraints.ResourceType.CLLI,
- pceHardConstraintsInput));
-
+ listOfElementsCLLI.addAll(
+ listOfElementsBuild(pathEdges, PceConstraints.ResourceType.CLLI, pceHardConstraintsInput));
List<String> listOfElementsSRLG = new ArrayList<>();
// first link is XPONDEROUTPUT, no SRLG for it
listOfElementsSRLG.add("NONE");
- listOfElementsSRLG.addAll(listOfElementsBuild(pathEdges, PceConstraints.ResourceType.SRLG,
- pceHardConstraintsInput));
-
+ listOfElementsSRLG.addAll(
+ listOfElementsBuild(pathEdges, PceConstraints.ResourceType.SRLG, pceHardConstraintsInput));
// validation: check each type for each element
- List<String> listNodeToInclude = listToInclude
- .stream().filter(rp -> PceConstraints.ResourceType.NODE.equals(rp.getType()))
- .map(ResourcePair::getName).collect(Collectors.toList());
- List<String> listSrlgToInclude = listToInclude
- .stream().filter(rp -> PceConstraints.ResourceType.SRLG.equals(rp.getType()))
- .map(ResourcePair::getName).collect(Collectors.toList());
- List<String> listClliToInclude = listToInclude
- .stream().filter(rp -> PceConstraints.ResourceType.CLLI.equals(rp.getType()))
- .map(ResourcePair::getName).collect(Collectors.toList());
-
- return listOfElementsSubNode.containsAll(listNodeToInclude)
- && listOfElementsSRLG.containsAll(listSrlgToInclude)
- && listOfElementsCLLI.containsAll(listClliToInclude);
+ return listOfElementsSubNode.containsAll(
+ listToInclude
+ .stream().filter(rp -> PceConstraints.ResourceType.NODE.equals(rp.getType()))
+ .map(ResourcePair::getName).collect(Collectors.toList()))
+ && listOfElementsSRLG.containsAll(
+ listToInclude
+ .stream().filter(rp -> PceConstraints.ResourceType.SRLG.equals(rp.getType()))
+ .map(ResourcePair::getName).collect(Collectors.toList()))
+ && listOfElementsCLLI.containsAll(
+ listToInclude
+ .stream().filter(rp -> PceConstraints.ResourceType.CLLI.equals(rp.getType()))
+ .map(ResourcePair::getName).collect(Collectors.toList()));
}
private List<String> listOfElementsBuild(List<PceGraphEdge> pathEdges, PceConstraints.ResourceType type,
- PceConstraints pceHardConstraints) {
-
+ PceConstraints pceHardConstraints) {
List<String> listOfElements = new ArrayList<>();
for (PceGraphEdge link : pathEdges) {
switch (type) {
}
private Map<String, Uint16> chooseTribPort(GraphPath<String,
- PceGraphEdge> path, Map<NodeId, PceNode> allPceNodes, Map<String, List<Uint16>> tribSlotMap, int nbSlot) {
+ PceGraphEdge> path, Map<NodeId, PceNode> allPceNodes, Map<String, List<Uint16>> tribSlotMap, int nbSlot) {
LOG.debug("In choosetribPort: edgeList = {} ", path.getEdgeList());
Map<String, Uint16> tribPortMap = new HashMap<>();
-
for (PceGraphEdge edge : path.getEdgeList()) {
- NodeId linkSrcNode = edge.link().getSourceId();
- String linkSrcTp = edge.link().getSourceTP().getValue();
- NodeId linkDestNode = edge.link().getDestId();
- String linkDestTp = edge.link().getDestTP().getValue();
- PceNode pceOtnNodeSrc = allPceNodes.get(linkSrcNode);
- PceNode pceOtnNodeDest = allPceNodes.get(linkDestNode);
- List<Uint16> srcTpnPool = pceOtnNodeSrc.getAvailableTribPorts().get(linkSrcTp);
- List<Uint16> destTpnPool = pceOtnNodeDest.getAvailableTribPorts().get(linkDestTp);
+ List<Uint16> srcTpnPool =
+ allPceNodes
+ .get(edge.link().getSourceId())
+ .getAvailableTribPorts()
+ .get(edge.link().getSourceTP().getValue());
+ List<Uint16> destTpnPool =
+ allPceNodes
+ .get(edge.link().getDestId())
+ .getAvailableTribPorts()
+ .get(edge.link().getDestTP().getValue());
List<Uint16> commonEdgeTpnPool = new ArrayList<>();
for (Uint16 srcTpn : srcTpnPool) {
if (destTpnPool.contains(srcTpn)) {
commonEdgeTpnPool.add(srcTpn);
}
}
-
- if (!commonEdgeTpnPool.isEmpty()) {
- Integer startTribSlot = tribSlotMap.values().stream().findFirst().get().get(0).toJava();
- Integer tribPort = (int) Math.ceil((double)startTribSlot / nbSlot);
- for (Uint16 commonTribPort : commonEdgeTpnPool) {
- if (tribPort.equals(commonTribPort.toJava())) {
- tribPortMap.put(edge.link().getLinkId().getValue(), commonTribPort);
- }
+ if (commonEdgeTpnPool.isEmpty()) {
+ continue;
+ }
+ Integer startTribSlot = tribSlotMap.values().stream().findFirst().get().get(0).toJava();
+ Integer tribPort = (int) Math.ceil((double)startTribSlot / nbSlot);
+ for (Uint16 commonTribPort : commonEdgeTpnPool) {
+ if (tribPort.equals(commonTribPort.toJava())) {
+ tribPortMap.put(edge.link().getLinkId().getValue(), commonTribPort);
}
}
}
}
private Map<String, List<Uint16>> chooseTribSlot(GraphPath<String,
- PceGraphEdge> path, Map<NodeId, PceNode> allPceNodes, int nbSlot) {
+ PceGraphEdge> path, Map<NodeId, PceNode> allPceNodes, int nbSlot) {
LOG.debug("In choosetribSlot: edgeList = {} ", path.getEdgeList());
Map<String, List<Uint16>> tribSlotMap = new HashMap<>();
-
for (PceGraphEdge edge : path.getEdgeList()) {
- NodeId linkSrcNode = edge.link().getSourceId();
- String linkSrcTp = edge.link().getSourceTP().getValue();
- NodeId linkDestNode = edge.link().getDestId();
- String linkDestTp = edge.link().getDestTP().getValue();
- PceNode pceOtnNodeSrc = allPceNodes.get(linkSrcNode);
- PceNode pceOtnNodeDest = allPceNodes.get(linkDestNode);
- List<Uint16> srcTsPool = pceOtnNodeSrc.getAvailableTribSlots().get(linkSrcTp);
- List<Uint16> destTsPool = pceOtnNodeDest.getAvailableTribSlots().get(linkDestTp);
+ List<Uint16> srcTsPool =
+ allPceNodes
+ .get(edge.link().getSourceId())
+ .getAvailableTribSlots()
+ .get(edge.link().getSourceTP().getValue());
+ List<Uint16> destTsPool =
+ allPceNodes
+ .get(edge.link().getDestId())
+ .getAvailableTribSlots()
+ .get(edge.link().getDestTP().getValue());
List<Uint16> commonEdgeTsPoolList = new ArrayList<>();
List<Uint16> tribSlotList = new ArrayList<>();
for (Uint16 integer : srcTsPool) {
Collections.sort(commonEdgeTsPoolList);
List<Uint16> commonGoodStartEdgeTsPoolList = new ArrayList<>();
for (Uint16 startEdgeTsPool : commonEdgeTsPoolList) {
- if (Integer.valueOf(1).equals(startEdgeTsPool.toJava() % nbSlot)
- || nbSlot == 1) {
+ if (Integer.valueOf(1).equals(startEdgeTsPool.toJava() % nbSlot) || nbSlot == 1) {
commonGoodStartEdgeTsPoolList.add(startEdgeTsPool);
}
}
private List<OpucnTribSlotDef> getMinMaxTpTs(Map<String, Uint16> tribPort, Map<String, List<Uint16>> tribSlot) {
String tribport = tribPort.values().toArray()[0].toString();
- @SuppressWarnings("unchecked")
List<Uint16> tsList = (List<Uint16>) tribSlot.values().toArray()[0];
- OpucnTribSlotDef minOpucnTs = OpucnTribSlotDef
- .getDefaultInstance(String.join(".", tribport, tsList.get(0).toString()));
- OpucnTribSlotDef maxOpucnTs = OpucnTribSlotDef
- .getDefaultInstance(String.join(".", tribport, tsList.get(tsList.size() - 1).toString()));
- List<OpucnTribSlotDef> minmaxTpTsList = new ArrayList<>();
- minmaxTpTsList.add(minOpucnTs);
- minmaxTpTsList.add(maxOpucnTs);
- return minmaxTpTsList;
+ return new ArrayList<>(List.of(
+ OpucnTribSlotDef.getDefaultInstance(String.join(".", tribport, tsList.get(0).toString())),
+ OpucnTribSlotDef.getDefaultInstance(String.join(".", tribport, tsList.get(tsList.size() - 1).toString()))));
}
/**
@SuppressWarnings("deprecation")
@edu.umd.cs.findbugs.annotations.SuppressWarnings("DLS_DEAD_LOCAL_STORE")
private double checkOSNR(GraphPath<String, PceGraphEdge> path, Map<NodeId, PceNode> allPceNodes,
- Map<LinkId, PceLink> allPceLinks, String serviceType, String direction, CatalogUtils cu) {
+ Map<LinkId, PceLink> allPceLinks, String serviceType, String direction, CatalogUtils cu) {
double spacing = 50.0;
double calcPdl2 = 0;
double calcOsnrdB = 0;
double margin = 0;
double pwrIn = -60.0;
double pwrOut = -60.0;
- int pathElement = 0;
int increment = 1;
int offsetLink = 0;
boolean transponderPresent = false;
- if ((StringConstants.SERVICE_DIRECTION_ZA).equals(direction)) {
+ if (direction.equals(StringConstants.SERVICE_DIRECTION_ZA)) {
increment = - 1;
offsetLink = -1;
}
// first level calculation
Map<String, Double> impairments = new HashMap<>();
for (int n = 0; n < vertices.size(); n++) {
- InstanceIdentifier<TerminationPoint1> nwTpIid;
- PceNode nextNode = null;
- if ((StringConstants.SERVICE_DIRECTION_AZ).equals(direction)) {
- pathElement = n ;
- } else {
- pathElement = vertices.size() - n - 1;
- }
+ int pathElement = direction.equals(StringConstants.SERVICE_DIRECTION_AZ) ? n : vertices.size() - n - 1;
PceNode currentNode = allPceNodes.get(new NodeId(vertices.get(pathElement)));
- if (((pathElement != vertices.size() - 1) && (StringConstants.SERVICE_DIRECTION_AZ).equals(direction))
- || ((pathElement != 0) && (StringConstants.SERVICE_DIRECTION_ZA).equals(direction))) {
- nextNode = allPceNodes.get(new NodeId(vertices.get(pathElement + increment)));
- }
+ PceNode nextNode =
+ pathElement != vertices.size() - 1 && direction.equals(StringConstants.SERVICE_DIRECTION_AZ)
+ || pathElement != 0 && direction.equals(StringConstants.SERVICE_DIRECTION_ZA)
+ ? allPceNodes.get(new NodeId(vertices.get(pathElement + increment)))
+ : null;
LOG.debug("loop of check OSNR, n = {} Path Element = {}", n, pathElement);
switch (currentNode.getORNodeType()) {
case XPONDER:
transponderPresent = true;
- String nwTpId = "";
- if (((pathElement == 0) && (StringConstants.SERVICE_DIRECTION_AZ).equals(direction))
- || ((pathElement == (vertices.size() - 1)) && (StringConstants.SERVICE_DIRECTION_ZA)
- .equals(direction))) {
- //First Xponder of the path TX side
- nwTpId = getAppropriatePceLink((pathElement + offsetLink), edges, allPceLinks, direction)
- .getSourceTP().getValue();
- } else {
+ String nwTpId =
+ pathElement == 0 && direction.equals(StringConstants.SERVICE_DIRECTION_AZ)
+ || pathElement == vertices.size() - 1
+ && direction.equals(StringConstants.SERVICE_DIRECTION_ZA)
+ ? getAppropriatePceLink((pathElement + offsetLink), edges, allPceLinks, direction)
+ .getSourceTP()
+ .getValue()
// last Xponder of the path (RX side)
- nwTpId = getAppropriatePceLink((pathElement - offsetLink - 1), edges, allPceLinks, direction)
- .getDestTP().getValue();
- }
- nwTpIid = InstanceIdentifiers.createNetworkTerminationPoint1IIDBuilder(
- vertices.get(pathElement), nwTpId);
+ : getAppropriatePceLink((pathElement - offsetLink - 1), edges, allPceLinks, direction)
+ .getDestTP()
+ .getValue();
+ InstanceIdentifier<TerminationPoint1> nwTpIid =
+ InstanceIdentifiers.createNetworkTerminationPoint1IIDBuilder(vertices.get(pathElement), nwTpId);
LOG.debug("loop of check OSNR : XPDR, n = {} Path Element = {}", n, pathElement);
try {
if (networkTransactionService.read(LogicalDatastoreType.CONFIGURATION, nwTpIid)
.get().isPresent()) {
- XpdrNetworkAttributes xna = networkTransactionService
- .read(LogicalDatastoreType.CONFIGURATION, nwTpIid)
- .get().get().getXpdrNetworkAttributes();
- // If the operational mode of the Xponder is not consistent or
- // if the operational mode of the Xponder is not declared in the topology
- // (Network TP)
- if (currentNode.getXponderOperationalMode(xna).contentEquals(StringConstants.UNKNOWN_MODE)
- || currentNode.getXponderOperationalMode(xna) == null
- || currentNode.getXponderOperationalMode(xna).isEmpty()) {
+// If the Xponder operational mode (setOpMode Arg1) is not consistent or not declared in the topology (Network TP)
+// Operational mode is retrieved from the service Type assuming it is supported by the Xponder (setOpMode Arg2)
+ opMode = setOpMode(
+ currentNode.getXponderOperationalMode(
+ networkTransactionService
+ .read(LogicalDatastoreType.CONFIGURATION, nwTpIid)
+ .get().get().getXpdrNetworkAttributes()),
+ // Operational mode is found as an attribute of the network TP
+ cu.getPceOperationalModeFromServiceType(
+ CatalogConstant.CatalogNodeType.TSP, serviceType));
// Operational mode is retrieved from the service Type assuming it is supported
// by the Xponder
- opMode = cu.getPceOperationalModeFromServiceType(
- CatalogConstant.CatalogNodeType.TSP, serviceType);
- } else {
- // Operational mode is found as an attribute of the network TP
- opMode = currentNode.getXponderOperationalMode(xna);
- }
LOG.debug("Transponder {} corresponding to path Element {} in the path has {} operational "
+ "mode", currentNode.getNodeId().getValue(), pathElement, opMode);
} else {
+ " default Operational Mode {} from serviceType {}", nwTpId, opMode, serviceType);
}
// If TSP is the last of the path
- if (((pathElement == (vertices.size() - 1))
- && (StringConstants.SERVICE_DIRECTION_AZ).equals(direction))
- || ((pathElement == 0) && (StringConstants.SERVICE_DIRECTION_ZA).equals(direction))) {
+ if (pathElement == vertices.size() - 1 && direction.equals(StringConstants.SERVICE_DIRECTION_AZ)
+ || pathElement == 0 && direction.equals(StringConstants.SERVICE_DIRECTION_ZA)) {
LOG.debug("Loop n = {}, Step5.1, XPDR, tries calculating Margin, just before call", n);
// Check that accumulated degradations are compatible with TSP performances
// According to OpenROADM spec :
// If the operational mode of the ADD/DROP MUX is not consistent or
// if the operational mode of the ADD/DROP MUX is not declared in the topology
// (Network TP)
- if (StringConstants.UNKNOWN_MODE.equals(nextNode.getOperationalMode())
- || nextNode.getOperationalMode() == null
- || nextNode.getOperationalMode().isEmpty()) {
// Operational mode is set by default to standard opMode for ADD SRGs
- adnMode = CatalogConstant.MWWRCORE;
- } else {
+ adnMode = setOpMode(nextNode.getOperationalMode(), CatalogConstant.MWWRCORE);
// Operational mode is found in SRG attributes of the Node
- adnMode = nextNode.getOperationalMode();
- }
LOG.debug("Transponder {} corresponding to path Element {} in the path is connected to SRG "
+ "which has {} operational mode", currentNode.getNodeId().getValue(), pathElement,
adnMode);
}
break;
case SRG:
- String srgMode = "";
- // If the operational mode of the ADD/DROP MUX is not consistent or
- // if the operational mode of the ADD/DROP MUX is not declared in the topology
- // (Network TP)
- if (StringConstants.UNKNOWN_MODE.equals(currentNode.getOperationalMode())
- || currentNode.getOperationalMode() == null
- || currentNode.getOperationalMode().isEmpty()) {
- // Operational mode is set by default to standard opMode for ADD/DROP SRGs
- srgMode = CatalogConstant.MWWRCORE;
- } else {
- // Operational mode is found in SRG attributes of the Node
- srgMode = currentNode.getOperationalMode();
- }
+// If the operational mode of the ADD/DROP MUX is not consistent or is not declared in the topology (Network TP)
+// Operational mode is set by default to standard opMode for ADD/DROP SRGs
+ String srgMode = setOpMode(currentNode.getOperationalMode(), CatalogConstant.MWWRCORE);
cnt = CatalogConstant.CatalogNodeType.DROP;
LOG.debug("loop of check OSNR : SRG, n = {} Path Element = {}", n, pathElement);
- if ((pathElement <= 1) && (StringConstants.SERVICE_DIRECTION_AZ).equals(direction)
- || (pathElement >= vertices.size() - 2)
- && (StringConstants.SERVICE_DIRECTION_ZA).equals(direction)) {
+ if (pathElement <= 1 && direction.equals(StringConstants.SERVICE_DIRECTION_AZ)
+ || pathElement >= vertices.size() - 2
+ && direction.equals(StringConstants.SERVICE_DIRECTION_ZA)) {
// This is ADD case : First (optical-tunnel) or 2nd (Regular E2E service from
// Xponder to Xponder) node element of the path is the ADD SRG.
- if (!(getAppropriatePceLink((pathElement + offsetLink), edges, allPceLinks, direction)
- .getlinkType() == OpenroadmLinkType.ADDLINK)) {
+ if (getAppropriatePceLink(pathElement + offsetLink, edges, allPceLinks, direction)
+ .getlinkType() != OpenroadmLinkType.ADDLINK) {
LOG.error("Error processing Node {} for which output link {} is not an ADDLINK Type",
currentNode.getNodeId().toString(), pathElement + offsetLink);
}
pwrIn = 0.0;
pwrOut = cu.getPceRoadmAmpOutputPower(cnt, srgMode,
getAppropriatePceLink((pathElement + 1 + offsetLink * 3), edges, allPceLinks, direction)
- .getspanLoss(), spacing,
+ .getspanLoss(),
+ spacing,
getAppropriatePceLink((pathElement + 1 + offsetLink * 3), edges, allPceLinks, direction)
- .getpowerCorrection());
+ .getpowerCorrection());
LOG.debug("loop of check OSNR : SRG, n = {} link {} Pout = {}",
pathElement, pathElement + 1 + offsetLink * 3, pwrOut);
} else {
// Other case is DROP, for which cnt is unchanged (.DROP)
- if (!(getAppropriatePceLink((pathElement - 1 - offsetLink), edges, allPceLinks, direction)
- .getlinkType() == OpenroadmLinkType.DROPLINK)) {
+ if (getAppropriatePceLink(pathElement - 1 - offsetLink, edges, allPceLinks, direction)
+ .getlinkType() != OpenroadmLinkType.DROPLINK) {
LOG.error("Error processing Node {} for which input link {} is not a DROPLINK Type",
currentNode.getNodeId().toString(), pathElement - 1 - offsetLink);
}
cnt = CatalogConstant.CatalogNodeType.EXPRESS;
String degree1Mode = "";
String degree2Mode = "";
- // If the operational mode of the Degree is not consistent or if the operational
- // mode is not declared in the topology
- if (StringConstants.UNKNOWN_MODE.equals(currentNode.getOperationalMode())
- || currentNode.getOperationalMode() == null
- || currentNode.getOperationalMode().isEmpty()) {
- // Operational mode is set by default to standard opMode for Degree
- degree1Mode = CatalogConstant.MWMWCORE;
- } else {
- // Operational mode is found in degree-attributes of the Node
- degree1Mode = currentNode.getOperationalMode();
- }
+// If the operational mode of the Degree is not consistent or declared in the topology
+// Operational mode is set by default to standard opMode for Degree
+ degree1Mode = setOpMode(currentNode.getOperationalMode(), CatalogConstant.MWMWCORE);
// Same for next node which is the second degree of a ROADM node
- if (StringConstants.UNKNOWN_MODE.equals(nextNode.getOperationalMode())
- || nextNode.getOperationalMode() == null
- || nextNode.getOperationalMode().isEmpty()) {
- degree2Mode = CatalogConstant.MWMWCORE;
- } else {
- degree2Mode = currentNode.getOperationalMode();
- }
+ degree2Mode = setOpMode(nextNode.getOperationalMode(), CatalogConstant.MWMWCORE);
// At that time OpenROADM provides only one spec for the ROADM nodes
if (!degree1Mode.equals(degree2Mode)) {
LOG.info("Unsupported Hybrid ROADM configuration with Degree1 {} of {} operational mode"
direction).getspanLoss();
// Calculate degradation accumulated across incoming Link and add them to
// accumulated impairments
- calcCd += getAppropriatePceLink((pathElement - offsetLink - 1), edges, allPceLinks, direction)
- .getcd();
- calcPmd2 += getAppropriatePceLink((pathElement - offsetLink - 1), edges, allPceLinks, direction)
- .getpmd2();
+ calcCd +=
+ getAppropriatePceLink(pathElement - offsetLink - 1, edges, allPceLinks, direction).getcd();
+ calcPmd2 +=
+ getAppropriatePceLink(pathElement - offsetLink - 1, edges, allPceLinks, direction).getpmd2();
// This also includes Non Linear Contribution from the path
- calcOnsrLin += cu.calculateNLonsrContribution(pwrOut, getAppropriatePceLink((pathElement
- - offsetLink - 1), edges, allPceLinks, direction).getLength(), spacing);
+ calcOnsrLin += cu.calculateNLonsrContribution(pwrOut,
+ getAppropriatePceLink(pathElement - offsetLink - 1, edges, allPceLinks, direction).getLength(),
+ spacing);
// Calculate output power for next span (Output of degree 2)
- pwrOut = cu.getPceRoadmAmpOutputPower(cnt, degree2Mode, getAppropriatePceLink((pathElement
- + 3 * offsetLink + 1), edges, allPceLinks, direction).getspanLoss(), spacing,
- getAppropriatePceLink((pathElement + 3 * offsetLink + 1), edges, allPceLinks, direction)
- .getpowerCorrection());
+ pwrOut = cu.getPceRoadmAmpOutputPower(cnt, degree2Mode,
+ getAppropriatePceLink(pathElement + 3 * offsetLink + 1, edges, allPceLinks, direction)
+ .getspanLoss(),
+ spacing,
+ getAppropriatePceLink(pathElement + 3 * offsetLink + 1, edges, allPceLinks, direction)
+ .getpowerCorrection());
// Adds to accumulated impairments the degradation associated with the Express
// path of ROADM : Degree1, express link, Degree2
impairments = cu.getPceRoadmAmpParameters(cnt, degree2Mode,
+ "that optical tunnel degradations are compatible with external transponder performances");
return 0.0;
}
+ double delta = margin - SYS_MARGIN;
LOG.info("In checkOSNR: Transponder Operational mode {} results in a residual margin of {} dB, according "
+ "to CD, PMD and DGD induced penalties and set System Margin of {} dB.",
- opMode, margin - SYS_MARGIN, SYS_MARGIN);
- String validationMessage = "INVALIDATED";
- if ((margin - SYS_MARGIN) >= 0) {
- validationMessage = "VALIDATED";
- }
- if ((StringConstants.SERVICE_DIRECTION_AZ).equals(direction)) {
- LOG.info("- In checkOSNR: A to Z Path from {} to {} {}", vertices.get(0),
- vertices.get(vertices.size() - 1), validationMessage);
+ opMode, delta, SYS_MARGIN);
+ String validationMessage = delta >= 0 ? "VALIDATED" : "INVALIDATED";
+ if (direction.equals(StringConstants.SERVICE_DIRECTION_AZ)) {
+ LOG.info("- In checkOSNR: A to Z Path from {} to {} {}",
+ vertices.get(0), vertices.get(vertices.size() - 1), validationMessage);
} else {
- LOG.info("- In checkOSNR: Z to A Path from {} to {} {}", vertices.get(vertices.size() - 1),
- vertices.get(0), validationMessage);
+ LOG.info("- In checkOSNR: Z to A Path from {} to {} {}",
+ vertices.get(vertices.size() - 1), vertices.get(0), validationMessage);
}
- return (margin - SYS_MARGIN);
+ return delta;
}
+ private String setOpMode(String opMode, String defaultMode) {
+ return
+ opMode == null || opMode.isEmpty() || opMode.contentEquals(StringConstants.UNKNOWN_MODE)
+ ? defaultMode
+ : opMode;
+ }
+
+
// Method to provide either regular link (AtoZ) or Opposite link (ZtoA) in the list of PceGraphEdges
private PceLink getAppropriatePceLink(Integer pathEltNber, List<PceGraphEdge> edges,
Map<LinkId, PceLink> allPceLinks, String direction) {
return edges.get(pathEltNber).link();
}
//For Z to A direction, must return the opposite link
- return allPceLinks.get(new LinkId(edges.get(pathEltNber).link()
- .getOppositeLink()));
+ return allPceLinks.get(new LinkId(edges.get(pathEltNber).link().getOppositeLink()));
}
private double getOsnrDbfromOnsrLin(double onsrLu) {
BitSet result = BitSet.valueOf(freqMap);
boolean isFlexGrid = true;
LOG.debug("Processing path {} with length {}", path, path.getLength());
- BitSet pceNodeFreqMap;
for (PceGraphEdge edge : path.getEdgeList()) {
- LOG.debug("Processing source {} ", edge.link().getSourceId());
- if (allPceNodes.containsKey(edge.link().getSourceId())) {
- PceNode pceNode = allPceNodes.get(edge.link().getSourceId());
+ NodeId srcNodeId = edge.link().getSourceId();
+ LOG.debug("Processing source {} ", srcNodeId);
+ if (allPceNodes.containsKey(srcNodeId)) {
+ PceNode pceNode = allPceNodes.get(srcNodeId);
LOG.debug("Processing PCE node {}", pceNode);
- if (StringConstants.OPENROADM_DEVICE_VERSION_1_2_1.equals(pceNode.getVersion())) {
+ String pceNodeVersion = pceNode.getVersion();
+ NodeId pceNodeId = pceNode.getNodeId();
+ BigDecimal sltWdthGran = pceNode.getSlotWidthGranularity();
+ BigDecimal ctralFreqGran = pceNode.getCentralFreqGranularity();
+ if (StringConstants.OPENROADM_DEVICE_VERSION_1_2_1.equals(pceNodeVersion)) {
LOG.debug("Node {}: version is {} and slot width granularity is {} -> fixed grid mode",
- pceNode.getNodeId(), pceNode.getVersion(), pceNode.getSlotWidthGranularity());
+ pceNodeId, pceNodeVersion, sltWdthGran);
isFlexGrid = false;
}
- if ((pceNode.getSlotWidthGranularity().setScale(0, RoundingMode.CEILING)
- .equals(GridConstant.SLOT_WIDTH_50))
- && (pceNode.getCentralFreqGranularity().setScale(0, RoundingMode.CEILING)
- .equals(GridConstant.SLOT_WIDTH_50))) {
- LOG.debug("Node {}: version is {} with slot width granularity {} and central "
+ if (sltWdthGran.setScale(0, RoundingMode.CEILING).equals(GridConstant.SLOT_WIDTH_50)
+ && ctralFreqGran.setScale(0, RoundingMode.CEILING).equals(GridConstant.SLOT_WIDTH_50)) {
+ LOG.debug("Node {}: version is {} with slot width granularity {} and central "
+ "frequency granularity is {} -> fixed grid mode",
- pceNode.getNodeId(), pceNode.getVersion(), pceNode.getSlotWidthGranularity(),
- pceNode.getCentralFreqGranularity());
+ pceNodeId, pceNodeVersion, sltWdthGran, ctralFreqGran);
isFlexGrid = false;
}
- pceNodeFreqMap = pceNode.getBitSetData();
+ BitSet pceNodeFreqMap = pceNode.getBitSetData();
LOG.debug("Pce node bitset {}", pceNodeFreqMap);
if (pceNodeFreqMap != null) {
result.and(pceNodeFreqMap);
* @return a spectrum assignment object which contains begin and stop index. If
* no spectrum assignment found, beginIndex = stopIndex = 0
*/
- private SpectrumAssignment computeBestSpectrumAssignment(BitSet spectrumOccupation, int spectralWidthSlotNumber,
- boolean isFlexGrid) {
+ private SpectrumAssignment computeBestSpectrumAssignment(
+ BitSet spectrumOccupation, int spectralWidthSlotNumber, boolean isFlexGrid) {
SpectrumAssignmentBuilder spectrumAssignmentBldr = new SpectrumAssignmentBuilder()
.setBeginIndex(Uint16.valueOf(0))
.setStopIndex(Uint16.valueOf(0))
.setFlexGrid(isFlexGrid);
BitSet referenceBitSet = new BitSet(spectralWidthSlotNumber);
referenceBitSet.set(0, spectralWidthSlotNumber);
- int nbSteps = isFlexGrid ? spectralWidthSlotNumber : 1;
//higher is the frequency, smallest is the wavelength number
//in operational, the allocation is done through wavelength starting from the smallest
//so we have to loop from the last element of the spectrum occupation
- for (int i = spectrumOccupation.size(); i >= spectralWidthSlotNumber; i -= nbSteps) {
+ for (int i = spectrumOccupation.size(); i >= spectralWidthSlotNumber;
+ i -= isFlexGrid ? spectralWidthSlotNumber : 1) {
if (spectrumOccupation.get(i - spectralWidthSlotNumber, i).equals(referenceBitSet)) {
spectrumAssignmentBldr.setBeginIndex(Uint16.valueOf(i - spectralWidthSlotNumber));
spectrumAssignmentBldr.setStopIndex(Uint16.valueOf(i - 1));
Code Review / transportpce.git / blobdiff