WDMUtils (net2plan-javadoc 0.6.0.1 API)

java.lang.Object
- com.net2plan.libraries.WDMUtils

```
public class WDMUtils
extends Object
```
Class to deal with WDM optical topologies in fixed-grid and flexi-grid networks, including wavelength assignment and regenerator placement.
Optical networks have been established as the enabling technology for today’s high-speed communication networks. Wavelength Division Multiplexing (WDM) enables the efficient utilization of optical fibers by dividing its tremendous bandwidth into a set of disjoint channels.

The so-called wavelength grid determines the wavelengths or wavebands used by a channel:
- In fixed-grid networks, all the channels have the same width, typically of 100 GHz or 50 GHz. For instance, according to the 100 GHz ITU-T grid, first channel in the C-band has a central frequency of 196.1 THz, next 196.0 THz, next 195.9 THz... (until 191.2 THz, the last channel in the C-band). In this case each channel is typically called a wavelength.
- Flexi-grid networks are a generalization of fixed-grid networks, where the width of a channel is an integer multiple of the width of a so-called frequency slot (typically 12.5 GHz). A channel can typically aggregate up to tens of slots. In general (but not always), these slots are constrained to be contiguous.
Flexi-grid networks where all the channels occupy exactly one frequency slot, and the width of the slot is e.g. 100 GHz, are equivalent to a fixed-grid network with a 100 GHz width. For this reason, after Net2Plan 0.4.1 we have put together inside WDMUtils the functionalities of both fixed and flexi grid WDM networks (formerly, flexi-grid networks were dealt with in FlexiGridUtils library, now eliminated).

Wavelength-routed networks

In wavelength-routed WDM networks, all-optical channels traversing several fibers, called lightpaths, can be established between pairs of nodes. A lightpath occupies one channel (a wavelength in fixed-grid networks, and a set of frequency slots in flexi-grid networks) in each traversed link, and two lightpaths routed over the same physical link cannot use the same frequency slot in that link. This is called the wavelength or frequency slot clash constraint. The Routing and Spectrum Assignment (RSA) problem and the Routing and Wavelength Assignment (RWA) problem in flexi and fixed grid WDM networks respectively are the ones deciding for each lightpath the route and frequency slots (wavelengths) to occupy in each traversed fiber. Typically, the wavelength/slots of a lightpath cannot change along the traversed fibers (since wavelength converters are not available). In this case we say that the problem has the wavelength continuity constraint.
Higher layers in the network see a lightpath as a pipe to transmit traffic, and they are not necessarily aware of the actual sequence of fiber links of the lightpath.

The line rate of the lightpath is its capacity e.g. in Gbps. Typical line rates are 10, 40 and 100 Gbps. In flexi-grid networks, it is possible to have lightpaths of different line rates, that occupy the same number of frequency slots. This is because, the transponders (the ones transmitting and receiving the optical signals) can be based on different optical modulations with different spectral efficiencies. For instance, a transponder using BPSK modulation has a spectral efficiency of 1 bps/Hz, while a more sophisticated transponder using 16-QAM has 4 bps/Hz.

Nodes in wavelength-routed networks are called Optical Add/Drop Multiplexers (OADMs). They are able to add new lightpaths initiated in the node, drop lightpaths terminating in the node, and optically switch (bypass) lightpaths that traverse the node. Usually, a lightpath occupies the same wavelength in all the traversed links. This is called the wavelength continuity constraint. However, it is possible (so far only in fixed-grid networks) to allocate optical wavelength converters at intermediate nodes of the lightpath that are able to change its wavelength. Nowadays, wavelength converters are composed of an opto-electronic receiver attached to an electro-optic transmitter. Then, the optical signal is regenerated, while its wavelength can be modified. More often, optical regenerators are used not for changing the wavelength in an intermediate node of a lightpath, but to regenerate the optical signal recovering it from its normal degradation caused by channel noise and other impairments.

In Net2Plan, the WDMUtils library is provided to ease the handling of WDM networks. WDMUtils assumptions are:
- Network layer: A WDM network is represented by a network layer. Typically, the layer name is set to "WDM" (although this is not mandatory). The measure units for the traffic in this layer is assumed to be Gbps. In its turn, the capacity of the links is assumed to be measured in number of frequency slots.
- Links: Each link in the WDM network layer is an optical fibre. The capacity of the link is measured as the (integer) number of frequency slots available in that fiber. For instance, a typical WDM network using the C-band in 50 GHz channels, has 80 available waveleneghts, and thus the link capacity is 80.
- Nodes: Each node in the network with input/output links in the WDM layer, represents an Optical Add/Drop Multiplexer (OADMs) capable of routing lightpaths.
- Demands: A demand is here an intention to carry traffic between two OADMS. The offered traffic is assumed to be measured in Gbps (e.g. typically 10 Gbps, 40 Gbps, 100 Gbps).
- Routes: A route represents a lightpath. The carried traffic of the lightpath corresponds to the lighptath line rate. The occupied link capacity of the lightpath is the total number of slots occupied (the same total number in all the traversed links). For specifying the particular frequency slots occupied by a lightpath in a link, in Net2Plan we assume that frequency slots in any link are numbered with consecutive numbers starting from zero 0,1,2,... The lowest number typically corresponds to the lower wavelength. The set of frequency slots occupied by a lightpath in each traversed link is stored by WDMUtils in a route attribute, in an internal format. The user using the WDMUtils library does not need to bother about the details of this format. Additionally, it is possible to define the set of nodes where the optical signal goes through a regenerator of the optical signal (with or without wavelength conversion). This information is also stored as Route attributes.
- Protection segments: Zero, one or more protection segments can be associated to the route, representing (partial or total) backup lightpaths that protect the primary route. The occupied link capacity of the protection segment reflects the total number of frequency slots reserved in the traversed links. The actual set of slots reserved in each traversed, and the places where the signal is regenerated (if any) are also stored by WDMUtils in segment attributes
Offline and online network design algorithms for fixed/flexi grid WDM networks, as well as reports for showing WDM physical layer and RSA allocation information, can be found in the Net2Plan code repository under keyword WDM.
Author:

Pablo Pavon Mariño

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`WDMUtils.LightpathAdd` This class represents the request to add a new lightpath.
`static class`	`WDMUtils.LightpathModify` This class represents the request to modify an existing lightpath.
`static class`	`WDMUtils.LightpathRemove` This class represents the request to remove an existing lightpath.
`static class`	`WDMUtils.ModulationFormat` Class to define typical modulation formats.
`static class`	`WDMUtils.RSA` This class represents a Routing and Spectrum Assignment, valid for a lightpath in both fixed and flexi-grid WDM networks.
`static class`	`WDMUtils.TransponderTypesInfo` This class is devoted to give easy access to the transponders information provided by the user in the typical user-defined parameters `transponderTypesInfo`.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Route`	`addLightpath(Demand demand, WDMUtils.RSA rsa, double lineRateGbps)` Creates a new lightpath with the given RSA, as a `Route` object.
`static void`	`allocateResources(WDMUtils.RSA rsa, DoubleMatrix2D frequencySlot2FiberOccupancy_se, DoubleMatrix1D nodeRegeneratorOccupancy)` Updates `frequencySlot2FiberOccupancy_se` and `nodeRegeneratorOccupancy` to consider that a new lightpath is occupying the resources given by `rsa`.
`static void`	`checkResourceAllocationClashing(NetPlan netPlan, boolean countFailedLightpaths, boolean checkRegeneratorsAsWavelengthConverters, NetworkLayer... optionalLayerParameter)` Checks resource clashing: no frequency slot in the same fiber can be occupied by more than one lightpath, nor any slot of an index higher than the fiber capacity can be occupied.
`static List<Pair<Integer,Integer>>`	`computeAvailableSpectrumVoids(TreeSet<Integer> slotOccupancy, int totalAvailableSlotsPerFiber)` Computes the list of spectral voids (list of available contiguous slots) from a slot availability vector (of a fiber or of a path).
`static int`	`computeMaximumRequests(List<Pair<Integer,Integer>> availableSpectrumVoids, int numSlots)` Computes the maximum number of requests (each one of the same given number of frequency slots) which can be simultaneously allocated in the given set of spectrum voids.
`static WDMUtils.ModulationFormat`	`computeModulationFormat(double pathLengthInKm, Set<WDMUtils.ModulationFormat> availableModulationFormats)` Returns the modulation format among the ones given, (i) with the maximum spectral efficiency, (ii) but with enough optical reach for the given path length.
`static WDMUtils.ModulationFormat`	`computeModulationFormat(List<Link> seqFibers, Set<WDMUtils.ModulationFormat> availableModulationFormats)` The same as `computeModulationFormat(lengthKm, availableModulationFormats)`, where `lengthKm` is the length in km of the input path.
`static Map<List<Link>,WDMUtils.ModulationFormat>`	`computeModulationFormatPerPath(Map<Pair<Node,Node>,List<List<Link>>> cpl, Set<WDMUtils.ModulationFormat> availableModulationFormats)` Returns the modulation format with the maximum spectral efficiency, while the optical reach constraint is fulfilled, for each path in the list of candidate paths (`cpl`)
`static int`	`computeNumberOfSlots(double bandwidthInGbps, double slotGranularityInGHz, double guardBandInGHz, WDMUtils.ModulationFormat modulationFormat)` Computes the number of frequency slots required for a lightpath that needs a given amount of Gbps, using a certain modulation (defining the Gbps/GHz spectral efficiency), and that requires a given minimum guard band in GHz (this guard band is assumed to be the sum of the two guard bands at upper and lower side of the band)
`static TreeSet<Integer>`	`computePathSlotOccupancy(List<Link> seqFibers, DoubleMatrix2D frequencySlot2FiberOccupancy_se)` Computes the slot availability vector of a path, represented by a sequence of fibers, where each position indicates whether or not its corresponding frequency slot is available along the path.
`static int[]`	`computeRegeneratorPositions(List<Link> seqFibers, double maxRegeneratorDistanceInKm)` Returns the list of nodes within the lightpath route containing a regenerator, only following a distance criterium, assuming no wavelength conversion is required.
`static int[]`	`computeRegeneratorPositions(List<Link> seqFibers, DoubleMatrix2D seqFrequencySlots, double maxRegeneratorDistanceInKm)` Returns the list of nodes within the lightpath route containing a regenerator, only following a distance criterium.
`static int`	`getFiberNumFrequencySlots(Link fiber)` Returns the number of frequency slots for the given fiber.
`static Pair<DoubleMatrix2D,DoubleMatrix1D>`	`getNetworkSlotAndRegeneratorOcupancy(NetPlan netPlan, boolean countFailedLightpaths, NetworkLayer... optionalLayerParameter)` Returns the fiber occupied (columns) in each wavelength (rows), and an array with the number of occupied regenerators in each node.
`static Pair<Map<Pair<Link,Integer>,List<Route>>,Map<Node,List<Route>>>`	`getNetworkSlotOccupancyMap(NetPlan netPlan, boolean countFailedLightpaths, NetworkLayer... optionalLayerParameter)` Returns two maps, showing the frequency slots in the links and signal regenerator in the nodes occupancies.
`static DoubleMatrix1D`	`getVectorFiberNumFrequencySlots(NetPlan netPlan, NetworkLayer... optionalLayerParameter)` Returns the total number of frequency slots in each fiber.
`static boolean`	`isAllocatableRSASet(DoubleMatrix2D frequencySlot2FiberOccupancy_se, WDMUtils.RSA... rsas)` Returns `true` if all the RSAs are allocatable (the needed frequency slots are free in the given sequence of links), `false` otherwise.
`static boolean`	`isWDMFormatCorrect(Link fiber)` Returns true if the `Link` object representing a fiber is well formed, according to the `WDMUtils` requirements.
`static boolean`	`isWDMFormatCorrect(NetPlan netPlan, NetworkLayer... optionalLayerParameter)` Performs some checks in a WDM network.
`static boolean`	`isWDMFormatCorrect(Route lp)` Returns true if the `Route` object is a well formed lightpath, according to the `WDMUtils` requirements.
`static void`	`releaseResources(WDMUtils.RSA rsa, DoubleMatrix2D frequencySlot2FiberOccupancy_se, DoubleMatrix1D nodeRegeneratorOccupancy)` Updates `frequencySlot2FiberOccupancy_se` to consider that a lightpath is releasing used frequency slots, and `nodeRegeneratorOccupancy` to consider that the lightpath releases the occupied regenerators
`static void`	`revertToInitialRSA(Route r)` The full RSA of the lightpath (travsersed fibers, occupied slots and regenerators) is reverted to its primary path.
`static void`	`setFiberNumFrequencySlots(Link fiber, int numFrequencySlots)` Sets the number of frequency slots available on the given fiber.
`static void`	`setFibersNumFrequencySlots(NetPlan netPlan, int numFrequencySlots, NetworkLayer... optionalLayerParameter)` Sets the number of frequency slots available in each fiber to the same value.
`static void`	`setLightpathRSAAttributes(Route lp, WDMUtils.RSA rsa, boolean initializeThePrimaryRoute)` Sets the attributes of the given `Route` object to reflect the RSA occupation in current, primary or a backup path.
`static int`	`spectrumAssignment_firstFit(List<Link> seqFibers, DoubleMatrix2D frequencySlot2FiberOccupancy_se, int numContiguousSlotsRequired)` Frequency slot assignment algorithm based on a first-fit fashion.
`static Pair<Integer,Integer>`	`spectrumAssignment_firstFitTwoRoutes(List<Link> seqFibers_1, List<Link> seqFibers_2, DoubleMatrix2D frequencySlot2FiberOccupancy_se, int numContiguousSlotsRequired)` Frequency slot assignment algorithm based on a first-fit fashion for two different paths.
`static Pair<int[],int[]>`	`wavelengthAssignment_RPP_firstFit(List<Link> seqFibers, DoubleMatrix2D frequencySlot2FiberOccupancy_se, DoubleMatrix1D nodeRegeneratorOccupancy, double maxRegeneratorDistanceInKm)` Wavelength assignment algorithm based on a first-fit fashion assuming full wavelength conversion and regeneration capabilities.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - addLightpath
```
public static Route addLightpath(Demand demand,
                                 WDMUtils.RSA rsa,
                                 double lineRateGbps)
```
    Creates a new lightpath with the given RSA, as a Route object. The attributes of the lightpath to store the WDM information are initialized appropriately
    
    Parameters:
    
    demand - The demand the lightpath belongs to
    
    rsa - the RSA
    
    lineRateGbps - the line rate of the lightpath in Gbps
    
    Returns:
    
    The newly created lightpath
  - allocateResources
```
public static void allocateResources(WDMUtils.RSA rsa,
                                     DoubleMatrix2D frequencySlot2FiberOccupancy_se,
                                     DoubleMatrix1D nodeRegeneratorOccupancy)
```
    Updates frequencySlot2FiberOccupancy_se and nodeRegeneratorOccupancy to consider that a new lightpath is occupying the resources given by rsa.
    
    Parameters:
    
    rsa - The rsa
    
    frequencySlot2FiberOccupancy_se - Current slot-fiber occupancy (updated inside the method)
    
    nodeRegeneratorOccupancy - Current number of regenerators occupied per node
  - checkResourceAllocationClashing
```
public static void checkResourceAllocationClashing(NetPlan netPlan,
                                                   boolean countFailedLightpaths,
                                                   boolean checkRegeneratorsAsWavelengthConverters,
                                                   NetworkLayer... optionalLayerParameter)
```
    Checks resource clashing: no frequency slot in the same fiber can be occupied by more than one lightpath, nor any slot of an index higher than the fiber capacity can be occupied. If a lightpath has as current route one of the backups, the clashing for this backup is not checked
    
    Parameters:
    
    netPlan - The object representing the network
    
    countFailedLightpaths - Include paths (current, primary or backup) that are down
    
    checkRegeneratorsAsWavelengthConverters - Whether or not to check that a lighpath occupies one regenerator in every node where the RSA checnges the frequency slots (that is, where a wavelength conversion occurs)
    
    optionalLayerParameter - WDM network layer. If not present, the default layer is assumed
  - computeAvailableSpectrumVoids
```
public static List<Pair<Integer,Integer>> computeAvailableSpectrumVoids(TreeSet<Integer> slotOccupancy,
                                                                        int totalAvailableSlotsPerFiber)
```
    Computes the list of spectral voids (list of available contiguous slots) from a slot availability vector (of a fiber or of a path).
    
    Parameters:
    
    slotOccupancy - Set of slots that are already occupied
    
    totalAvailableSlotsPerFiber - Number of slots per fiber
    
    Returns:
    
    List of spectrum voids, each one with a pair indicating both the initial slot id and the number of consecutive slots within the void. If no spectrum void is found, it returns an empty list
  - computeMaximumRequests
```
public static int computeMaximumRequests(List<Pair<Integer,Integer>> availableSpectrumVoids,
                                         int numSlots)
```
    Computes the maximum number of requests (each one of the same given number of frequency slots) which can be simultaneously allocated in the given set of spectrum voids.
    
    Parameters:
    
    availableSpectrumVoids - List of available spectrum voids (first item of each pair is the initial slot identifier, the second one is the number of consecutive slots)
    
    numSlots - Number of required slots of all the connections
    
    Returns:
    
    Maximum number of requests of the given number of slots which can be allocated in the given set of spectrum voids
  - computeModulationFormat
```
public static WDMUtils.ModulationFormat computeModulationFormat(double pathLengthInKm,
                                                                Set<WDMUtils.ModulationFormat> availableModulationFormats)
```
    Returns the modulation format among the ones given, (i) with the maximum spectral efficiency, (ii) but with enough optical reach for the given path length.
    
    Parameters:
    
    pathLengthInKm - Path length (in kilometers): the minimum reach of the returned modulation format
    
    availableModulationFormats - Set of candidate modulation formats
    
    Returns:
    
    Best modulation format for the given path length. An exception is raised if no moculation format is applicable
  - computeModulationFormat
```
public static WDMUtils.ModulationFormat computeModulationFormat(List<Link> seqFibers,
                                                                Set<WDMUtils.ModulationFormat> availableModulationFormats)
```
    The same as computeModulationFormat(lengthKm, availableModulationFormats), where lengthKm is the length in km of the input path.
    
    Parameters:
    
    seqFibers - Sequence of fibers of the path
    
    availableModulationFormats - Set of candidate modulation formats
    
    Returns:
    
    Best modulation format for the given path length. An exception is raised if no moculation format is applicable
  - computeModulationFormatPerPath
```
public static Map<List<Link>,WDMUtils.ModulationFormat> computeModulationFormatPerPath(Map<Pair<Node,Node>,List<List<Link>>> cpl,
                                                                                       Set<WDMUtils.ModulationFormat> availableModulationFormats)
```
    Returns the modulation format with the maximum spectral efficiency, while the optical reach constraint is fulfilled, for each path in the list of candidate paths (cpl)
    
    Parameters:
    
    cpl - The list of paths (the key of the map is the pair of end nodes, the value is the list of the paths between these nodes)
    
    availableModulationFormats - Set of candidate modulation formats
    
    Returns:
    
    Modulation format per path
  - computeNumberOfSlots
```
public static int computeNumberOfSlots(double bandwidthInGbps,
                                       double slotGranularityInGHz,
                                       double guardBandInGHz,
                                       WDMUtils.ModulationFormat modulationFormat)
```
    Computes the number of frequency slots required for a lightpath that needs a given amount of Gbps, using a certain modulation (defining the Gbps/GHz spectral efficiency), and that requires a given minimum guard band in GHz (this guard band is assumed to be the sum of the two guard bands at upper and lower side of the band)
    
    Parameters:
    
    bandwidthInGbps - Requested bandwidth (in Gbps)
    
    slotGranularityInGHz - Slot granularity (in GHz)
    
    guardBandInGHz - Guard-band size (in GHz) (summing the one with upper and lower wavelengths)
    
    modulationFormat - Modulation format
    
    Returns:
    
    Number of slots required to allocate the bandwidth demand
  - computePathSlotOccupancy
```
public static TreeSet<Integer> computePathSlotOccupancy(List<Link> seqFibers,
                                                        DoubleMatrix2D frequencySlot2FiberOccupancy_se)
```
    Computes the slot availability vector of a path, represented by a sequence of fibers, where each position indicates whether or not its corresponding frequency slot is available along the path.
    
    Important: Loop-free paths should be employed, but it is not checked by the method.
    
    Parameters:
    
    frequencySlot2FiberOccupancy_se - Indicates per each fiber its slot occupancy, where already-occupied slots appear
    
    seqFibers - (Loop-free) Sequence of traversed fibers (unchecked for conitinuity or cycles)
    
    Returns:
    
    Slot occupancy (vector with one coordinate per slot, 1 if occupied, 0 if not)
  - computeRegeneratorPositions
```
public static int[] computeRegeneratorPositions(List<Link> seqFibers,
                                                double maxRegeneratorDistanceInKm)
```
    Returns the list of nodes within the lightpath route containing a regenerator, only following a distance criterium, assuming no wavelength conversion is required.
    
    Parameters:
    
    seqFibers - Sequence of traversed fibers
    
    maxRegeneratorDistanceInKm - Maximum regeneration distance: after this distance from the initial node or from the last regenerator, the signal is considered not recuperable
    
    Returns:
    
    A vector with as many elements as traversed links in the route/segment. Each element is a 1 if an optical regenerator is used at the origin node of the corresponding link, and a 0 if not. First element is always 0.
  - computeRegeneratorPositions
```
public static int[] computeRegeneratorPositions(List<Link> seqFibers,
                                                DoubleMatrix2D seqFrequencySlots,
                                                double maxRegeneratorDistanceInKm)
```
    Returns the list of nodes within the lightpath route containing a regenerator, only following a distance criterium. If the frequency slots occupied changes in a link to the next, we assume that such wavelength conversion needs a regenerator, and thus one regenerator is placed in the intermediate node.
    
    Parameters:
    
    seqFibers - Sequence of traversed fibers
    
    seqFrequencySlots - Sequence of frequency slots occupied (one row per slot, one column per traversed fiber)
    
    maxRegeneratorDistanceInKm - Maximum regeneration distance: after this distance from the initial node or from the last regenerator, the signal is considered not recuperable
    
    Returns:
    
    A vector with as many elements as traversed links in the route/segment. Each element is a 1 if an optical regenerator is used at the origin node of the corresponding link, and a 0 if not. First element is always 0.
  - getFiberNumFrequencySlots
```
public static int getFiberNumFrequencySlots(Link fiber)
```
    Returns the number of frequency slots for the given fiber. It is equivalent to the method getCapacity() from the Link object, but converting capacity value from double to int.
    
    Parameters:
    
    fiber - Link fiber
    
    Returns:
    
    Number of frequency slots
  - getNetworkSlotAndRegeneratorOcupancy
```
public static Pair<DoubleMatrix2D,DoubleMatrix1D> getNetworkSlotAndRegeneratorOcupancy(NetPlan netPlan,
                                                                                       boolean countFailedLightpaths,
                                                                                       NetworkLayer... optionalLayerParameter)
```
    Returns the fiber occupied (columns) in each wavelength (rows), and an array with the number of occupied regenerators in each node. The lightpaths with occupied capacity equal to zero (as Route objects) are not counted. An exception is raised if a slot is allocated to more than one lightpath (except if a lightpath current path is equal to one of its backup paths), or a slot with an id higher than the link capacity is occupied
    
    Parameters:
    
    netPlan - Current design
    
    countFailedLightpaths - Include paths (current, primary or backup) that are down
    
    optionalLayerParameter - WDM network layer. If not present, the default layer is assumed
    
    Returns:
    
    Frequency slot - links occupation matrix, and per node regenerator occupation vector
  - getNetworkSlotOccupancyMap
```
public static Pair<Map<Pair<Link,Integer>,List<Route>>,Map<Node,List<Route>>> getNetworkSlotOccupancyMap(NetPlan netPlan,
                                                                                                         boolean countFailedLightpaths,
                                                                                                         NetworkLayer... optionalLayerParameter)
```
    Returns two maps, showing the frequency slots in the links and signal regenerator in the nodes occupancies. The slot occupancy is a map where the keys are the pairs (fiber,slot) occupied by at least one lightpath, and the value is a pair with the list of regular lightpaths (as Route) objects occupying the slot, and a list of the backup lightpaths (as a pair with route, and the index of the backup lightpath in the list of backup paths for the route) occupying the slot. If more than one lightpath occupies an slot an exception is NOT thrown. The second map is a map with one key for each Node with at least one signal regeneration placed in its RSA, and the value is the pair of two lists of lightpaths (regular and protection) with a regenerator in it. If a lightpath has more than one regenerator in a node, it appears as many times as the number of regenerators there.
    
    Parameters:
    
    netPlan - Current design
    
    countFailedLightpaths - if false, only those paths (current, primary, or backup) that are not down are accounted
    
    optionalLayerParameter - WDM network layer. If not present, the default layer is assumed
    
    Returns:
    
    Link - frequency slot occupation map
  - getVectorFiberNumFrequencySlots
```
public static DoubleMatrix1D getVectorFiberNumFrequencySlots(NetPlan netPlan,
                                                             NetworkLayer... optionalLayerParameter)
```
    Returns the total number of frequency slots in each fiber.
    
    Parameters:
    
    netPlan - A NetPlan representing a WDM physical topology
    
    optionalLayerParameter - WDM network layer. If not present, the default layer is assumed
    
    Returns:
    
    Number of wavelengths per fiber
  - isAllocatableRSASet
```
public static boolean isAllocatableRSASet(DoubleMatrix2D frequencySlot2FiberOccupancy_se,
                                          WDMUtils.RSA... rsas)
```
    Returns true if all the RSAs are allocatable (the needed frequency slots are free in the given sequence of links), false otherwise.
    
    Parameters:
    
    frequencySlot2FiberOccupancy_se - Current slot-fiber occupancy
    
    rsas - one or more RSAs to check. We start allocating them in order (never releasing the resources of the previous ones). Then, true is returned if it is possible to allocate all of them simultaneously. In other words, if two RSAs in rsas require the same frequency slot in the same link, they are not allocatable.
    
    Returns:
    
    See description above
  - isWDMFormatCorrect
```
public static boolean isWDMFormatCorrect(Link fiber)
```
    Returns true if the Link object representing a fiber is well formed, according to the WDMUtils requirements. This means that the link capacity is an integer (which reflect the maximum number of slots occupied)
    
    Parameters:
    
    fiber - Checks if the given link is a fiber.
    
    Returns:
    
    True if it is. False if it is not.
  - isWDMFormatCorrect
```
public static boolean isWDMFormatCorrect(NetPlan netPlan,
                                         NetworkLayer... optionalLayerParameter)
```
    Performs some checks in a WDM network. Checks that all the route and protection segment objects of the WDM layer have valid values in the attributes storing its RSA and regenerator occupancy, and the links (fiber) have also a non-negative integer capacity.
    
    Parameters:
    
    netPlan - The object representing the network
    
    optionalLayerParameter - WDM network layer. If not present, the default layer is assumed
    
    Returns:
    
    true if the format is correct, false otherwise
  - isWDMFormatCorrect
```
public static boolean isWDMFormatCorrect(Route lp)
```
    Returns true if the Route object is a well formed lightpath, according to the WDMUtils requirements. This means that the attributes stating the assigned frequency slots, occupied signal regenerators are correct, and lp occupied link capacity (curent and in no failure state) are non negative integers. This mehotd does NOT check any frequency slot clashing (two lightpaths occupying the same slot in the same fiber).
    
    Parameters:
    
    lp - the lightpath
    
    Returns:
    
    true if the lightpath attributes are well formed, false otherwise
  - releaseResources
```
public static void releaseResources(WDMUtils.RSA rsa,
                                    DoubleMatrix2D frequencySlot2FiberOccupancy_se,
                                    DoubleMatrix1D nodeRegeneratorOccupancy)
```
    Updates frequencySlot2FiberOccupancy_se to consider that a lightpath is releasing used frequency slots, and nodeRegeneratorOccupancy to consider that the lightpath releases the occupied regenerators
    
    Parameters:
    
    rsa - The RSA to release
    
    frequencySlot2FiberOccupancy_se - Current slot-fiber occupancy (updated inside the method)
    
    nodeRegeneratorOccupancy - Current node regenerator occupancy (updated inside the method). If null regenerator information is not updated
  - revertToInitialRSA
```
public static void revertToInitialRSA(Route r)
```
    The full RSA of the lightpath (travsersed fibers, occupied slots and regenerators) is reverted to its primary path. This means that the current sequence of fibers is changed, and the attributes storing the information of the current RSA are updated with the information of the initial RSA (also already stored in attributes of the route by previous WDMUtils methods)
    
    Parameters:
    
    r - The route of the lightpath to revert
  - setFiberNumFrequencySlots
```
public static void setFiberNumFrequencySlots(Link fiber,
                                             int numFrequencySlots)
```
    Sets the number of frequency slots available on the given fiber.
    
    Parameters:
    
    fiber - Link fiber
    
    numFrequencySlots - Number of of frequency slots for the given fiber
  - setFibersNumFrequencySlots
```
public static void setFibersNumFrequencySlots(NetPlan netPlan,
                                              int numFrequencySlots,
                                              NetworkLayer... optionalLayerParameter)
```
    Sets the number of frequency slots available in each fiber to the same value.
    
    Parameters:
    
    netPlan - A NetPlan representing a WDM physical topology
    
    numFrequencySlots - Number of wavelengths for all fibers
    
    optionalLayerParameter - WDM network layer. If not present, the default layer is assumed
  - setLightpathRSAAttributes
```
public static void setLightpathRSAAttributes(Route lp,
                                             WDMUtils.RSA rsa,
                                             boolean initializeThePrimaryRoute)
```
    Sets the attributes of the given Route object to reflect the RSA occupation in current, primary or a backup path.
    
    Parameters:
    
    lp - the route object
    
    rsa - the RSA information
    
    initializeThePrimaryRoute - If true, we assume that the RSA corresponds to the primary path information in the Route object.
  - spectrumAssignment_firstFit
```
public static int spectrumAssignment_firstFit(List<Link> seqFibers,
                                              DoubleMatrix2D frequencySlot2FiberOccupancy_se,
                                              int numContiguousSlotsRequired)
```
    Frequency slot assignment algorithm based on a first-fit fashion. It tries to find a set of contiguous slots that are available in all the traversed links, and gets the one which starts in the lowest slot id (the initial slot id of the block is returned)
    Important: frequencySlot2FiberOccupancy_se is not updated by this method
    
    Parameters:
    
    seqFibers - Sequence of traversed fibers
    
    frequencySlot2FiberOccupancy_se - Current slot-fiber occupancy
    
    numContiguousSlotsRequired - Number of slots of the block (in fixed-grid WDM, this is 1)
    
    Returns:
    
    The id of the initial slot of the contiguous block, or -1 if there is no such block of contigous slots with free resources in all the links
  - spectrumAssignment_firstFitTwoRoutes
```
public static Pair<Integer,Integer> spectrumAssignment_firstFitTwoRoutes(List<Link> seqFibers_1,
                                                                         List<Link> seqFibers_2,
                                                                         DoubleMatrix2D frequencySlot2FiberOccupancy_se,
                                                                         int numContiguousSlotsRequired)
```
    Frequency slot assignment algorithm based on a first-fit fashion for two different paths. It tries to find the lowest (s1,s2) pair, so that a contiguous block of the needed slots, starting in s1, are free in the first path, and starting in s2 are free in the second path (assuming the occupied slots in the first path are not available now). Among all the feasible (s1,s2) pairs, the returned is the one with lowest s1, and if more than one, with the lowest s2. If no (s1,s2) pair exists with the required idle frequency slots, the method returns null
    
    Important: frequencySlot2FiberOccupancy_se is not updated by this method
    
    Parameters:
    
    seqFibers_1 - First sequence of traversed fibers
    
    seqFibers_2 - Second sequence of traversed fibers
    
    frequencySlot2FiberOccupancy_se - Current slot-fiber occupancy
    
    numContiguousSlotsRequired - Number of slots of the block (in fixed-grid WDM, this is 1)
    
    Returns:
    
    Pair of sequences of wavelengths traversed by each lightpath
  - wavelengthAssignment_RPP_firstFit
```
public static Pair<int[],int[]> wavelengthAssignment_RPP_firstFit(List<Link> seqFibers,
                                                                  DoubleMatrix2D frequencySlot2FiberOccupancy_se,
                                                                  DoubleMatrix1D nodeRegeneratorOccupancy,
                                                                  double maxRegeneratorDistanceInKm)
```
    Wavelength assignment algorithm based on a first-fit fashion assuming full wavelength conversion and regeneration capabilities. This algorithm is targeted for fixed-frid WDM networks, where all lightpaths occupy just one frequency slot (we call it, the lightpath wavelength). In the algorithm, each node selects the first free block for its output fiber, and next nodes in the lightpath try to maintain it. If not possible, or regeneration is needed, then include a regenerator (can act also as a full wavelength converter) and search for the first free wavelength, and so on.
    
    In case a lightpath cannot be allocated, the corresponding sequence of wavelengths (seqWavelengths parameter) will be an empty array.
    
    Parameters:
    
    seqFibers - Sequence of traversed fibers
    
    frequencySlot2FiberOccupancy_se - Current slot-fiber occupancy
    
    nodeRegeneratorOccupancy - Number of regenerators installed per node
    
    maxRegeneratorDistanceInKm - Maximum regeneration distance
    
    Returns:
    
    Sequence of wavelengths traversed by each lightpath, and a 0-1 array indicating whether (1) or not (0) a regenerator/wavelength converter is required at the origin node of the corresponding fiber

Class WDMUtils

Wavelength-routed networks

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

addLightpath

allocateResources

checkResourceAllocationClashing

computeAvailableSpectrumVoids

computeMaximumRequests

computeModulationFormat

computeModulationFormat

computeModulationFormatPerPath

computeNumberOfSlots

computePathSlotOccupancy

computeRegeneratorPositions

computeRegeneratorPositions

getFiberNumFrequencySlots

getNetworkSlotAndRegeneratorOcupancy

getNetworkSlotOccupancyMap

getVectorFiberNumFrequencySlots

isAllocatableRSASet

isWDMFormatCorrect

isWDMFormatCorrect

isWDMFormatCorrect

releaseResources

revertToInitialRSA

setFiberNumFrequencySlots

setFibersNumFrequencySlots

setLightpathRSAAttributes

spectrumAssignment_firstFit

spectrumAssignment_firstFitTwoRoutes

wavelengthAssignment_RPP_firstFit