Bump powsybl-single-line-diagram-core from 2.6.0 to 2.7.0

pom.xml

@@ -28,7 +28,7 @@ SPDX-License-Identifier: Apache-2.0
 
         <quarkus.platform.version>2.6.1.Final</quarkus.platform.version>
         <slf4j.version>1.7.32</slf4j.version>
-        <powsybl.sld.version>2.6.0</powsybl.sld.version>
+        <powsybl.sld.version>2.7.0</powsybl.sld.version>
         <gson.version>2.8.9</gson.version>
         <openpojo.version>0.9.1</openpojo.version>
     </properties>

service/src/main/java/org/lfenergy/compas/scl/auto/alignment/builder/AbstractGraphBuilder.java

@@ -0,0 +1,38 @@
+// SPDX-FileCopyrightText: 2021 Alliander N.V.
+//
+// SPDX-License-Identifier: Apache-2.0
+package org.lfenergy.compas.scl.auto.alignment.builder;
+
+import com.powsybl.sld.model.BaseGraph;
+import com.powsybl.sld.model.Node;
+
+import java.util.Map;
+
+public abstract class AbstractGraphBuilder<G extends BaseGraph> {
+    private G graph;
+    private final Map<String, Node> path2Node;
+
+    protected AbstractGraphBuilder(Map<String, Node> path2Node) {
+        this.path2Node = path2Node;
+    }
+
+    public G getGraph() {
+        return graph;
+    }
+
+    protected void setGraph(G graph) {
+        this.graph = graph;
+    }
+
+    protected void addNode(String path, Node node) {
+        path2Node.put(path, node);
+    }
+
+    protected Node getNodeByPath(String path) {
+        return path2Node.get(path);
+    }
+
+    protected Map<String, Node> getPath2Node() {
+        return path2Node;
+    }
+}

service/src/main/java/org/lfenergy/compas/scl/auto/alignment/builder/SubstationGraphBuilder.java

@@ -0,0 +1,98 @@
+// SPDX-FileCopyrightText: 2021 Alliander N.V.
+//
+// SPDX-License-Identifier: Apache-2.0
+package org.lfenergy.compas.scl.auto.alignment.builder;
+
+import com.powsybl.sld.model.*;
+import org.lfenergy.compas.scl.auto.alignment.exception.SclAutoAlignmentException;
+import org.lfenergy.compas.scl.auto.alignment.model.*;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.lfenergy.compas.scl.auto.alignment.exception.SclAutoAlignmentErrorCode.VOLTAGELEVEL_NOT_FOUND_ERROR_CODE;
+
+public class SubstationGraphBuilder extends AbstractGraphBuilder<SubstationGraph> {
+    private final GenericSubstation substation;
+
+    private final Map<String, VoltageLevelGraphBuilder> voltageLevelGraphBuilderMap = new HashMap<>();
+
+    public SubstationGraphBuilder(GenericSubstation substation) {
+        this(substation, new HashMap<>());
+    }
+
+    public SubstationGraphBuilder(GenericSubstation substation,
+                                  Map<String, Node> path2Node) {
+        super(path2Node);
+        this.substation = substation;
+
+        setGraph(SubstationGraph.create(substation.getFullName()));
+
+        createSubstation();
+    }
+
+    private void createSubstation() {
+        substation.getVoltageLevels().forEach(this::createVoltageLevelGraph);
+        substation.getPowerTransformers().forEach(this::createPowerTransformer);
+    }
+
+    private void createVoltageLevelGraph(GenericVoltageLevel voltageLevel) {
+        var voltageLevelBuilder = new VoltageLevelGraphBuilder(voltageLevel, substation, getPath2Node());
+        getGraph().addVoltageLevel(voltageLevelBuilder.getGraph());
+        voltageLevelGraphBuilderMap.put(voltageLevel.getFullName(), voltageLevelBuilder);
+    }
+
+    private VoltageLevelGraphBuilder getVoltageLevelBuilder(GenericTransformerWinding transformerWinding) {
+        var connectivityNode = transformerWinding.getTerminals().get(0).getConnectivityNode();
+        return substation.getVoltageLevels().stream()
+                .map(GenericVoltageLevel::getBays)
+                .flatMap(List::stream)
+                .map(GenericBay::getConductingEquipments)
+                .flatMap(List::stream)
+                .map(GenericConductingEquipment::getTerminals)
+                .flatMap(List::stream)
+                .filter(terminal -> connectivityNode.equals(terminal.getConnectivityNode()))
+                .findFirst()
+                .map(terminal -> ((GenericConductingEquipment) terminal.getParent()).getParent().getParent())
+                .map(genericVoltageLevel -> voltageLevelGraphBuilderMap.get(genericVoltageLevel.getFullName()))
+                .orElseThrow(() -> new SclAutoAlignmentException(VOLTAGELEVEL_NOT_FOUND_ERROR_CODE, "No voltage level found."));
+    }
+
+    private void createPowerTransformer(GenericPowerTransformer powerTransformer) {
+        if (powerTransformer.isFeeder2WT()) {
+            var tws = powerTransformer.getTransformerWindings();
+            getGraph().addMultiTermNode(
+                    Middle2WTNode.create(powerTransformer.getFullName(),
+                            powerTransformer.getFullName(),
+                            getGraph(),
+                            getFeeder2WTLegNode(tws.get(0)),
+                            getFeeder2WTLegNode(tws.get(1)),
+                            getVoltageLevelBuilder(tws.get(0)).getGraph().getVoltageLevelInfos(),
+                            getVoltageLevelBuilder(tws.get(1)).getGraph().getVoltageLevelInfos(),
+                            false));
+        } else if (powerTransformer.isFeeder3WT()) {
+            var tws = powerTransformer.getTransformerWindings();
+            getGraph().addMultiTermNode(
+                    Middle3WTNode.create(powerTransformer.getFullName(),
+                            powerTransformer.getFullName(),
+                            getGraph(),
+                            getFeeder3WTLegNode(tws.get(0)),
+                            getFeeder3WTLegNode(tws.get(1)),
+                            getFeeder3WTLegNode(tws.get(2)),
+                            getVoltageLevelBuilder(tws.get(0)).getGraph().getVoltageLevelInfos(),
+                            getVoltageLevelBuilder(tws.get(1)).getGraph().getVoltageLevelInfos(),
+                            getVoltageLevelBuilder(tws.get(2)).getGraph().getVoltageLevelInfos()));
+        }
+    }
+
+    private Feeder2WTLegNode getFeeder2WTLegNode(GenericTransformerWinding transformerWinding) {
+        var connectivityNode = transformerWinding.getTerminals().get(0).getConnectivityNode();
+        return (Feeder2WTLegNode) getNodeByPath(connectivityNode);
+    }
+
+    private Feeder3WTLegNode getFeeder3WTLegNode(GenericTransformerWinding transformerWinding) {
+        var connectivityNode = transformerWinding.getTerminals().get(0).getConnectivityNode();
+        return (Feeder3WTLegNode) getNodeByPath(connectivityNode);
+    }
+}

service/src/main/java/org/lfenergy/compas/scl/auto/alignment/builder/VoltageLevelGraphBuilder.java

@@ -0,0 +1,173 @@
+// SPDX-FileCopyrightText: 2021 Alliander N.V.
+//
+// SPDX-License-Identifier: Apache-2.0
+package org.lfenergy.compas.scl.auto.alignment.builder;
+
+import com.powsybl.sld.model.*;
+import org.lfenergy.compas.scl.auto.alignment.model.*;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class VoltageLevelGraphBuilder extends AbstractGraphBuilder<VoltageLevelGraph> {
+    private final GenericVoltageLevel voltageLevel;
+    private final GenericSubstation substation;
+
+    public VoltageLevelGraphBuilder(GenericVoltageLevel voltageLevel) {
+        this(voltageLevel, null, new HashMap<>(), true);
+    }
+
+    public VoltageLevelGraphBuilder(GenericVoltageLevel voltageLevel,
+                                    GenericSubstation substation,
+                                    Map<String, Node> path2Node) {
+        this(voltageLevel, substation, path2Node, false);
+    }
+
+    private VoltageLevelGraphBuilder(GenericVoltageLevel voltageLevel,
+                                     GenericSubstation substation,
+                                     Map<String, Node> path2Node,
+                                     boolean forVoltageLevelDiagram) {
+        super(path2Node);
+        this.voltageLevel = voltageLevel;
+        this.substation = substation;
+
+        var voltageLevelInfos = new VoltageLevelInfos(voltageLevel.getFullName(),
+                voltageLevel.getFullName(),
+                voltageLevel.getVoltage());
+        setGraph(VoltageLevelGraph.create(voltageLevelInfos, forVoltageLevelDiagram));
+
+        createVoltageLevel();
+    }
+
+    private void createVoltageLevel() {
+        // First process the Busbars.
+        var busbarIndex = new AtomicInteger(1);
+        voltageLevel.getBays().stream()
+                .filter(GenericBay::isBusbar)
+                .forEach(busbar -> processBusbarNode(busbar, busbarIndex));
+
+        // Next process the other bays.
+        voltageLevel.getBays().stream()
+                .filter(bay -> !bay.isBusbar())
+                .forEach(this::processBayNode);
+    }
+
+    private void processBusbarNode(GenericBay busbar,
+                                   AtomicInteger busbarIndex) {
+        busbar.getConnectivityNodes()
+                .forEach(connectivityNode ->
+                        addNode(connectivityNode.getPathName(),
+                                createBusbarNode(busbar.getFullName(), busbarIndex.getAndIncrement(), 1)));
+    }
+
+    public BusNode createBusbarNode(String id, int busbarIndex, int sectionIndex) {
+        BusNode busNode = BusNode.create(getGraph(), id, id);
+        getGraph().addNode(busNode);
+        busNode.setBusBarIndexSectionIndex(busbarIndex, sectionIndex);
+        return busNode;
+    }
+
+    private void processBayNode(GenericBay bay) {
+        bay.getConnectivityNodes().forEach(this::createConnectivityNode);
+        bay.getConductingEquipments().forEach(this::processConductingEquipment);
+    }
+
+    private void createConnectivityNode(GenericConnectivityNode connectivityNode) {
+        getPowerTransformer(connectivityNode.getPathName())
+                .ifPresentOrElse(powerTransformer -> {
+                            if (powerTransformer.isFeeder2WT()) {
+                                addNode(connectivityNode.getPathName(),
+                                        createFeeder2WTLegNode(connectivityNode.getPathName(),
+                                                powerTransformer.getSide(connectivityNode.getPathName()), 0, null));
+                            } else if (powerTransformer.isFeeder3WT()) {
+                                addNode(connectivityNode.getPathName(),
+                                        createFeeder3WTLegNode(connectivityNode.getPathName(),
+                                                powerTransformer.getSide(connectivityNode.getPathName()), 0, null));
+                            }
+                        }, () ->
+                                addNode(connectivityNode.getPathName(),
+                                        createFictitiousNode(connectivityNode.getPathName()))
+                );
+    }
+
+    private Optional<GenericPowerTransformer> getPowerTransformer(String pathName) {
+        if (substation != null) {
+            return substation.getPowerTransformerByConnectivityNode(pathName);
+        }
+        return Optional.empty();
+    }
+
+    private void processConductingEquipment(GenericConductingEquipment conductingEquipment) {
+        var terminals = conductingEquipment.getTerminals();
+        var fullName = conductingEquipment.getFullName();
+        var node = createSwitchNode(fullName);
+
+        Node node1 = terminalToNode(terminals.get(0));
+        Node node2 = null;
+        var termNb = terminals.size();
+        if (termNb == 1) {
+            node2 = createLoad(fullName + "/Grounded");
+        } else if (termNb == 2) {
+            node2 = terminalToNode(terminals.get(1));
+        }
+        connectNode(node, node1);
+        connectNode(node, node2);
+    }
+
+    private Node terminalToNode(GenericTerminal terminal) {
+        var pathName = terminal.getConnectivityNode();
+        if (pathName != null) {
+            return getNodeByPath(pathName);
+        }
+        return createLoad(terminal.getCNodeName());
+    }
+
+    private SwitchNode createSwitchNode(String id) {
+        SwitchNode sw = new SwitchNode(id, id, SwitchNode.SwitchKind.BREAKER.name(), false,
+                getGraph(), SwitchNode.SwitchKind.BREAKER, false);
+        getGraph().addNode(sw);
+        return sw;
+    }
+
+    private void connectNode(Node node1, Node node2) {
+        getGraph().addEdge(node1, node2);
+    }
+
+    private FictitiousNode createFictitiousNode(String id) {
+        InternalNode fictitiousNode = new InternalNode(id, getGraph());
+        getGraph().addNode(fictitiousNode);
+        return fictitiousNode;
+    }
+
+    private FeederNode createLoad(String id) {
+        FeederInjectionNode fn = FeederInjectionNode.createLoad(getGraph(), id, id);
+        commonFeederSetting(fn, id, 0, null);
+        return fn;
+    }
+
+    public Feeder2WTLegNode createFeeder2WTLegNode(String id, FeederWithSideNode.Side side, int order,
+                                                   BusCell.Direction direction) {
+        Feeder2WTLegNode f2WTe = Feeder2WTLegNode.create(getGraph(), id + "_" + side, id, id, side);
+        commonFeederSetting(f2WTe, id, order, direction);
+        return f2WTe;
+    }
+
+    public Feeder3WTLegNode createFeeder3WTLegNode(String id, FeederWithSideNode.Side side, int order,
+                                                   BusCell.Direction direction) {
+        Feeder3WTLegNode f3WTe = Feeder3WTLegNode.createForSubstationDiagram(getGraph(), id + "_" + side, id, id, side);
+        commonFeederSetting(f3WTe, id + side.getIntValue(), order, direction);
+        return f3WTe;
+    }
+
+    private void commonFeederSetting(FeederNode node, String id, int order, BusCell.Direction direction) {
+        node.setLabel(id);
+        getGraph().addNode(node);
+
+        if (direction != null) {
+            node.setOrder(order);
+            node.setDirection(direction);
+        }
+    }
+}

service/src/main/java/org/lfenergy/compas/scl/auto/alignment/service/SclAutoAlignmentDiagramLabelProvider.java

@@ -15,11 +15,10 @@
 import java.util.*;
 
 public class SclAutoAlignmentDiagramLabelProvider implements DiagramLabelProvider {
-    private final Map<Node, List<NodeLabel>> busLabels;
+    private final Map<Node, List<NodeLabel>> busLabels = new HashMap<>();
 
     public SclAutoAlignmentDiagramLabelProvider(SubstationGraph graph) {
-        this.busLabels = new HashMap<>();
-        graph.getNodes().forEach(voltageLevelGraph ->
+        graph.getVoltageLevels().forEach(voltageLevelGraph ->
                 voltageLevelGraph.getNodes().forEach(this::addNode)
         );
         graph.getMultiTermNodes().forEach(this::addNode);