VoltageLevel

All Superinterfaces:: Container<VoltageLevel>, Extendable<VoltageLevel>, Identifiable<VoltageLevel>

public interface VoltageLevel
extends Container<VoltageLevel>

A voltage level is a collection of equipments located in the same substation and at the same base voltage.

A voltage level contains a topology model, i.e. an object that describes how equipments are connected together.

Topology model:

A voltage level may have two kinds of topology model depending on what level of detail we want to have (getTopologyKind()):

node/breaker model: this is the most detailed way to describe a topology. All elements are physical ones: busbar sections, breakers and disconnectors. A node in a node/breaker context means "connection node" and not topological node or bus.
bus/breaker model: this is an aggregated form of the topology made of buses and breakers. A bus is the aggregation of busbar sections and closed switches.

Topology view:

A topology model can be managed through the 3 following views ordered from the most detailed to the less detailed:

node/breaker view
bus/breaker view
bus only view

Depending on the topology model kind of the voltage level a view can have the status:

N/A, it doesn't make sense to take view that is more detailed than the model. An exception is thrown when a method is called on an N/A view
modifiable, when the view has the same level of detail than the model
readable only, because the view is a result of a computation on the topology model

The view status is summarized in the following table:

		Topology model
		node/breaker	bus/breaker
Topology view	node/breaker	modifiable	N/A
	bus/breaker	readable	modifiable
	bus	readable	readable

Creating a substation with a node/breaker topology model:

The substation of the example has two voltage levels VL1 and VL2 described by a node/breaker topology model. The first voltage level VL1 has 2 busbar sections BBS1 and BBS2 , a generator GN, a load LD and a coupler BR3 between busbar section BBS1 and BBS2. The second voltage level VL2 has a single busbar section BBS3 a line LN and is connected to voltage level VL1 through transformer TR.

Here is a diagram of the substation:

The node/breaker topology model is stored inside the voltage level as a graph where connection nodes are the vertices and switches are the edges.

The next diagram shows how to map the subtation topology to a graph.

Each voltage level has its own topology graph. Voltage level VL1 has 8 connection nodes. Generator GN is connected to node 1, load LD to node 5, busbar sections BBS1 and BBS2 to node 3 and 4. 2, 6 and 7 are internal connection nodes. Voltage level VL2 has 3 nodes, line LN is connected to node 1, busbar section BBS3 to node 2. Transformer TR is connected to node 8 of voltage level 400Kv and node 3 of voltage level 225Kv. Plain edges represent closed switches. Dashed edges reprensent opened switches. Green edges will disappear during the bus/breaker topology computation whereas pink edges (like in this case 3<->4) will be retained whatever their position are (see Switch.isRetained()).

The following code shows how to create the substation with a node/breaker topology model.

    Network n = ...
    Substation s = ...
    VoltageLevel vl1 = s.newVoltageLevel()
        .setId("VL1")
        .setTopologyKind(TopologyKind.NODE_BREAKER)
        .add();
    vl1.getNodeBreakerView().setNodeCount(8);
    // create busbar sections BBS1 and BBS2
    vl1.getNodeBreakerView().newBusbarSection()
        .setId("BBS1")
        .add();
    vl1.getNodeBreakerView().newBusbarSection()
        .setId("BBS2")
        .add();
    // create generator GN
    vl1.newGenerator()
        .setId("GN")
        .setNode(1)
        ...
        .add();
    // create load LD
    vl1.newLoad()
        .setId("LD")
        .setNode(5)
        ...
        .add();
    // connect generator GN by creating breaker BR1 and disconnectors DI1 and DI2
    vl1.getNodeBreakerView().newBreaker()
        .setId("BR1")
        .setOpen(false)
        .setNode1(1)
        .setNode1(2)
        .add();
    vl1.getNodeBreakerView().newDisconnector()
        .setId("DI1")
        .setOpen(false)
        .setNode1(2)
        .setNode1(3)
        .add();
    vl1.getNodeBreakerView().newDisconnector()
        .setId("DI2")
        .setOpen(true)
        .setNode1(2)
        .setNode1(4)
        .add();
    // connect load LD
    ...
    // create busbar coupler BR3
    vl1.getNodeBreakerView().newBreaker()
        .setId("BR3")
        .setOpen(false)
        .setRetained(true) // retain this breaker in the bus/breaker topology!!!
        .setNode1(3)
        .setNode2(4)
        .add();

    VoltageLevel vl2 = s.newVoltageLevel()
        .setId("VL2")
        .setTopologyKind(TopologyKind.NODE_BREAKER)
        .add();
    vl2.getNodeBreakerView().setNodeCount(3);
    // create busbar section BBS3
    vl2.getNodeBreakerView().newBusbarSection()
        .setId("BBS3")
        .add();
    // create line LN
    n.newLine()
        .setId("LN")
        .setVoltageLevel1("VL2")
        .setNode1(1)
        .setVoltageLevel2(...)
        .setNode2(...)
        ...
        .add();

    // create transformer TR
    s.newTwoWindingsTransformer()
        .setId("TR")
        .setVoltageLevel1("VL1")
        .setNode1(8)
        .setVoltageLevel2("VL2")
        .setNode2(3)
        ...
        .add();

The following diagram shows computed bus/breaker topology. Compared to node/breaker topology, only remains equipements (GN, LD, TR, LN), and switches flagged as retained (BR3). Equipments are now connected through buses (B1 and B2).

To get a bus/breaker view on the substation voltage level VL1 use getBusBreakerView(). The following code shows how to get buses and breakers of the bus/breaker view in voltage level VL1.

    // VL1 contains 2 buses in the bus/breaker view
    Iterator<Bus> itB = vl1.getBusBreakerView().getBuses().iterator();

    // first bus connects nodes 1, 2, 3, 5, 6
    Bus b1 = itB.next();
    // ... and consequently generator GN and load LD
    Generator gn = b1.getGenerators().iterator().next();
    Load ld = b1.getLoads().iterator().next();

    // bus/breaker view can also be accessed from an equipment
    Bus alsoB1 = gn.getTerminal().getBusBreakerView.getBus();

    // second bus connects nodes 4, 7, 8
    Bus b2 = itB.next();
    TwoWindingsTransformer tr = b2.getTwoWindingsTransformer().iterator().next();

    // VL1 contains 1 switch in the bus/breaker view
    Iterator<Switch> itS = vl1.getBusBreakerView().getSwitches().iterator();
    Switch br3 = itS.next();

The following diagram shows computed bus topology. Compared to bus/breaker topology, there is no switches anymore. Only remains equipements (GN, LD, TR, LN) connected through buses.

To get a bus view one the substation voltage level VL1 use getBusView(). The following code shows how to get buses of the bus view in voltage level VL1.

    // VL1 contains 1 buses in the bus view
    Iterator<Bus> itB = vl1.getBusView().getBuses();

    // the bus connects all the equipements of voltage level VL1
    Bus b1 = itB.next();

Creating a substation with a bus/breaker topology model:

Instead of creating VL1 and VL3 with a node/breaker topology model, we can directly create them in a simpler bus/breaker topology model. It can be very useful when data source only contains bus/branch data link in DEF or CIM format.

The following code shows how to create the substation with a bus/breaker topology model.

    VoltageLevel vl1 = s.newVoltageLevel()
        .setId("VL1")
        .setTopologyKind(TopologyKind.BUS_BREAKER)
        .add();
    // create busbar sections BBS1 and BBS2
    vl1.getBusBreakerView().newBus()
        .setId("B1")
        .add();
    vl1.getBusBreakerView().newBus()
        .setId("B2")
        .add();
    // create generator GN
    vl1.newGenerator()
        .setId("GN")
        .setBus("B1")
        ...
        .add();
    // create load LD
    vl1.newLoad()
        .setId("LD")
        .setBus("B1")
        ...
        .add();
     // create busbar coupler BR3
     vl1.getBusBreakerView().newBreaker()
        .setId("BR3")
        .setOpen(false)
        .setBus1("B1")
        .setBus2("B2")
        .add();

    VoltageLevel vl2 = s.newVoltageLevel()
        .setId("VL2")
        .setTopologyKind(TopologyKind.BUS_BREAKER)
        .add();
    vl2.getBusBreakerView().newBus()
        .setId("B3")
        .add();
    // create line LN
    n.newLine()
        .setId("LN")
        .setVoltageLevel1("VL2");
        .setBus1("B3")
        .setVoltageLevel2(...);
        .setBus2(...)
        ...
        .add();

    // create transformer TR
    s.newTwoWindingsTransformer()
        .setId("TR")
        .setVoltageLevel1("VL1");
        .setBus1("B2")
        .setVoltageLevel2("VL2");
        .setBus2("B3")
        ...
        .add();

Warning: in that case the node/breaker view status on voltage level VL1 and VL2 is N/A.

To create a voltage level, see VoltageLevelAdder

See Also:: VoltageLevelAdder

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`VoltageLevel.BusBreakerView` A bus/breaker view of the topology.
`static interface`	`VoltageLevel.BusView` A bus view of the substation topology.
`static interface`	`VoltageLevel.NodeBreakerView` A node/breaker view of the topology.
`static interface`	`VoltageLevel.TopologyTraverser` Topology traversal handler

Method Summary

All Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`exportTopology(java.io.OutputStream outputStream)` Export the topology in DOT format (Graphviz).
`void`	`exportTopology(java.lang.String filename)` Export in a file the topology in DOT format (Graphviz).
`VoltageLevel.BusBreakerView`	`getBusBreakerView()` Get a bus/breaker view of the topology.
`VoltageLevel.BusView`	`getBusView()` Get a bus view of the topology.
`<T extends Connectable> T`	`getConnectable(java.lang.String id, java.lang.Class<T> aClass)` Get an equipment connected to this substation voltage level.
`int`	`getConnectableCount()` Count the equipments connected to this substation voltage level.
`<T extends Connectable> int`	`getConnectableCount(java.lang.Class<T> clazz)` Count the equipments connected to this substation voltage level for a given type.
`java.lang.Iterable<Connectable>`	`getConnectables()` Get an Iterable on all the equipments connected to this substation voltage level.
`<T extends Connectable> java.lang.Iterable<T>`	`getConnectables(java.lang.Class<T> clazz)` Get an Iterable on all the equipments connected to this substation voltage level for a given type.
`java.util.stream.Stream<Connectable>`	`getConnectableStream()` Get a Stream on all the equipments connected to this substation voltage level.
`<T extends Connectable> java.util.stream.Stream<T>`	`getConnectableStream(java.lang.Class<T> clazz)` Get a Stream on all the equipments connected to this substation voltage level for a given type.
`int`	`getDanglingLineCount()` Get dangling line count.
`java.lang.Iterable<DanglingLine>`	`getDanglingLines()` Get dangling lines.
`java.util.stream.Stream<DanglingLine>`	`getDanglingLineStream()` Get dangling lines.
`int`	`getGeneratorCount()` Get generator count.
`java.lang.Iterable<Generator>`	`getGenerators()` Get generators.
`java.util.stream.Stream<Generator>`	`getGeneratorStream()` Get generators.
`double`	`getHighVoltageLimit()` Get the high voltage limit in KV.
`int`	`getLccConverterStationCount()` Get LCC converter stations count connected to this voltage level.
`java.lang.Iterable<LccConverterStation>`	`getLccConverterStations()` Get all LCC converter stations connected to this voltage level.
`java.util.stream.Stream<LccConverterStation>`	`getLccConverterStationStream()` Get all LCC converter stations connected to this voltage level.
`int`	`getLoadCount()` Get load count.
`java.lang.Iterable<Load>`	`getLoads()` Get loads.
`java.util.stream.Stream<Load>`	`getLoadStream()` Get loads.
`double`	`getLowVoltageLimit()` Get the low voltage limit in KV.
`VoltageLevel.NodeBreakerView`	`getNodeBreakerView()` Get a node/breaker view of the topology.
`double`	`getNominalV()` Get the nominal voltage in KV.
`default int`	`getShuntCompensatorCount()` Get shunt count.
`default java.lang.Iterable<ShuntCompensator>`	`getShuntCompensators()` Get compensator shunts.
`default java.util.stream.Stream<ShuntCompensator>`	`getShuntCompensatorStream()` Get compensator shunts.
`default int`	`getShuntCount()` Deprecated. Use `getShuntCompensatorCount()` instead.
`default java.lang.Iterable<ShuntCompensator>`	`getShunts()` Deprecated. Use `getShuntCompensators()` instead.
`default java.util.stream.Stream<ShuntCompensator>`	`getShuntStream()` Deprecated. Use `getShuntCompensatorStream()` instead.
`int`	`getStaticVarCompensatorCount()` Get static var compensator count.
`java.lang.Iterable<StaticVarCompensator>`	`getStaticVarCompensators()` Get static var compensators.
`java.util.stream.Stream<StaticVarCompensator>`	`getStaticVarCompensatorStream()` Get static var compensators.
`Substation`	`getSubstation()` Get the substation to which the voltage level belongs.
`int`	`getSwitchCount()` Get switch count.
`java.lang.Iterable<Switch>`	`getSwitches()` Get switches.
`TopologyKind`	`getTopologyKind()` Get the kind of topology.
`int`	`getVscConverterStationCount()` Get VSC converter stations count connected to this voltage level.
`java.lang.Iterable<VscConverterStation>`	`getVscConverterStations()` Get all VSC converter stations connected to this voltage level.
`java.util.stream.Stream<VscConverterStation>`	`getVscConverterStationStream()` Get all VSC converter stations connected to this voltage level.
`DanglingLineAdder`	`newDanglingLine()` Get a builder to create a new dangling line.
`GeneratorAdder`	`newGenerator()` Get a builder to create a new generator.
`LccConverterStationAdder`	`newLccConverterStation()` Get a builder to create a new LCC converter station connected to this voltage level.
`LoadAdder`	`newLoad()` Get a builder to create a new load.
`default ShuntCompensatorAdder`	`newShunt()` Deprecated. Use `newShuntCompensator()` instead.
`default ShuntCompensatorAdder`	`newShuntCompensator()` Get a builder to create a new compensator shunt.
`StaticVarCompensatorAdder`	`newStaticVarCompensator()` Get a builder to create a new static var compensator.
`VscConverterStationAdder`	`newVscConverterStation()` Get a builder to create a new VSC converter station connected to this voltage level.
`void`	`printTopology()` Print an ASCII representation of the topology on the standard ouput.
`void`	`printTopology(java.io.PrintStream out, ShortIdDictionary dict)` Print an ASCII representation of the topology on a stream.
`VoltageLevel`	`setHighVoltageLimit(double highVoltageLimit)` Set the high voltage limit in KV.
`VoltageLevel`	`setLowVoltageLimit(double lowVoltageLimit)` Set the low voltage limit in KV.
`VoltageLevel`	`setNominalV(double nominalV)`
`void`	`visitEquipments(TopologyVisitor visitor)` Visit equipments of the voltage level.

Methods inherited from interface com.powsybl.iidm.network.Container
getContainerType

Methods inherited from interface com.powsybl.iidm.network.Identifiable
getId, getName, getProperties, hasProperty

Methods inherited from interface com.powsybl.commons.extensions.Extendable
addExtension, getExtension, getExtensionByName, getExtensions, removeExtension

- Method Detail
  - getSubstation
```
Substation getSubstation()
```
    Get the substation to which the voltage level belongs.
  - getNominalV
```
double getNominalV()
```
    Get the nominal voltage in KV.
  - setNominalV
```
VoltageLevel setNominalV(double nominalV)
```
  - getLowVoltageLimit
```
double getLowVoltageLimit()
```
    Get the low voltage limit in KV.
    
    Returns:
    
    the low voltage limit or NaN if undefined
  - setLowVoltageLimit
```
VoltageLevel setLowVoltageLimit(double lowVoltageLimit)
```
    Set the low voltage limit in KV.
    
    Parameters:
    
    lowVoltageLimit - the low voltage limit in KV
  - getHighVoltageLimit
```
double getHighVoltageLimit()
```
    Get the high voltage limit in KV.
    
    Returns:
    
    the high voltage limit or NaN if undefined
  - setHighVoltageLimit
```
VoltageLevel setHighVoltageLimit(double highVoltageLimit)
```
    Set the high voltage limit in KV.
    
    Parameters:
    
    highVoltageLimit - the high voltage limit in KV
  - getConnectable
```
<T extends Connectable> T getConnectable(java.lang.String id,
                                         java.lang.Class<T> aClass)
```
    Get an equipment connected to this substation voltage level.
    
    Parameters:
    
    id - the equipment id
    
    aClass -
    
    Returns:
    
    the equipment
  - getConnectables
```
<T extends Connectable> java.lang.Iterable<T> getConnectables(java.lang.Class<T> clazz)
```
    Get an Iterable on all the equipments connected to this substation voltage level for a given type.
    
    Parameters:
    
    clazz - equipments type
    
    Returns:
    
    all the equipments of the given type
  - getConnectableStream
```
<T extends Connectable> java.util.stream.Stream<T> getConnectableStream(java.lang.Class<T> clazz)
```
    Get a Stream on all the equipments connected to this substation voltage level for a given type.
    
    Parameters:
    
    clazz - equipments type
    
    Returns:
    
    all the equipments of the given type
  - getConnectableCount
```
<T extends Connectable> int getConnectableCount(java.lang.Class<T> clazz)
```
    Count the equipments connected to this substation voltage level for a given type.
    
    Parameters:
    
    clazz - equipments type
    
    Returns:
    
    all the equipment of the given type
  - getConnectables
```
java.lang.Iterable<Connectable> getConnectables()
```
    Get an Iterable on all the equipments connected to this substation voltage level.
    
    Returns:
    
    all the equipments
  - getConnectableStream
```
java.util.stream.Stream<Connectable> getConnectableStream()
```
    Get a Stream on all the equipments connected to this substation voltage level.
    
    Returns:
    
    all the equipments
  - getConnectableCount
```
int getConnectableCount()
```
    Count the equipments connected to this substation voltage level.
    
    Returns:
    
    all the equipments
  - newGenerator
```
GeneratorAdder newGenerator()
```
    Get a builder to create a new generator.
  - getGenerators
```
java.lang.Iterable<Generator> getGenerators()
```
    Get generators.
  - getGeneratorStream
```
java.util.stream.Stream<Generator> getGeneratorStream()
```
    Get generators.
  - getGeneratorCount
```
int getGeneratorCount()
```
    Get generator count.
  - newLoad
```
LoadAdder newLoad()
```
    Get a builder to create a new load.
  - getLoads
```
java.lang.Iterable<Load> getLoads()
```
    Get loads.
  - getLoadStream
```
java.util.stream.Stream<Load> getLoadStream()
```
    Get loads.
  - getSwitches
```
java.lang.Iterable<Switch> getSwitches()
```
    Get switches.
  - getSwitchCount
```
int getSwitchCount()
```
    Get switch count.
  - getLoadCount
```
int getLoadCount()
```
    Get load count.
  - newShunt
```
@Deprecated
default ShuntCompensatorAdder newShunt()
```
    Deprecated. Use newShuntCompensator() instead.
  - getShunts
```
@Deprecated
default java.lang.Iterable<ShuntCompensator> getShunts()
```
    Deprecated. Use getShuntCompensators() instead.
  - getShuntStream
```
@Deprecated
default java.util.stream.Stream<ShuntCompensator> getShuntStream()
```
    Deprecated. Use getShuntCompensatorStream() instead.
  - getShuntCount
```
@Deprecated
default int getShuntCount()
```
    Deprecated. Use getShuntCompensatorCount() instead.
  - newShuntCompensator
```
default ShuntCompensatorAdder newShuntCompensator()
```
    Get a builder to create a new compensator shunt.
  - getShuntCompensators
```
default java.lang.Iterable<ShuntCompensator> getShuntCompensators()
```
    Get compensator shunts.
  - getShuntCompensatorStream
```
default java.util.stream.Stream<ShuntCompensator> getShuntCompensatorStream()
```
    Get compensator shunts.
  - getShuntCompensatorCount
```
default int getShuntCompensatorCount()
```
    Get shunt count.
  - newDanglingLine
```
DanglingLineAdder newDanglingLine()
```
    Get a builder to create a new dangling line.
  - getDanglingLines
```
java.lang.Iterable<DanglingLine> getDanglingLines()
```
    Get dangling lines.
  - getDanglingLineStream
```
java.util.stream.Stream<DanglingLine> getDanglingLineStream()
```
    Get dangling lines.
  - getDanglingLineCount
```
int getDanglingLineCount()
```
    Get dangling line count.
  - newStaticVarCompensator
```
StaticVarCompensatorAdder newStaticVarCompensator()
```
    Get a builder to create a new static var compensator.
  - getStaticVarCompensators
```
java.lang.Iterable<StaticVarCompensator> getStaticVarCompensators()
```
    Get static var compensators.
  - getStaticVarCompensatorStream
```
java.util.stream.Stream<StaticVarCompensator> getStaticVarCompensatorStream()
```
    Get static var compensators.
  - getStaticVarCompensatorCount
```
int getStaticVarCompensatorCount()
```
    Get static var compensator count.
  - newVscConverterStation
```
VscConverterStationAdder newVscConverterStation()
```
    Get a builder to create a new VSC converter station connected to this voltage level.
    
    Returns:
    
    a builder to create a new VSC converter
  - getVscConverterStations
```
java.lang.Iterable<VscConverterStation> getVscConverterStations()
```
    Get all VSC converter stations connected to this voltage level.
    
    Returns:
    
    all VSC converter stations connected to this voltage level
  - getVscConverterStationStream
```
java.util.stream.Stream<VscConverterStation> getVscConverterStationStream()
```
    Get all VSC converter stations connected to this voltage level.
    
    Returns:
    
    all VSC converter stations connected to this voltage level
  - getVscConverterStationCount
```
int getVscConverterStationCount()
```
    Get VSC converter stations count connected to this voltage level.
    
    Returns:
    
    VSC converter stations count connected to this voltage level
  - newLccConverterStation
```
LccConverterStationAdder newLccConverterStation()
```
    Get a builder to create a new LCC converter station connected to this voltage level.
    
    Returns:
    
    a builder to create a new LCC converter
  - getLccConverterStations
```
java.lang.Iterable<LccConverterStation> getLccConverterStations()
```
    Get all LCC converter stations connected to this voltage level.
    
    Returns:
    
    all LCC converter stations connected to this voltage level
  - getLccConverterStationStream
```
java.util.stream.Stream<LccConverterStation> getLccConverterStationStream()
```
    Get all LCC converter stations connected to this voltage level.
    
    Returns:
    
    all LCC converter stations connected to this voltage level
  - getLccConverterStationCount
```
int getLccConverterStationCount()
```
    Get LCC converter stations count connected to this voltage level.
    
    Returns:
    
    LCC converter stations count connected to this voltage level
  - visitEquipments
```
void visitEquipments(TopologyVisitor visitor)
```
    Visit equipments of the voltage level.
    
    Parameters:
    
    visitor -
  - getTopologyKind
```
TopologyKind getTopologyKind()
```
    Get the kind of topology.
  - getNodeBreakerView
```
VoltageLevel.NodeBreakerView getNodeBreakerView()
```
    Get a node/breaker view of the topology.
    
    Returns:
    
    a node/breaker view of the topology
  - getBusBreakerView
```
VoltageLevel.BusBreakerView getBusBreakerView()
```
    Get a bus/breaker view of the topology.
    
    Returns:
    
    a bus/breaker view of the topology
  - getBusView
```
VoltageLevel.BusView getBusView()
```
    Get a bus view of the topology.
    
    Returns:
    
    a bus view of the topology
  - printTopology
```
void printTopology()
```
    Print an ASCII representation of the topology on the standard ouput.
  - printTopology
```
void printTopology(java.io.PrintStream out,
                   ShortIdDictionary dict)
```
    Print an ASCII representation of the topology on a stream.
    
    Parameters:
    
    out - the stream
  - exportTopology
```
void exportTopology(java.lang.String filename)
             throws java.io.IOException
```
    Export in a file the topology in DOT format (Graphviz).
    
    Parameters:
    
    filename - the file name
    
    Throws:
    
    java.io.IOException
  - exportTopology
```
void exportTopology(java.io.OutputStream outputStream)
             throws java.io.IOException
```
    Export the topology in DOT format (Graphviz).
    
    Parameters:
    
    outputStream - a writer
    
    Throws:
    
    java.io.IOException

Interface VoltageLevel

Topology model:

Topology view:

Creating a substation with a node/breaker topology model:

Creating a substation with a bus/breaker topology model:

Nested Class Summary

Method Summary

Methods inherited from interface com.powsybl.iidm.network.Container

Methods inherited from interface com.powsybl.iidm.network.Identifiable

Methods inherited from interface com.powsybl.commons.extensions.Extendable

Method Detail

getSubstation

getNominalV

setNominalV

getLowVoltageLimit

setLowVoltageLimit

getHighVoltageLimit

setHighVoltageLimit

getConnectable

getConnectables

getConnectableStream

getConnectableCount

getConnectables

getConnectableStream

getConnectableCount

newGenerator

getGenerators

getGeneratorStream

getGeneratorCount

newLoad

getLoads

getLoadStream

getSwitches

getSwitchCount

getLoadCount

newShunt

getShunts

getShuntStream

getShuntCount

newShuntCompensator

getShuntCompensators

getShuntCompensatorStream

getShuntCompensatorCount

newDanglingLine

getDanglingLines

getDanglingLineStream

getDanglingLineCount

newStaticVarCompensator

getStaticVarCompensators

getStaticVarCompensatorStream

getStaticVarCompensatorCount

newVscConverterStation

getVscConverterStations

getVscConverterStationStream

getVscConverterStationCount

newLccConverterStation

getLccConverterStations

getLccConverterStationStream

getLccConverterStationCount

visitEquipments

getTopologyKind

getNodeBreakerView

getBusBreakerView

getBusView

printTopology

printTopology

exportTopology

exportTopology