Manage dangling lines and tie lines

metrix-integration/src/main/groovy/com/powsybl/metrix/integration/BranchMonitoringData.groovy

@@ -7,6 +7,8 @@
  */
 package com.powsybl.metrix.integration
 
+import com.powsybl.iidm.network.Branch
+import com.powsybl.iidm.network.DanglingLine
 import com.powsybl.iidm.network.Identifiable
 import com.powsybl.iidm.network.Network
 import com.powsybl.metrix.mapping.LogDslLoader
@@ -126,11 +128,19 @@ class BranchMonitoringData {
     }
 
     protected static branchData(Closure closure, String id, Network network, TimeSeriesMappingConfigLoader configLoader, MetrixDslData data, LogDslLoader logDslLoader) {
-        Identifiable identifiable = network.getBranch(id)
+        Identifiable identifiable = network.getIdentifiable(id)
         if (identifiable == null) {
             logDslLoader.logWarn("Branch %s not found in the network", id)
             return
         }
+        if (!(identifiable instanceof Branch || identifiable instanceof DanglingLine)) {
+            logDslLoader.logWarn("Branch %s is not a Branch or Dangling Line", id)
+            return
+        }
+        if (identifiable instanceof DanglingLine && identifiable.isPaired()) {
+            logDslLoader.logWarn("Branch %s is a paired Dangling Line, the TieLine should be used instead", id)
+            return
+        }
 
         def branchSpec = branchMonitoringData(closure)
 

metrix-integration/src/main/groovy/com/powsybl/metrix/integration/SectionMonitoringData.groovy

@@ -48,10 +48,18 @@ class SectionMonitoringData {
                 logDslLoader.logWarn("sectionMonitoring '" + id + "' branch id '"+branch.getKey()+"' not found in the network")
                 return
             }
-            if (!(identifiable instanceof Line || identifiable instanceof TwoWindingsTransformer || identifiable instanceof HvdcLine)) {
+            if (!(identifiable instanceof Line ||
+                    identifiable instanceof TwoWindingsTransformer ||
+                    identifiable instanceof TieLine ||
+                    identifiable instanceof DanglingLine ||
+                    identifiable instanceof HvdcLine)) {
                 logDslLoader.logWarn("sectionMonitoring '" + id + "' type " + identifiable.getClass().name + " not supported")
                 return
             }
+            if (identifiable instanceof DanglingLine && identifiable.isPaired()) {
+                logDslLoader.logWarn("Branch %s is a paired Dangling Line, the TieLine should be used instead", id)
+                return
+            }
         }
         section.setCoefFlowList(spec.branchList)
         data.addSection(section)

metrix-integration/src/main/java/com/powsybl/metrix/integration/MetrixNetwork.java

@@ -37,6 +37,8 @@ public class MetrixNetwork {
     private static final Logger LOGGER = LoggerFactory.getLogger(MetrixNetwork.class);
     private static final String PAYS_CVG_PROPERTY = "paysCvg";
     private static final String PAYS_CVG_UNDEFINED = "Undefined";
+    private static final String METRIX_DANGLING_LINE_BUS_SUFFIX = "_metrixDanglingLineBus";
+    private static final String METRIX_DANGLING_LINE_LOAD_SUFFIX = "_metrixDanglingLineLoad";
 
     private final Network network;
 
@@ -52,8 +54,9 @@ public class MetrixNetwork {
     private final Set<Line> lineList = new LinkedHashSet<>();
     private final Set<TwoWindingsTransformer> twoWindingsTransformerList = new LinkedHashSet<>();
     private final Set<ThreeWindingsTransformer> threeWindingsTransformerList = new LinkedHashSet<>();
-    private final Set<DanglingLine> danglingLineList = new LinkedHashSet<>();
     private final Set<Switch> switchList = new LinkedHashSet<>();
+    private final Set<DanglingLine> unpairedDanglingLineList = new LinkedHashSet<>();
+    private final Set<TieLine> tieLineList = new LinkedHashSet<>();
 
     private final Set<PhaseTapChanger> phaseTapChangerList = new LinkedHashSet<>();
 
@@ -104,14 +107,18 @@ public List<ThreeWindingsTransformer> getThreeWindingsTransformerList() {
         return List.copyOf(threeWindingsTransformerList);
     }
 
-    public List<DanglingLine> getDanglingLineList() {
-        return List.copyOf(danglingLineList);
+    public List<DanglingLine> getUnpairedDanglingLineList() {
+        return List.copyOf(unpairedDanglingLineList);
     }
 
     public List<Switch> getSwitchList() {
         return List.copyOf(switchList);
     }
 
+    public List<TieLine> getTieLineList() {
+        return List.copyOf(tieLineList);
+    }
+
     public List<PhaseTapChanger> getPhaseTapChangerList() {
         return List.copyOf(phaseTapChangerList);
     }
@@ -137,6 +144,19 @@ public int getIndex(Identifiable<?> identifiable) {
         return mapper.getInt(subset, identifiable.getId());
     }
 
+    public int getUnpairedDanglingLineBusIndex(DanglingLine danglingLine) {
+        Objects.requireNonNull(danglingLine);
+        if (danglingLine.isPaired()) {
+            throw new IllegalStateException("DanglingLine is paired " + danglingLine.getId());
+        }
+        return mapper.getInt(MetrixSubset.NOEUD, danglingLine.getId() + METRIX_DANGLING_LINE_BUS_SUFFIX);
+    }
+
+    public static String getUnpairedDanglingLineLoadId(DanglingLine danglingLine) {
+        Objects.requireNonNull(danglingLine);
+        return danglingLine.getId() + METRIX_DANGLING_LINE_LOAD_SUFFIX;
+    }
+
     private MetrixSubset getMetrixSubset(Identifiable<?> identifiable) {
         MetrixSubset subset = MetrixSubset.QUAD;
         if (identifiable instanceof Generator) {
@@ -205,6 +225,12 @@ private void addLine(Line line) {
         }
     }
 
+    private void addTieLine(TieLine tieLine) {
+        if (tieLineList.add(tieLine)) {
+            mapper.newInt(MetrixSubset.QUAD, tieLine.getId());
+        }
+    }
+
     private void addTwoWindingsTransformer(TwoWindingsTransformer twt) {
         if (twoWindingsTransformerList.add(twt)) {
             mapper.newInt(MetrixSubset.QUAD, twt.getId());
@@ -217,9 +243,11 @@ private void addThreeWindingsTransformer(ThreeWindingsTransformer twt) {
         }
     }
 
-    private void addDanglingLine(DanglingLine dl) {
-        if (danglingLineList.add(dl)) {
+    private void addUnpairedDanglingLine(DanglingLine dl) {
+        if (unpairedDanglingLineList.add(dl)) {
             mapper.newInt(MetrixSubset.QUAD, dl.getId());
+            mapper.newInt(MetrixSubset.NOEUD, dl.getId() + METRIX_DANGLING_LINE_BUS_SUFFIX);
+            mapper.newInt(MetrixSubset.LOAD, dl.getId() + METRIX_DANGLING_LINE_LOAD_SUFFIX);
         }
     }
 
@@ -315,6 +343,28 @@ private void createLineList() {
         }
     }
 
+    private void createTieLineList() {
+        int nbNok = 0;
+        for (TieLine tieLine : network.getTieLines()) {
+            Terminal t1 = tieLine.getTerminal1();
+            Bus b1 = t1.getBusBreakerView().getBus();
+            Terminal t2 = tieLine.getTerminal2();
+            Bus b2 = t2.getBusBreakerView().getBus();
+            if (b1 != null && b2 != null) {
+                if (busList.contains(b1) && busList.contains(b2)) {
+                    addTieLine(tieLine);
+                } else {
+                    nbNok++;
+                }
+            } else {
+                nbNok++;
+            }
+        }
+        if (LOGGER.isDebugEnabled()) {
+            LOGGER.debug(String.format("TieLines   total = <%5d> ok = <%5d> not = <%5d>", tieLineList.size() + nbNok, tieLineList.size(), nbNok));
+        }
+    }
+
     private void addTwoWindingsTransformer(TwoWindingsTransformer twt, AtomicInteger nbNok, AtomicInteger nbPtcNok) {
         Terminal t1 = twt.getTerminal1();
         Terminal t2 = twt.getTerminal2();
@@ -383,23 +433,25 @@ private void createTransformerList() {
         createThreeWindingsTransformersList();
     }
 
-    private void createDanglingLineList() {
+    private void createUnpairedDanglingLineList() {
         int nbNok = 0;
         for (DanglingLine dl : network.getDanglingLines()) {
-            Terminal t = dl.getTerminal();
-            Bus b = t.getBusBreakerView().getBus();
-            if (b != null) {
-                if (busList.contains(b)) {
-                    addDanglingLine(dl);
+            if (!dl.isPaired()) {
+                Terminal t = dl.getTerminal();
+                Bus b = t.getBusBreakerView().getBus();
+                if (b != null) {
+                    if (busList.contains(b)) {
+                        addUnpairedDanglingLine(dl);
+                    } else {
+                        nbNok++;
+                    }
                 } else {
                     nbNok++;
                 }
-            } else {
-                nbNok++;
             }
         }
         if (LOGGER.isDebugEnabled()) {
-            LOGGER.debug(String.format("Dangling   total = <%5d> ok = <%5d> not = <%5d>", danglingLineList.size() + nbNok, danglingLineList.size(), nbNok));
+            LOGGER.debug(String.format("Dangling   total = <%5d> ok = <%5d> not = <%5d>", unpairedDanglingLineList.size() + nbNok, unpairedDanglingLineList.size(), nbNok));
         }
     }
 
@@ -421,7 +473,7 @@ private void createSwitchList() {
             }
         }
         if (LOGGER.isDebugEnabled()) {
-            LOGGER.debug(String.format("Switches    total = <%5d> ok = <%5d> not = <%5d>", switchList.size() + nbNok, switchList.size(), nbNok));
+            LOGGER.debug(String.format("Switches   total = <%5d> ok = <%5d> not = <%5d>", switchList.size() + nbNok, switchList.size(), nbNok));
         }
     }
 
@@ -521,10 +573,11 @@ private void init() {
         createGeneratorList();
         createLineList();
         createTransformerList();
-        createDanglingLineList();
+        createUnpairedDanglingLineList();
         createSwitchList();
         createLoadList();
         createHvdcLineList();
+        createTieLineList();
     }
 
     public static MetrixNetwork create(Network network) {
@@ -538,8 +591,7 @@ public static MetrixNetwork create(Network network, ContingenciesProvider contin
             try {
                 reader = Files.newBufferedReader(remedialActionFile, StandardCharsets.UTF_8);
             } catch (IOException e) {
-                LOGGER.error("Failed to read remedialActionFile {}", remedialActionFile, e);
-                throw new UncheckedIOException(e);
+                throw new UncheckedIOException("Failed to read remedialActionFile " + remedialActionFile, e);
             }
         }
         return create(
@@ -657,7 +709,18 @@ private void addElementToRetainedBreakersList(Switch sw, Terminal terminal, bool
             // Since switches connected to lines and TWT are "replaced" by those connectables, no need to set them retained
             case LINE, TWO_WINDINGS_TRANSFORMER -> addElementToRetainedBreakersList(sw, terminal.getConnectable().getId(), false);
             case LOAD, GENERATOR -> addElementToRetainedBreakersList(sw, switchId, setRetained);
-            case DANGLING_LINE, HVDC_CONVERTER_STATION, SHUNT_COMPENSATOR, STATIC_VAR_COMPENSATOR,
+            case DANGLING_LINE -> {
+                DanglingLine danglingLine = (DanglingLine) terminal.getConnectable();
+                if (danglingLine.isPaired()) {
+                    // Paired dangling line is managed as a line via the tie line
+                    TieLine tieLine = danglingLine.getTieLine().orElseThrow(() -> new PowsyblException("No tie line on a paired dangling line - should not happen"));
+                    addElementToRetainedBreakersList(sw, tieLine.getId(), false);
+                } else {
+                    // Unpaired dangling line is managed as a line (ending to a load)
+                    addElementToRetainedBreakersList(sw, terminal.getConnectable().getId(), false);
+                }
+            }
+            case HVDC_CONVERTER_STATION, SHUNT_COMPENSATOR, STATIC_VAR_COMPENSATOR,
                  THREE_WINDINGS_TRANSFORMER -> {
                 if (LOGGER.isWarnEnabled()) {
                     LOGGER.warn("Unsupported connectable type ({}) for switch '{}'", terminal.getConnectable().getType(), switchId);