pce/src/main/java/org/opendaylight/transportpce/pce/gnpy/GnpyTopoImpl.java

   1 /*
   2  * Copyright © 2019 Orange, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.transportpce.pce.gnpy;
  10
  11 import java.math.BigDecimal;
  12 import java.util.ArrayList;
  13 import java.util.Collection;
  14 import java.util.HashMap;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.concurrent.ExecutionException;
  18 import java.util.stream.IntStream;
  19 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  20 import org.opendaylight.transportpce.common.NetworkUtils;
  21 import org.opendaylight.transportpce.common.network.NetworkTransactionService;
  22 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.Coordinate;
  23 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.Km;
  24 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.edfa.params.Operational;
  25 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.edfa.params.OperationalBuilder;
  26 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.element.type.choice.element.type.Edfa;
  27 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.element.type.choice.element.type.EdfaBuilder;
  28 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.element.type.choice.element.type.FiberRoadmBuilder;
  29 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.element.type.choice.element.type.Transceiver;
  30 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.element.type.choice.element.type.TransceiverBuilder;
  31 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.element.type.choice.element.type.fiberroadm.Params;
  32 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.element.type.choice.element.type.fiberroadm.ParamsBuilder;
  33 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.element.type.choice.element.type.fiberroadm.params.fiberroadmfused.Fiber;
  34 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.element.type.choice.element.type.fiberroadm.params.fiberroadmfused.FiberBuilder;
  35 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.element.type.choice.element.type.fiberroadm.params.fiberroadmfused.Roadm;
  36 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.element.type.choice.element.type.fiberroadm.params.fiberroadmfused.RoadmBuilder;
  37 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.location.attributes.Location;
  38 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.location.attributes.LocationBuilder;
  39 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.topo.Connections;
  40 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.topo.ConnectionsBuilder;
  41 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.topo.Elements;
  42 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.topo.ElementsBuilder;
  43 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.topo.ElementsKey;
  44 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.topo.elements.Metadata;
  45 import org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.topo.elements.MetadataBuilder;
  46 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210.Link1;
  47 import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev211210.SpanAttributes;
  48 import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev211210.amplified.link.attributes.AmplifiedLink;
  49 import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev211210.amplified.link.attributes.amplified.link.section.element.section.element.Span;
  50 import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev211210.amplified.link.attributes.amplified.link.section.element.section.element.ila.Ila;
  51 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.rev211210.Node1;
  52 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210.networks.network.link.OMSAttributes;
  53 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmLinkType;
  54 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.link.concatenation.LinkConcatenation;
  55 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
  56 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks;
  57 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network;
  58 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkKey;
  59 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
  60 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNode;
  61 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Network1;
  62 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link;
  63 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  64 import org.opendaylight.yangtools.yang.common.Decimal64;
  65 import org.slf4j.Logger;
  66 import org.slf4j.LoggerFactory;
  67
  68 /**
  69  * Class to create the topology corresponding to GNPy requirements.
  70  *
  71  * @author Ahmed Triki ( ahmed.triki@orange.com )
  72  *
  73  */
  74
  75 public class GnpyTopoImpl {
  76     private static final Logger LOG = LoggerFactory.getLogger(GnpyTopoImpl.class);
  77     private final NetworkTransactionService networkTransactionService;
  78     //List of elements
  79     private Map<ElementsKey, Elements> elements = new HashMap<>();
  80     private List<Connections> connections = new ArrayList<>();
  81     private List<String> elementsList = new ArrayList<>();
  82     //Mapping elements
  83     //Mapping between the ord-topo and ord-ntw node
  84     private Map<String, String> mapDisgNodeRefNode = new HashMap<>();
  85     //Mapping between the ROADM-ROADM linkId/secElement and the linkId
  86     private Map<String, List<String>> mapLinkFiber = new HashMap<>();
  87     //List of Xponders
  88     private List<String> trxList = new ArrayList<>();
  89     private static final double LATITUDE = 0;
  90     private static final double LONGITUTE = 0;
  91     private static final String REGION = "N/A";
  92     private static final String CITY = "N/A";
  93     private static final int CONVERT_KM_M = 1000;
  94     private static final double TARGET_PCH_OUT_DB = -20;
  95
  96     /*
  97      * Construct the ExtractTopoDataStoreImpl.
  98      */
  99     public GnpyTopoImpl(final NetworkTransactionService networkTransactionService) throws GnpyException {
 100         this.networkTransactionService = networkTransactionService;
 101         extractTopo();
 102     }
 103
 104     /*
 105      * extract the topology
 106      *
 107      */
 108     private void extractTopo() throws GnpyException {
 109         // Define the instance identifier of the OpenRoadm topology
 110         InstanceIdentifier<Network> insIdOpenRoadmTopo = InstanceIdentifier
 111                 .builder(Networks.class)
 112                 .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))).build();
 113         // Define the instance identifier of the OpenRoadm network
 114         InstanceIdentifier<Network> insIdrOpenRoadmNet = InstanceIdentifier
 115                 .builder(Networks.class)
 116                 .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID))).build();
 117         try {
 118             // Initialize the reading of the networkTransactionService
 119             // read the configuration part of the data broker that concerns the openRoadm topology and get all the nodes
 120             java.util.Optional<Network> openRoadmTopo = this.networkTransactionService
 121                     .read(LogicalDatastoreType.CONFIGURATION, insIdOpenRoadmTopo).get();
 122             java.util.Optional<Network> openRoadmNet = this.networkTransactionService
 123                     .read(LogicalDatastoreType.CONFIGURATION, insIdrOpenRoadmNet).get();
 124             if (openRoadmNet.isPresent() && openRoadmTopo.isPresent()) {
 125                 extractElements(openRoadmTopo,openRoadmNet);
 126                 extractConnections(openRoadmTopo);
 127                 LOG.debug("In GnpyTopoImpl : elements and connections are well extracted");
 128             }
 129             else {
 130                 throw new GnpyException(
 131                     "In GnpyTopoImpl : openroadm topology network or openroadm network are not well mounted ...");
 132             }
 133         } catch (InterruptedException | ExecutionException e) {
 134             this.networkTransactionService.close();
 135             throw new GnpyException("In gnpyTopoImpl: error in reading the topology", e);
 136         }
 137         this.networkTransactionService.close();
 138     }
 139
 140     private void extractElements(java.util.Optional<Network> openRoadmTopo,
 141             java.util.Optional<Network> openRoadmNet) throws GnpyException {
 142         if ((!openRoadmNet.isPresent()) || (!openRoadmTopo.isPresent())) {
 143             throw new GnpyException("In gnpyTopoImpl: openRoadmNet or openRoadmTopo is not present");
 144         }
 145         // Create the list of nodes
 146         Collection<Node> openRoadmNetNodeList = openRoadmNet.get().nonnullNode().values();
 147         Collection<Node> openRoadmTopoNodeList = openRoadmTopo.get().nonnullNode().values();
 148
 149         if (openRoadmTopoNodeList.isEmpty() || openRoadmNetNodeList.isEmpty()) {
 150             throw new GnpyException("In gnpyTopoImpl: no nodes in the openradm topology or openroadm network");
 151         }
 152         // Create elements
 153         for (Node openRoadmTopoNode : openRoadmTopoNodeList) {
 154             // Retrieve the supporting node and the type of the node in openRoadm network
 155             Collection<SupportingNode> supportingNodeList = openRoadmTopoNode.nonnullSupportingNode().values();
 156
 157             for (SupportingNode supportingNode : supportingNodeList) {
 158                 if (!supportingNode.getNetworkRef().getValue().equals("openroadm-network")) {
 159                     continue;
 160                 }
 161                 String nodeRef = supportingNode.getNodeRef().getValue();
 162                 if (nodeRef == null) {
 163                     throw new GnpyException("In gnpyTopoImpl: nodeRef is null");
 164                 }
 165                 // Retrieve the mapping between the openRoadm topology and openRoadm network
 166                 mapDisgNodeRefNode.put(openRoadmTopoNode.getNodeId().getValue(), nodeRef);
 167                 Node1 openRoadmNetNode1 = null;
 168                 org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev211210
 169                     .Node1 commonNetworkNode1 = null;
 170                 for (Node openRoadmNetNode : openRoadmNetNodeList) {
 171                     if (openRoadmNetNode.getNodeId().getValue().equals(nodeRef)) {
 172                         openRoadmNetNode1 = openRoadmNetNode.augmentation(Node1.class);
 173                         commonNetworkNode1 = openRoadmNetNode.augmentation(org.opendaylight.yang.gen.v1
 174                             .http.org.openroadm.common.network.rev211210.Node1.class);
 175                         break;
 176                     }
 177                 }
 178                 if (commonNetworkNode1 == null) {
 179                     throw new GnpyException(String.format("In gnpyTopoImpl: the node type of %s is null",nodeRef));
 180                 }
 181                 if (commonNetworkNode1.getNodeType().getName().equals("ROADM")) {
 182                     if (!elementsList.contains(nodeRef)) {
 183                         Elements element = createElementsRoadm(LATITUDE, LONGITUTE, nodeRef,
 184                                 openRoadmNetNode1.getShelf(),TARGET_PCH_OUT_DB, nodeRef);
 185                         this.elements.put(element.key(),element);
 186                         elementsList.add(nodeRef);
 187                     }
 188                 } else if (commonNetworkNode1.getNodeType().getName().equals("XPONDER")) {
 189                     if (!elementsList.contains(nodeRef)) {
 190                         Elements element = createElementsTransceiver(LATITUDE, LONGITUTE, nodeRef,
 191                                 openRoadmNetNode1.getShelf(), nodeRef);
 192                         this.elements.put(element.key(),element);
 193                         elementsList.add(nodeRef);
 194                         trxList.add(nodeRef);
 195                     }
 196                 } else {
 197                     throw new GnpyException("In gnpyTopoImpl: the type is not implemented");
 198                 }
 199             }
 200         }
 201     }
 202
 203     private void extractConnections(java.util.Optional<Network> openRoadmTopo) throws GnpyException {
 204         // Create the list of connections
 205         if (!openRoadmTopo.isPresent()) {
 206             throw new GnpyException("In gnpyTopoImpl: openroadmTopo is not present");
 207         }
 208         Network1 nw1 = openRoadmTopo.get().augmentation(Network1.class);
 209         Collection<Link> linksList = nw1.nonnullLink().values();
 210         // 1:EXPRESS-LINK    2:ADD-LINK       3:DROP-LINK
 211         // 4:ROADM-To-ROADM  5:XPONDER-INPUT  6:XPONDER-OUTPUT
 212         int[] externalLink = {OpenroadmLinkType.ROADMTOROADM.getIntValue(),OpenroadmLinkType.XPONDERINPUT.getIntValue(),
 213             OpenroadmLinkType.XPONDEROUTPUT.getIntValue()};
 214
 215         if (linksList.isEmpty()) {
 216             throw new GnpyException("In gnpyTopoImpl: no links in the network");
 217         }
 218
 219         for (Link link : linksList) {
 220             Link1 link1 = link.augmentation(Link1.class);
 221             org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev211210
 222                 .Link1 openroadmNetworkLink1 = link.augmentation(org.opendaylight.yang.gen.v1.http
 223                         .org.openroadm.network.topology.rev211210.Link1.class);
 224             if (link1.getLinkType() == null) {
 225                 throw new GnpyException("In gnpyTopoImpl: the link type is null");
 226             }
 227             int linkType = link1.getLinkType().getIntValue();
 228             if (! IntStream.of(externalLink).anyMatch(x -> x == linkType)) {
 229                 continue;
 230             }
 231
 232             String srcId = mapDisgNodeRefNode.get(link.getSource().getSourceNode().getValue());
 233             String linkId = link.getLinkId().getValue();
 234             String destId = null;
 235             if (linkType == OpenroadmLinkType.ROADMTOROADM.getIntValue()) {
 236                 OMSAttributes omsAttributes = openroadmNetworkLink1.getOMSAttributes();
 237                 if (omsAttributes == null) {
 238                     throw new GnpyException(String.format(
 239                         "In gnpyTopoImpl: OMS attributes do not exit for ROADM to ROADM link: %s",linkId));
 240                 }
 241                 //Case of amplified link
 242                 if (omsAttributes.getAmplifiedLink() != null) {
 243                     srcId = extractAmplifiedLink(omsAttributes, linkId, srcId);
 244                 }
 245                 //Case of one span link
 246                 if (omsAttributes.getSpan() != null) {
 247                     srcId = extractSpanLink(omsAttributes, linkId, srcId);
 248                 }
 249             }
 250             // Create a new link
 251             destId = mapDisgNodeRefNode.get(link.getDestination().getDestNode().getValue());
 252             createNewConnection(srcId,destId);
 253         }
 254     }
 255
 256     private String extractAmplifiedLink(OMSAttributes omsAttributes, String linkId, String srcId)
 257         throws GnpyException {
 258
 259         List<AmplifiedLink> amplifiedLinkList = new ArrayList<>(omsAttributes.getAmplifiedLink()
 260             .nonnullAmplifiedLink().values());
 261         String destId = null;
 262         if (!amplifiedLinkList.isEmpty()) {
 263             for (AmplifiedLink amplifiedLink: amplifiedLinkList) {
 264                 String secElt = amplifiedLink .getSectionEltNumber().toString();
 265                 //Case of ILA
 266                 if (amplifiedLink.getSectionElement().getSectionElement() instanceof Ila) {
 267                     Ila ila = (Ila) amplifiedLink.getSectionElement().getSectionElement();
 268                     destId = extractILAFromAmpLink(ila);
 269                 }
 270                 //Case of Span
 271                 if (amplifiedLink.getSectionElement().getSectionElement() instanceof Span) {
 272                     Span span = (Span) amplifiedLink.getSectionElement().getSectionElement();
 273                     destId = extractSpan(span.getSpan(), linkId, secElt);
 274                 }
 275                 // Create a new link
 276                 if (createNewConnection(srcId,destId)) {
 277                     srcId = destId;
 278                 }
 279             }
 280         }
 281         return srcId;
 282     }
 283
 284     private String extractSpanLink(OMSAttributes omsAttributes, String linkId, String srcId)
 285         throws GnpyException {
 286
 287         SpanAttributes span = omsAttributes.getSpan();
 288         String destId = extractSpan(span, linkId, linkId);
 289         if (createNewConnection(srcId, destId)) {
 290             return destId;
 291         }
 292         return srcId;
 293     }
 294
 295     private String extractILAFromAmpLink(Ila ila) throws GnpyException {
 296         String nodeId = ila.getNodeId().getValue();
 297         mapDisgNodeRefNode.put(nodeId, nodeId);
 298         Elements element = createElementsEdfa(LATITUDE, LONGITUTE, REGION, CITY,
 299                 ila.getGain().getValue().decimalValue(), ila.getTilt().getValue().decimalValue(),
 300                 ila.getOutVoaAtt().getValue().decimalValue(), "std_medium_gain",
 301                 nodeId);
 302         this.elements.put(element.key(),element);
 303         return nodeId;
 304     }
 305
 306     private String extractSpan(SpanAttributes span, String linkId, String subLinkId) throws GnpyException {
 307         if (!mapLinkFiber.containsKey(linkId)) {
 308             mapLinkFiber.put(linkId, new ArrayList<>());
 309         }
 310         mapLinkFiber.get(linkId).add(subLinkId);
 311         //mapFiberIp.put(subLinkId, ipFiber);
 312         //fiberId = incrementIdentifier(fiberId);
 313         double attIn = 0;
 314         double connIn = 0;
 315         double connOut = 0;
 316         String typeVariety = "SSMF";
 317         double length = 0;
 318         // Compute the length of the link
 319         for (LinkConcatenation linkConcatenation : span.nonnullLinkConcatenation().values()) {
 320             double srlgLength = linkConcatenation.getSRLGLength().doubleValue();
 321             //convert to kilometer
 322             length += srlgLength / CONVERT_KM_M;
 323         }
 324         if (length == 0) {
 325             throw new GnpyException(String.format(
 326                 "In gnpyTopoImpl: length of the link %s is equal to zero",linkId));
 327         }
 328         double lossCoef = span.getSpanlossCurrent().getValue().doubleValue() / length;
 329         Elements element = createElementsFiber(LATITUDE, LONGITUTE, REGION, CITY,
 330                 subLinkId, length, attIn, lossCoef, connIn, connOut, typeVariety);
 331         this.elements.put(element.key(),element);
 332         return subLinkId;
 333     }
 334
 335     /*
 336      * Method to create Fiber
 337      */
 338     private Elements createElementsFiber(double latitude, double longitude, String region, String city, String uidFiber,
 339             double length, double attIn, double lossCoef, double connIn, double connOut, String typeVariety) {
 340         // Create an amplifier after the ROADM
 341         Coordinate c1 = new Coordinate(Decimal64.valueOf(String.valueOf(latitude)));
 342         Coordinate c2 = new Coordinate(Decimal64.valueOf(String.valueOf(longitude)));
 343         Location location1 = new LocationBuilder().setRegion(region).setCity(city).setLatitude(c1).setLongitude(c2)
 344                 .build();
 345         Metadata metadata1 = new MetadataBuilder().setLocation(location1).build();
 346         Fiber fiber = new FiberBuilder()
 347             .setLength(Decimal64.valueOf(String.valueOf(length)))
 348             .setLengthUnits(Km.class)
 349             .setAttIn(Decimal64.valueOf(String.valueOf(attIn)))
 350             .setLossCoef(Decimal64.valueOf(String.valueOf(lossCoef)))
 351             .setConIn(Decimal64.valueOf(String.valueOf(connIn)))
 352             .setConOut(Decimal64.valueOf(String.valueOf(connOut)))
 353             .build();
 354         Params params1 = new ParamsBuilder().setFiberroadmfused(fiber).build();
 355         return new ElementsBuilder().setUid(uidFiber)
 356                 .setType(org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.Fiber.class)
 357                 .setTypeVariety(typeVariety).setMetadata(metadata1)
 358                 .setElementType(new FiberRoadmBuilder().setParams(params1).build()).build();
 359     }
 360
 361     /*
 362      * Method to create EDFA
 363      */
 364     private Elements createElementsEdfa(double latitude, double longitude, String region, String city,
 365             BigDecimal gainTarget, BigDecimal tiltTarget, BigDecimal outVoa, String typeVariety, String uidEdfa) {
 366         // Create an amplifier after the ROADM
 367         Coordinate c1 = new Coordinate(Decimal64.valueOf(String.valueOf(latitude)));
 368         Coordinate c2 = new Coordinate(Decimal64.valueOf(String.valueOf(longitude)));
 369         Location location1 = new LocationBuilder().setRegion(region).setCity(city).setLatitude(c1).setLongitude(c2)
 370                 .build();
 371         Metadata metadata1 = new MetadataBuilder().setLocation(location1).build();
 372         Operational operational = new OperationalBuilder()
 373             .setGainTarget(Decimal64.valueOf(gainTarget))
 374             .setTiltTarget(Decimal64.valueOf(tiltTarget))
 375             .setOutVoa(Decimal64.valueOf(outVoa))
 376             .build();
 377         Edfa edfa = new EdfaBuilder()
 378                 .setOperational(operational).build();
 379         return new ElementsBuilder().setUid(uidEdfa)
 380                 .setType(org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.Edfa.class)
 381                 .setMetadata(metadata1).setElementType(edfa).setTypeVariety(typeVariety).build();
 382     }
 383
 384     /*
 385      * Method to create ROADM
 386      */
 387     private Elements createElementsRoadm(double latitude, double longitude, String region, String city,
 388             double targetPchOutDb, String uidRoadm) {
 389         Coordinate c1 = new Coordinate(Decimal64.valueOf(String.valueOf(latitude)));
 390         Coordinate c2 = new Coordinate(Decimal64.valueOf(String.valueOf(longitude)));
 391         Location location1 = new LocationBuilder().setRegion(region).setCity(city).setLatitude(c1).setLongitude(c2)
 392                 .build();
 393         Metadata metadata1 = new MetadataBuilder().setLocation(location1).build();
 394         Roadm roadm = new RoadmBuilder()
 395             .setTargetPchOutDb(Decimal64.valueOf(String.valueOf(targetPchOutDb)))
 396             .build();
 397         Params params1 = new ParamsBuilder().setFiberroadmfused(roadm).build();
 398         return new ElementsBuilder().setUid(uidRoadm)
 399                 .setType(org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.Roadm.class)
 400                 .setMetadata(metadata1).setElementType(new FiberRoadmBuilder().setParams(params1).build()).build();
 401     }
 402
 403     /*
 404      * Method to create Transceiver
 405      */
 406     private Elements createElementsTransceiver(double latitude, double longitude, String region, String city,
 407             String uidTrans) {
 408         Coordinate c1 = new Coordinate(Decimal64.valueOf(String.valueOf(latitude)));
 409         Coordinate c2 = new Coordinate(Decimal64.valueOf(String.valueOf(longitude)));
 410         Location location1 = new LocationBuilder().setRegion(region).setCity(city).setLatitude(c1).setLongitude(c2)
 411                 .build();
 412         Metadata metadata1 = new MetadataBuilder().setLocation(location1).build();
 413         Transceiver transceiver = new TransceiverBuilder().build();
 414         return new ElementsBuilder().setUid(uidTrans)
 415                 .setType(org.opendaylight.yang.gen.v1.gnpy.gnpy.network.topology.rev220615.Transceiver.class)
 416                 .setMetadata(metadata1).setElementType(transceiver).build();
 417     }
 418
 419     /*
 420      * Method to create Connection
 421      */
 422     private boolean createNewConnection(String fromNode, String toNode) throws GnpyException {
 423         if (fromNode == null || toNode == null) {
 424             throw new GnpyException("create new connection : null node IpAddress");
 425         }
 426         if (fromNode.equals(toNode)) {
 427             return false;
 428         }
 429         Connections connection = new ConnectionsBuilder().setFromNode(fromNode).setToNode(toNode).build();
 430         this.connections.add(connection);
 431         return true;
 432     }
 433
 434     public Map<ElementsKey, Elements> getElements() {
 435         return elements;
 436     }
 437
 438     public void setElements(Map<ElementsKey, Elements> elements) {
 439         this.elements = elements;
 440     }
 441
 442     public List<Connections> getConnections() {
 443         return connections;
 444     }
 445
 446     public void setConnections(List<Connections> connections) {
 447         this.connections = connections;
 448     }
 449
 450     public List<String> getElementsList() {
 451         return elementsList;
 452     }
 453
 454     public void setElementsList(List<String> elementsList) {
 455         this.elementsList = elementsList;
 456     }
 457
 458     public Map<String, String> getMapDisgNodeRefNode() {
 459         return mapDisgNodeRefNode;
 460     }
 461
 462     public void setMapDisgNodeRefNode(Map<String, String> mapDisgNodeRefNode) {
 463         this.mapDisgNodeRefNode = mapDisgNodeRefNode;
 464     }
 465
 466     public Map<String, List<String>> getMapLinkFiber() {
 467         return mapLinkFiber;
 468     }
 469
 470     public void setMapLinkFiber(Map<String, List<String>> mapLinkFiber) {
 471         this.mapLinkFiber = mapLinkFiber;
 472     }
 473
 474     public List<String> getTrxList() {
 475         return trxList;
 476     }
 477
 478     public void setTrxList(List<String> trxList) {
 479         this.trxList = trxList;
 480     }
 481 }