[CGMES] Less internal connections created at import

cgmes/cgmes-conversion/src/main/java/com/powsybl/cgmes/conversion/Conversion.java

@@ -170,6 +170,7 @@ public Network convert(ReportNode reportNode) {
         cgmes.baseVoltages().forEach(bv -> bvAdder.addBaseVoltage(bv.getId("BaseVoltage"), bv.asDouble("nominalVoltage"), isBoundaryBaseVoltage(bv.getLocal("graph"))));
         bvAdder.add();
         cgmes.computedTerminals().forEach(t -> context.terminalMapping().buildTopologicalNodeCgmesTerminalsMapping(t));
+        cgmes.computedTerminals().forEach(t -> context.terminalMapping().buildConnectivityNodeCgmesTerminalsMapping(t, context.config()));
         cgmes.regulatingControls().forEach(p -> context.regulatingControlMapping().cacheRegulatingControls(p));
         context.popReportNode();
 

cgmes/cgmes-conversion/src/main/java/com/powsybl/cgmes/conversion/NodeMapping.java

@@ -9,22 +9,26 @@
 package com.powsybl.cgmes.conversion;
 
 import com.powsybl.cgmes.model.CgmesTerminal;
+import com.powsybl.commons.PowsyblException;
 import com.powsybl.iidm.network.Switch;
 import com.powsybl.iidm.network.SwitchKind;
 import com.powsybl.iidm.network.VoltageLevel;
 
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 /**
  * @author Luma Zamarreño {@literal <zamarrenolm at aia.es>}
  */
 public class NodeMapping {
 
+    private final Map<String, Integer> cgmes2iidm = new HashMap<>(100);
+    private final Map<VoltageLevel, Integer> voltageLevelNumNodes = new HashMap<>(100);
+    private final Context context;
+
     public NodeMapping(Context context) {
         this.context = context;
-        cgmes2iidm = new HashMap<>(100);
-        voltageLevelNumNodes = new HashMap<>(100);
     }
 
     public int iidmNodeForTopologicalNode(String id, int associatedNode, VoltageLevel vl) {
@@ -43,51 +47,118 @@ public int iidmNodeForTopologicalNode(String id, int associatedNode, VoltageLeve
     }
 
     public int iidmNodeForTerminal(CgmesTerminal t, boolean isSwitchEnd, VoltageLevel vl) {
-        return iidmNodeForTerminal(t, isSwitchEnd, vl, true);
+        // Because there are some node-breaker models that, in addition to the information of opened switches also set
+        // the terminal.connected property to false, we have decided to create fictitious switches to precisely
+        // map this situation to IIDM.
+        // This behavior can be disabled through configuration.
+
+        var fictSwCreationMode = context.config().getCreateFictitiousSwitchesForDisconnectedTerminalsMode();
+        boolean bbsForEveryConnectivityNode = context.config().createBusbarSectionForEveryConnectivityNode();
+        if (!t.connected() && createFictitiousSwitch(fictSwCreationMode, isSwitchEnd)) {
+            createFictitiousSwitch(t, vl);
+        } else {
+            if (isSwitchEnd) {
+                // for switches the iidm node is the one from the connectivity node
+                return cgmes2iidm.get(t.connectivityNode());
+            } else if (bbsForEveryConnectivityNode) {
+                createInternalConnection(t, vl);
+            } else if (!cgmes2iidm.containsKey(t.id())) {
+                // Create internal connections but only if too many terminals on connectivity node
+                createInternalConnectionsIfNeeded(t.connectivityNode(), vl);
+            }
+        }
+
+        return cgmes2iidm.get(t.id());
     }
 
-    public int iidmNodeForTerminal(CgmesTerminal t, boolean isSwitchEnd, VoltageLevel vl, boolean equipmentIsConnected) {
-        int iidmNodeForConductingEquipment = cgmes2iidm.computeIfAbsent(t.id(), id -> newNode(vl));
-        // Add internal connection from terminal to connectivity node
+    private void createInternalConnectionsIfNeeded(String connectivityNode, VoltageLevel vl) {
+        List<CgmesTerminal> connectivityNodeTerminals = context.terminalMapping().getConnectivityNodeTerminals(connectivityNode);
+        switch (connectivityNodeTerminals.size()) {
+            case 0 -> throw new PowsyblException("Erroneous connectivity node terminals mapping");
+            case 1 ->
+                // Only one terminal: no need to create an internal connection
+                // Connectivity node and terminal share the same iidm node
+                oneIidmNodeForBothTerminalAndConnectivityNode(connectivityNodeTerminals.get(0), vl);
+            case 2 -> {
+                // There are two terminals on the same connectivity node. We need one (and only one!) internal connection
+                // between the two terminals as iidm can only handle one terminal per node.
+                // There's a special treatment for BusbarSections described below. Indeed, a bbs is a central equipment,
+                // to which bays/cells connect. We want to keep this physical centrality in iidm, especially for
+                // easy graph traversals and visualization. Note that there are no other central equipments of this type.
+                // - if there's one bbs, it is placed at the connectivity node: in iidm we want the node of the bbs terminal
+                // (and not the connectivity point!) to be where all feeders connect.
+                // - if there are two bbs on the same connectivity node (that is, two united bbs), this is only done for
+                // the first bbs of the list.
+                CgmesTerminal t0 = connectivityNodeTerminals.get(0);
+                CgmesTerminal t1 = connectivityNodeTerminals.get(1);
+                if (!isBusbarSectionTerminal(t0) && isBusbarSectionTerminal(t1)) {
+                    oneIidmNodeForBothTerminalAndConnectivityNode(t1, vl);
+                    createInternalConnection(t0, vl);
+                } else {
+                    oneIidmNodeForBothTerminalAndConnectivityNode(t0, vl);
+                    createInternalConnection(t1, vl);
+                }
+            }
+            default -> {
+                // We need the connectivity node as connecting point between terminals
+                // Similarly to previous case, there's a special treatment for BusbarSections described thereafter for
+                // the same mentioned reasons.
+                // - if there's only one bbs, it is placed at the connectivity node.
+                // - if there are several bbs (that is, several united bbs), this is only done for the first one
+                // encountered, the other ones are connected to the first one with internal connections.
+                boolean bbsEncountered = false;
+                for (CgmesTerminal t : connectivityNodeTerminals) {
+                    if (!bbsEncountered && isBusbarSectionTerminal(t)) {
+                        oneIidmNodeForBothTerminalAndConnectivityNode(t, vl);
+                        bbsEncountered = true;
+                    } else {
+                        // Add internal connection from terminal to connectivity node as iidm can only handle one terminal per node
+                        // For node-breaker models we create an internal connection between the terminal and its connectivity node
+                        createInternalConnection(t, vl);
+                    }
+                }
+            }
+        }
+    }
+
+    private void createInternalConnection(CgmesTerminal t, VoltageLevel vl) {
         int iidmNodeForConnectivityNode = cgmes2iidm.computeIfAbsent(t.connectivityNode(), id -> newNode(vl));
+        int iidmNodeForTerminal = cgmes2iidm.computeIfAbsent(t.id(), id -> newNode(vl));
+        vl.getNodeBreakerView().newInternalConnection()
+                .setNode1(iidmNodeForConnectivityNode)
+                .setNode2(iidmNodeForTerminal)
+                .add();
+    }
 
-        // For node-breaker models we create an internal connection between
-        // the terminal and its connectivity node
-        // Because there are some node-breaker models that,
-        // in addition to the information of opened switches also set
-        // the terminal.connected property to false,
-        // we have decided to create fictitious switches to precisely
-        // map this situation to IIDM.
-        // This behavior can be disabled through configuration.
+    private void oneIidmNodeForBothTerminalAndConnectivityNode(CgmesTerminal t, VoltageLevel vl) {
+        int iidmNodeForConnectivityNode = cgmes2iidm.computeIfAbsent(t.connectivityNode(), id -> newNode(vl));
+        cgmes2iidm.put(t.id(), iidmNodeForConnectivityNode); // connectivity node and terminal share the same iidm node
+    }
 
-        boolean connected = t.connected() && equipmentIsConnected;
+    private void createFictitiousSwitch(CgmesTerminal t, VoltageLevel vl) {
+        int iidmNodeForConductingEquipment = cgmes2iidm.computeIfAbsent(t.id(), id -> newNode(vl));
+        int iidmNodeForConnectivityNode = cgmes2iidm.computeIfAbsent(t.connectivityNode(), id -> newNode(vl));
 
-        if (connected || !createFictitiousSwitch(context.config().getCreateFictitiousSwitchesForDisconnectedTerminalsMode(), isSwitchEnd)) {
-            // TODO(Luma): do not add an internal connection if is has already been added?
-            vl.getNodeBreakerView().newInternalConnection()
+        // Only add fictitious switches for disconnected terminals if not already added
+        // Use the id and name of terminal
+        String switchId = t.id() + "_SW_fict";
+        if (vl.getNetwork().getSwitch(switchId) == null) {
+            Switch sw = vl.getNodeBreakerView().newSwitch()
+                    .setFictitious(true)
+                    .setId(switchId)
+                    .setName(t.name())
                     .setNode1(iidmNodeForConductingEquipment)
                     .setNode2(iidmNodeForConnectivityNode)
+                    .setOpen(true)
+                    .setKind(SwitchKind.BREAKER)
+                    .setEnsureIdUnicity(context.config().isEnsureIdAliasUnicity())
                     .add();
-        } else {
-            // Only add fictitious switches for disconnected terminals if not already added
-            // Use the id and name of terminal
-            String switchId = t.id() + "_SW_fict";
-            if (vl.getNetwork().getSwitch(switchId) == null) {
-                Switch sw = vl.getNodeBreakerView().newSwitch()
-                        .setFictitious(true)
-                        .setId(switchId)
-                        .setName(t.name())
-                        .setNode1(iidmNodeForConductingEquipment)
-                        .setNode2(iidmNodeForConnectivityNode)
-                        .setOpen(true)
-                        .setKind(SwitchKind.BREAKER)
-                        .setEnsureIdUnicity(context.config().isEnsureIdAliasUnicity())
-                        .add();
-                sw.setProperty(Conversion.PROPERTY_IS_CREATED_FOR_DISCONNECTED_TERMINAL, "true");
-            }
+            sw.setProperty(Conversion.PROPERTY_IS_CREATED_FOR_DISCONNECTED_TERMINAL, "true");
         }
+    }
 
-        return iidmNodeForConductingEquipment;
+    private static boolean isBusbarSectionTerminal(CgmesTerminal t) {
+        return t.conductingEquipmentType().equals("BusbarSection");
     }
 
     private static boolean createFictitiousSwitch(CgmesImport.FictitiousSwitchesCreationMode mode, boolean isSwitchEnd) {
@@ -110,8 +181,4 @@ private int newNode(VoltageLevel vl) {
         int numNodes = voltageLevelNumNodes.merge(vl, 1, Integer::sum);
         return numNodes - 1;
     }
-
-    private final Map<String, Integer> cgmes2iidm;
-    private final Map<VoltageLevel, Integer> voltageLevelNumNodes;
-    private final Context context;
 }

cgmes/cgmes-conversion/src/main/java/com/powsybl/cgmes/conversion/TerminalMapping.java

@@ -26,13 +26,14 @@
  */
 public class TerminalMapping {
 
-    public TerminalMapping() {
-        boundaries = new HashMap<>();
-        terminals = new HashMap<>();
-        terminalNumbers = new HashMap<>();
-        topologicalNodesMapping = new HashMap<>();
-        cgmesTerminalsMapping = new HashMap<>();
-    }
+    private final Map<String, Terminal> terminals = new HashMap<>();
+    private final Map<String, Boundary> boundaries = new HashMap<>();
+    // This is a somewhat dirty way of storing the side for the CGMES terminal
+    // (only mapped when the terminal is connected to a branch)
+    private final Map<String, Integer> terminalNumbers = new HashMap<>();
+    private final Map<String, List<String>> topologicalNodesMapping = new HashMap<>();
+    private final Map<String, List<CgmesTerminal>> connectivityNodeTerminalsMapping = new HashMap<>();
+    private final Map<String, String> cgmesTerminalsMapping = new HashMap<>();
 
     public void add(String cgmesTerminal, Terminal iidmTerminal, int terminalNumber) {
         if (terminals.containsKey(cgmesTerminal) || boundaries.containsKey(cgmesTerminal)) {
@@ -145,6 +146,22 @@ public void buildTopologicalNodeCgmesTerminalsMapping(CgmesTerminal t) {
         }
     }
 
+    public void buildConnectivityNodeCgmesTerminalsMapping(CgmesTerminal t, Conversion.Config config) {
+        // To avoid creating unnecessary internal connections, we need to compute the mapping of the connectivity nodes to the list
+        // of CgmesTerminals
+        // - this list should not contain switches
+        // - if CgmesImport.FictitiousSwitchesCreationMode.ALWAYS or CgmesImport.FictitiousSwitchesCreationMode.ALWAYS_EXCEPT_SWITCHES,
+        // this list should not contain the disconnected terminals
+        boolean onlyConnected = config.getCreateFictitiousSwitchesForDisconnectedTerminalsMode() != CgmesImport.FictitiousSwitchesCreationMode.NEVER;
+        if (CgmesNames.SWITCH_TYPES.contains(t.conductingEquipmentType())) {
+            return; // switches do not have terminals in iidm, so we should not count them
+        }
+        String connectivityNode = t.connectivityNode();
+        if (connectivityNode != null && (!onlyConnected || t.connected())) {
+            connectivityNodeTerminalsMapping.computeIfAbsent(connectivityNode, k -> new ArrayList<>(1)).add(t);
+        }
+    }
+
     public boolean areAssociated(String cgmesTerminalId, String topologicalNode) {
         return topologicalNodesMapping.get(topologicalNode).contains(cgmesTerminalId);
     }
@@ -173,11 +190,7 @@ public String findCgmesTerminalFromTopologicalNode(String topologicalNode) {
         return topologicalNodesMapping.containsKey(topologicalNode) ? topologicalNodesMapping.get(topologicalNode).get(0) : null;
     }
 
-    private final Map<String, Terminal> terminals;
-    private final Map<String, Boundary> boundaries;
-    // This is a somewhat dirty way of storing the side for the CGMES terminal
-    // (only mapped when the terminal is connected to a branch)
-    private final Map<String, Integer> terminalNumbers;
-    private final Map<String, List<String>> topologicalNodesMapping;
-    private final Map<String, String> cgmesTerminalsMapping;
+    public List<CgmesTerminal> getConnectivityNodeTerminals(String id) {
+        return connectivityNodeTerminalsMapping.getOrDefault(id, List.of());
+    }
 }

cgmes/cgmes-conversion/src/main/java/com/powsybl/cgmes/conversion/elements/AbstractConductingEquipmentConversion.java

@@ -381,20 +381,16 @@ private static Optional<EquivalentInjectionConversion> getEquivalentInjectionCon
     }
 
     int iidmNode() {
-        return iidmNode(1, true);
+        return iidmNode(1);
     }
 
     int iidmNode(int n) {
-        return iidmNode(n, true);
-    }
-
-    int iidmNode(int n, boolean equipmentIsConnected) {
         if (!context.nodeBreaker()) {
             throw new ConversionException("Can't request an iidmNode if conversion context is not node-breaker");
         }
         VoltageLevel vl = terminals[n - 1].voltageLevel;
         CgmesTerminal t = terminals[n - 1].t;
-        return context.nodeMapping().iidmNodeForTerminal(t, type.equals("Switch"), vl, equipmentIsConnected);
+        return context.nodeMapping().iidmNodeForTerminal(t, type.equals("Switch"), vl);
     }
 
     String busId() {
@@ -616,24 +612,20 @@ public static void connect(Context context, BranchAdder<?, ?> adder,
     }
 
     public void connect(BranchAdder<?, ?> adder, boolean t1Connected, boolean t2Connected) {
-        connect(adder, t1Connected, t2Connected, true);
-    }
-
-    public void connect(BranchAdder<?, ?> adder, boolean t1Connected, boolean t2Connected, boolean branchIsClosed) {
         if (context.nodeBreaker()) {
             adder
                 .setVoltageLevel1(iidmVoltageLevelId(1))
                 .setVoltageLevel2(iidmVoltageLevelId(2))
-                .setNode1(iidmNode(1, branchIsClosed))
-                .setNode2(iidmNode(2, branchIsClosed));
+                .setNode1(iidmNode(1))
+                .setNode2(iidmNode(2));
         } else {
             String busId1 = busId(1);
             String busId2 = busId(2);
             adder
                 .setVoltageLevel1(iidmVoltageLevelId(1))
                 .setVoltageLevel2(iidmVoltageLevelId(2))
-                .setBus1(t1Connected && branchIsClosed ? busId1 : null)
-                .setBus2(t2Connected && branchIsClosed ? busId2 : null)
+                .setBus1(t1Connected ? busId1 : null)
+                .setBus2(t2Connected ? busId2 : null)
                 .setConnectableBus1(busId1)
                 .setConnectableBus2(busId2);
         }