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