Support having multiple active operational limits group

src/main/java/com/powsybl/openloadflow/network/LfBranch.java

@@ -15,6 +15,7 @@
 import com.powsybl.iidm.network.util.LimitViolationUtils;
 import com.powsybl.openloadflow.sa.LimitReductionManager;
 import com.powsybl.openloadflow.util.Evaluable;
+import com.powsybl.openloadflow.util.PerUnit;
 import com.powsybl.security.results.BranchResult;
 
 import java.util.*;
@@ -38,6 +39,73 @@ enum BranchType {
     record LfBranchResults(double p1, double p2, double q1, double q2, double i1, double i2) {
     }
 
+    class LfLimitsGroup {
+
+        private final List<LfLimit> sortedLimits;
+
+        private final String operationalLimitsGroupId;
+
+        public LfLimitsGroup(List<LfLimit> sortedLimits, String operationalLimitsGroupId) {
+            this.sortedLimits = sortedLimits;
+            this.operationalLimitsGroupId = operationalLimitsGroupId;
+        }
+
+        public String getOperationalLimitsGroupId() {
+            return operationalLimitsGroupId;
+        }
+
+        public List<LfLimit> getSortedLimits() {
+            return sortedLimits;
+        }
+
+        private static double getScaleForLimitType(LimitType type, LfBus bus) {
+            return switch (type) {
+                case ACTIVE_POWER, APPARENT_POWER -> 1.0 / PerUnit.SB;
+                case CURRENT -> 1.0 / PerUnit.ib(bus.getNominalV());
+                default ->
+                        throw new UnsupportedOperationException(String.format("Getting scale for limit type %s is not supported.", type));
+            };
+        }
+
+        /**
+         * Create the list of LfLimits from a LoadingLimits and a list of reductions.
+         * The resulting list will contain the permanent limit
+         * This list is returned in a LfLimitsGroup object
+         */
+        public static LfLimitsGroup createSortedLimitsList(LoadingLimits loadingLimits, String operationalLimitsGroupId, LfBus bus, double[] limitReductions) {
+            List<LfLimit> sortedLimits = new ArrayList<>(3);
+            if (loadingLimits != null) {
+                double toPerUnit = getScaleForLimitType(loadingLimits.getLimitType(), bus);
+
+                int i = 0;
+                for (LoadingLimits.TemporaryLimit temporaryLimit : loadingLimits.getTemporaryLimits()) {
+                    if (temporaryLimit.getAcceptableDuration() != 0) {
+                        // it is not useful to add a limit with acceptable duration equal to zero as the only value plausible
+                        // for this limit is infinity.
+                        // https://javadoc.io/doc/com.powsybl/powsybl-core/latest/com/powsybl/iidm/network/CurrentLimits.html
+                        double reduction = limitReductions.length == 0 ? 1d : limitReductions[i + 1]; // Temporary limit's reductions are stored starting from index 1 in `limitReductions`
+                        double originalValuePerUnit = temporaryLimit.getValue() * toPerUnit;
+                        sortedLimits.add(0, LfLimit.createTemporaryLimit(temporaryLimit.getName(), temporaryLimit.getAcceptableDuration(),
+                                originalValuePerUnit, reduction));
+                    }
+                    i++;
+                }
+                double reduction = limitReductions.length == 0 ? 1d : limitReductions[0];
+                sortedLimits.add(LfLimit.createPermanentLimit(loadingLimits.getPermanentLimit() * toPerUnit, reduction));
+            }
+            if (sortedLimits.size() > 1) {
+                // we only make that fix if there is more than a permanent limit attached to the branch.
+                for (int i = sortedLimits.size() - 1; i > 0; i--) {
+                    // From the permanent limit to the most serious temporary limit.
+                    sortedLimits.get(i).setAcceptableDuration(sortedLimits.get(i - 1).getAcceptableDuration());
+                }
+                sortedLimits.get(0).setAcceptableDuration(0);
+            }
+            return new LfLimitsGroup(sortedLimits, operationalLimitsGroupId);
+        }
+
+    }
+
     class LfLimit {
 
         private final String name;
@@ -211,9 +279,9 @@ static int[] createIndex(LfNetwork network, List<LfBranch> branches) {
 
     List<Evaluable> getAdditionalClosedQ2();
 
-    List<LfLimit> getLimits1(LimitType type, LimitReductionManager limitReductionManager);
+    List<LfLimitsGroup> getLimits1(LimitType type, LimitReductionManager limitReductionManager);
 
-    default List<LfLimit> getLimits2(LimitType type, LimitReductionManager limitReductionManager) {
+    default List<LfLimitsGroup> getLimits2(LimitType type, LimitReductionManager limitReductionManager) {
         return Collections.emptyList();
     }
 

src/main/java/com/powsybl/openloadflow/network/impl/AbstractLfBranch.java

@@ -11,7 +11,6 @@
 import com.powsybl.openloadflow.network.*;
 import com.powsybl.openloadflow.sa.LimitReductionManager;
 import com.powsybl.openloadflow.util.Evaluable;
-import com.powsybl.openloadflow.util.PerUnit;
 import net.jafama.FastMath;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -30,17 +29,17 @@ public abstract class AbstractLfBranch extends AbstractElement implements LfBran
 
     protected final LfBus bus2;
 
-    private List<LfLimit> currentLimits1;
+    private List<LfLimitsGroup> currentLimits1;
 
-    private List<LfLimit> activePowerLimits1;
+    private List<LfLimitsGroup> activePowerLimits1;
 
-    private List<LfLimit> apparentPowerLimits1;
+    private List<LfLimitsGroup> apparentPowerLimits1;
 
-    private List<LfLimit> currentLimits2;
+    private List<LfLimitsGroup> currentLimits2;
 
-    private List<LfLimit> activePowerLimits2;
+    private List<LfLimitsGroup> activePowerLimits2;
 
-    private List<LfLimit> apparentPowerLimits2;
+    private List<LfLimitsGroup> apparentPowerLimits2;
 
     protected final PiModel piModel;
 
@@ -92,42 +91,6 @@ public Optional<ThreeSides> getOriginalSide() {
         return Optional.empty();
     }
 
-    /**
-     * Create the list of LfLimits from a LoadingLimits and a list of reductions.
-     * The resulting list will contain the permanent limit
-     */
-    protected static List<LfLimit> createSortedLimitsList(LoadingLimits loadingLimits, LfBus bus, double[] limitReductions) {
-        List<LfLimit> sortedLimits = new ArrayList<>(3);
-        if (loadingLimits != null) {
-            double toPerUnit = getScaleForLimitType(loadingLimits.getLimitType(), bus);
-
-            int i = 0;
-            for (LoadingLimits.TemporaryLimit temporaryLimit : loadingLimits.getTemporaryLimits()) {
-                if (temporaryLimit.getAcceptableDuration() != 0) {
-                    // it is not useful to add a limit with acceptable duration equal to zero as the only value plausible
-                    // for this limit is infinity.
-                    // https://javadoc.io/doc/com.powsybl/powsybl-core/latest/com/powsybl/iidm/network/CurrentLimits.html
-                    double reduction = limitReductions.length == 0 ? 1d : limitReductions[i + 1]; // Temporary limit's reductions are stored starting from index 1 in `limitReductions`
-                    double originalValuePerUnit = temporaryLimit.getValue() * toPerUnit;
-                    sortedLimits.add(0, LfLimit.createTemporaryLimit(temporaryLimit.getName(), temporaryLimit.getAcceptableDuration(),
-                            originalValuePerUnit, reduction));
-                }
-                i++;
-            }
-            double reduction = limitReductions.length == 0 ? 1d : limitReductions[0];
-            sortedLimits.add(LfLimit.createPermanentLimit(loadingLimits.getPermanentLimit() * toPerUnit, reduction));
-        }
-        if (sortedLimits.size() > 1) {
-            // we only make that fix if there is more than a permanent limit attached to the branch.
-            for (int i = sortedLimits.size() - 1; i > 0; i--) {
-                // From the permanent limit to the most serious temporary limit.
-                sortedLimits.get(i).setAcceptableDuration(sortedLimits.get(i - 1).getAcceptableDuration());
-            }
-            sortedLimits.get(0).setAcceptableDuration(0);
-        }
-        return sortedLimits;
-    }
-
     @Override
     public ElementType getType() {
         return ElementType.BRANCH;
@@ -143,7 +106,7 @@ public LfBus getBus2() {
         return bus2;
     }
 
-    private List<LfLimit> getLimits1(LimitType type) {
+    private List<LfLimitsGroup> getLimits1(LimitType type) {
         switch (type) {
             case ACTIVE_POWER -> {
                 return activePowerLimits1;
@@ -158,7 +121,7 @@ private List<LfLimit> getLimits1(LimitType type) {
         }
     }
 
-    private void setLimits1(LimitType type, List<LfLimit> limits) {
+    private void setLimits1(LimitType type, List<LfLimitsGroup> limits) {
         switch (type) {
             case ACTIVE_POWER -> activePowerLimits1 = limits;
             case APPARENT_POWER -> apparentPowerLimits1 = limits;
@@ -167,19 +130,31 @@ private void setLimits1(LimitType type, List<LfLimit> limits) {
         }
     }
 
-    public <T extends LoadingLimits> List<LfLimit> getLimits1(LimitType type, Supplier<Optional<T>> loadingLimitsSupplier, LimitReductionManager limitReductionManager) {
-        var limits = getLimits1(type);
+    private <T extends LoadingLimits> List<LfLimitsGroup> createLimits(Supplier<Map<String, T>> loadingLimitsSupplier, LimitReductionManager limitReductionManager, TwoSides side) {
+        // It is possible to apply the reductions here since the only supported ContingencyContext for LimitReduction is ALL.
+        Map<String, T> allSelectedLoadingLimits = loadingLimitsSupplier.get(); // Map of all selected loading limits indexed by their operational limits group id
+        List<LfLimitsGroup> limits = new ArrayList<>();
+        for (Map.Entry<String, T> loadingLimitsEntry : allSelectedLoadingLimits.entrySet()) {
+            T loadingLimits = loadingLimitsEntry.getValue();
+            String operationalLimitsGroupId = loadingLimitsEntry.getKey();
+            limits.add(LfLimitsGroup.createSortedLimitsList(loadingLimits,
+                    operationalLimitsGroupId,
+                    side == TwoSides.ONE ? bus1 : bus2,
+                    getLimitReductions(side, limitReductionManager, loadingLimits)));
+        }
+        return limits;
+    }
+
+    public <T extends LoadingLimits> List<LfLimitsGroup> getLimits1(LimitType type, Supplier<Map<String, T>> loadingLimitsSupplier, LimitReductionManager limitReductionManager) {
+        List<LfLimitsGroup> limits = getLimits1(type);
         if (limits == null) {
-            // It is possible to apply the reductions here since the only supported ContingencyContext for LimitReduction is ALL.
-            var loadingLimits = loadingLimitsSupplier.get().orElse(null);
-            limits = createSortedLimitsList(loadingLimits, bus1,
-                    getLimitReductions(TwoSides.ONE, limitReductionManager, loadingLimits));
+            limits = createLimits(loadingLimitsSupplier, limitReductionManager, TwoSides.ONE);
             setLimits1(type, limits);
         }
         return limits;
     }
 
-    private List<LfLimit> getLimits2(LimitType type) {
+    private List<LfLimitsGroup> getLimits2(LimitType type) {
         switch (type) {
             case ACTIVE_POWER -> {
                 return activePowerLimits2;
@@ -194,7 +169,7 @@ private List<LfLimit> getLimits2(LimitType type) {
         }
     }
 
-    private void setLimits2(LimitType type, List<LfLimit> limits) {
+    private void setLimits2(LimitType type, List<LfLimitsGroup> limits) {
         switch (type) {
             case ACTIVE_POWER -> activePowerLimits2 = limits;
             case APPARENT_POWER -> apparentPowerLimits2 = limits;
@@ -203,13 +178,10 @@ private void setLimits2(LimitType type, List<LfLimit> limits) {
         }
     }
 
-    public <T extends LoadingLimits> List<LfLimit> getLimits2(LimitType type, Supplier<Optional<T>> loadingLimitsSupplier, LimitReductionManager limitReductionManager) {
+    public <T extends LoadingLimits> List<LfLimitsGroup> getLimits2(LimitType type, Supplier<Map<String, T>> loadingLimitsSupplier, LimitReductionManager limitReductionManager) {
         var limits = getLimits2(type);
         if (limits == null) {
-            // It is possible to apply the reductions here since the only supported ContingencyContext for LimitReduction is ALL.
-            var loadingLimits = loadingLimitsSupplier.get().orElse(null);
-            limits = createSortedLimitsList(loadingLimits, bus2,
-                    getLimitReductions(TwoSides.TWO, limitReductionManager, loadingLimits));
+            limits = createLimits(loadingLimitsSupplier, limitReductionManager, TwoSides.TWO);
             setLimits2(type, limits);
         }
         return limits;
@@ -264,19 +236,6 @@ protected void updateSolvedTapPosition(RatioTapChanger rtc, double ptcRho, doubl
         Transformers.findTapPosition(rtc, ptcRho, rho).ifPresent(rtc::setSolvedTapPosition);
     }
 
-    protected static double getScaleForLimitType(LimitType type, LfBus bus) {
-        switch (type) {
-            case ACTIVE_POWER,
-                 APPARENT_POWER:
-                return 1.0 / PerUnit.SB;
-            case CURRENT:
-                return 1.0 / PerUnit.ib(bus.getNominalV());
-            case VOLTAGE:
-            default:
-                throw new UnsupportedOperationException(String.format("Getting scale for limit type %s is not supported.", type));
-        }
-    }
-
     @Override
     public Optional<TransformerVoltageControl> getVoltageControl() {
         return Optional.ofNullable(voltageControl);

src/main/java/com/powsybl/openloadflow/network/impl/LfBoundaryLineBranch.java

@@ -7,10 +7,7 @@
  */
 package com.powsybl.openloadflow.network.impl;
 
-import com.powsybl.iidm.network.BoundaryLine;
-import com.powsybl.iidm.network.LimitType;
-import com.powsybl.iidm.network.LoadingLimits;
-import com.powsybl.iidm.network.TwoSides;
+import com.powsybl.iidm.network.*;
 import com.powsybl.openloadflow.network.*;
 import com.powsybl.openloadflow.sa.LimitReductionManager;
 import com.powsybl.openloadflow.util.PerUnit;
@@ -19,6 +16,10 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
 
 /**
  * @author Geoffroy Jamgotchian {@literal <geoffroy.jamgotchian at rte-france.com>}
@@ -80,15 +81,23 @@ public List<BranchResult> createBranchResult(double preContingencyBranchP1, doub
         return List.of(buildBranchResult(loadFlowModel, zeroImpedanceFlows, currentScale, currentScale, Double.NaN, Double.NaN));
     }
 
+    private <T extends LoadingLimits> Supplier<Map<String, T>> toMapIndexedByOperationalLimitsGroupId(Function<OperationalLimitsGroup, Optional<T>> limitsGetter) {
+        return () -> getBoundaryLine()
+                .getAllSelectedOperationalLimitsGroups()
+                .stream()
+                .filter(o -> limitsGetter.apply(o).isPresent())
+                .collect(Collectors.toMap(OperationalLimitsGroup::getId, o -> limitsGetter.apply(o).orElseThrow()));
+    }
+
     @Override
-    public List<LfLimit> getLimits1(final LimitType type, LimitReductionManager limitReductionManager) {
+    public List<LfLimitsGroup> getLimits1(final LimitType type, LimitReductionManager limitReductionManager) {
         switch (type) {
             case ACTIVE_POWER:
-                return getLimits1(type, () -> getBoundaryLine().getActivePowerLimits(), limitReductionManager);
+                return getLimits1(type, toMapIndexedByOperationalLimitsGroupId(OperationalLimitsGroup::getActivePowerLimits), limitReductionManager);
             case APPARENT_POWER:
-                return getLimits1(type, () -> getBoundaryLine().getApparentPowerLimits(), limitReductionManager);
+                return getLimits1(type, toMapIndexedByOperationalLimitsGroupId(OperationalLimitsGroup::getApparentPowerLimits), limitReductionManager);
             case CURRENT:
-                return getLimits1(type, () -> getBoundaryLine().getCurrentLimits(), limitReductionManager);
+                return getLimits1(type, toMapIndexedByOperationalLimitsGroupId(OperationalLimitsGroup::getCurrentLimits), limitReductionManager);
             case VOLTAGE:
             default:
                 throw new UnsupportedOperationException(String.format("Getting %s limits is not supported.", type.name()));

src/main/java/com/powsybl/openloadflow/network/impl/LfBranchImpl.java

@@ -18,6 +18,9 @@
 import org.slf4j.LoggerFactory;
 
 import java.util.*;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
 
 /**
  * @author Geoffroy Jamgotchian {@literal <geoffroy.jamgotchian at rte-france.com>}
@@ -228,30 +231,38 @@ public List<BranchResult> createBranchResult(double preContingencyBranchP1, doub
         return List.of(branchResult);
     }
 
+    private <T extends LoadingLimits> Supplier<Map<String, T>> toMapIndexedByOperationalLimitsGroupId(Function<OperationalLimitsGroup, Optional<T>> limitsGetter, TwoSides side) {
+        return () -> getBranch()
+                .getAllSelectedOperationalLimitsGroups(side)
+                .stream()
+                .filter(o -> limitsGetter.apply(o).isPresent())
+                .collect(Collectors.toMap(OperationalLimitsGroup::getId, o -> limitsGetter.apply(o).orElseThrow()));
+    }
+
     @Override
-    public List<LfLimit> getLimits1(final LimitType type, LimitReductionManager limitReductionManager) {
+    public List<LfLimitsGroup> getLimits1(final LimitType type, LimitReductionManager limitReductionManager) {
         switch (type) {
             case ACTIVE_POWER:
-                return getLimits1(type, () -> getBranch().getActivePowerLimits1(), limitReductionManager);
+                return getLimits1(type, toMapIndexedByOperationalLimitsGroupId(OperationalLimitsGroup::getActivePowerLimits, TwoSides.ONE), limitReductionManager);
             case APPARENT_POWER:
-                return getLimits1(type, () -> getBranch().getApparentPowerLimits1(), limitReductionManager);
+                return getLimits1(type, toMapIndexedByOperationalLimitsGroupId(OperationalLimitsGroup::getApparentPowerLimits, TwoSides.ONE), limitReductionManager);
             case CURRENT:
-                return getLimits1(type, () -> getBranch().getCurrentLimits1(), limitReductionManager);
+                return getLimits1(type, toMapIndexedByOperationalLimitsGroupId(OperationalLimitsGroup::getCurrentLimits, TwoSides.ONE), limitReductionManager);
             case VOLTAGE:
             default:
                 throw new UnsupportedOperationException(String.format("Getting %s limits is not supported.", type.name()));
         }
     }
 
     @Override
-    public List<LfLimit> getLimits2(final LimitType type, LimitReductionManager limitReductionManager) {
+    public List<LfLimitsGroup> getLimits2(final LimitType type, LimitReductionManager limitReductionManager) {
         switch (type) {
             case ACTIVE_POWER:
-                return getLimits2(type, () -> getBranch().getActivePowerLimits2(), limitReductionManager);
+                return getLimits2(type, toMapIndexedByOperationalLimitsGroupId(OperationalLimitsGroup::getActivePowerLimits, TwoSides.TWO), limitReductionManager);
             case APPARENT_POWER:
-                return getLimits2(type, () -> getBranch().getApparentPowerLimits2(), limitReductionManager);
+                return getLimits2(type, toMapIndexedByOperationalLimitsGroupId(OperationalLimitsGroup::getApparentPowerLimits, TwoSides.TWO), limitReductionManager);
             case CURRENT:
-                return getLimits2(type, () -> getBranch().getCurrentLimits2(), limitReductionManager);
+                return getLimits2(type, toMapIndexedByOperationalLimitsGroupId(OperationalLimitsGroup::getCurrentLimits, TwoSides.TWO), limitReductionManager);
             case VOLTAGE:
             default:
                 throw new UnsupportedOperationException(String.format("Getting %s limits is not supported.", type.name()));