Manage change of applicability on branch modification (#108)

basseche · EtienneLt · web-flow · commit 1db9dfbbd3ef · 2025-10-17T10:36:43.000+02:00
Signed-off-by: basseche &lt;bassel.el-cheikh_externe@rte-france.com&gt;
Signed-off-by: Etienne LESOT &lt;etienne.lesot@rte-france.com&gt;
Co-authored-by: EtienneLt &lt;etienne.lesot@rte-france.com&gt;
diff --git a/src/main/java/org/gridsuite/modification/modifications/AbstractBranchModification.java b/src/main/java/org/gridsuite/modification/modifications/AbstractBranchModification.java
@@ -37,6 +37,7 @@ public abstract class AbstractBranchModification extends AbstractModification {
     private static final String LIMIT_ACCEPTABLE_DURATION = "limitAcceptableDuration";
     private static final String OPERATIONAL_LIMITS_GROUP_NAME = "operationalLimitsGroupName";
     private static final String SIDE = "side";
+    private static final String APPLICABILITY = "applicability";
 
     protected final BranchModificationInfos modificationInfos;
 
@@ -82,6 +83,113 @@ protected void modifyBranch(Branch<?> branch, BranchModificationInfos branchModi
         updateConnections(branch, branchModificationInfos);
     }
 
+    private void copyOperationalLimitsGroup(CurrentLimitsAdder limitsAdder, OperationalLimitsGroup opLimitGroupToCopy) {
+        // Copy all limits of the other side
+        opLimitGroupToCopy.getCurrentLimits().ifPresent(currentLimits -> {
+            limitsAdder.setPermanentLimit(currentLimits.getPermanentLimit());
+
+            for (LoadingLimits.TemporaryLimit tempLimit : currentLimits.getTemporaryLimits()) {
+                addTemporaryLimit(limitsAdder, tempLimit.getName(), tempLimit.getValue(), tempLimit.getAcceptableDuration());
+            }
+            limitsAdder.add();
+        });
+    }
+
+    private void moveLimitSetToTheOtherSide(Branch<?> branch, List<OperationalLimitsGroupModificationInfos> modificationInfos,
+                                            OperationalLimitsGroup limitsGroupToCopy, String modifiedLimitSet,
+                                            boolean isSide1, List<ReportNode> olgReports) {
+        // if we have only one limit set with the same name but applicability is not good
+        // we should copy existing limit set on the right side and removed it from the other side
+        if (modificationInfos.stream().filter(limitSet -> limitSet.getId().equals(modifiedLimitSet)).toList().size() == 1) {
+            // Copy operational limits group to the other side
+            OperationalLimitsGroup limitsGroup = isSide1 ? branch.newOperationalLimitsGroup1(limitsGroupToCopy.getId())
+                : branch.newOperationalLimitsGroup2(limitsGroupToCopy.getId());
+            copyOperationalLimitsGroup(limitsGroup.newCurrentLimits(), limitsGroupToCopy);
+
+            olgReports.add(ReportNode.newRootReportNode().withMessageTemplate("network.modification.applicabilityChanged")
+                    .withUntypedValue(OPERATIONAL_LIMITS_GROUP_NAME, limitsGroupToCopy.getId())
+                    .withUntypedValue(APPLICABILITY, isSide1 ? SIDE1.toString() : SIDE2.toString())
+                    .withSeverity(TypedValue.INFO_SEVERITY)
+                    .build());
+            // Remove copied operational limits group
+            if (isSide1) {
+                branch.removeOperationalLimitsGroup2(modifiedLimitSet);
+            } else {
+                branch.removeOperationalLimitsGroup1(modifiedLimitSet);
+            }
+        }
+    }
+
+    private boolean shouldDeletedOtherSide(Branch<?> branch, List<OperationalLimitsGroupModificationInfos> modificationInfos,
+                                        OperationalLimitsGroupModificationInfos limitsModifInfos) {
+        boolean hasModificationOnSideOne = !modificationInfos.stream().filter(opLimitModifInfo ->
+                opLimitModifInfo.getId().equals(limitsModifInfos.getId()) && opLimitModifInfo.getApplicability().equals(SIDE1))
+            .toList().isEmpty();
+
+        boolean hasModificationOnSideTwo = !modificationInfos.stream().filter(opLimitModifInfo ->
+                opLimitModifInfo.getId().equals(limitsModifInfos.getId()) && opLimitModifInfo.getApplicability().equals(SIDE2))
+            .toList().isEmpty();
+
+        switch (limitsModifInfos.getApplicability()) {
+            case SIDE1 -> {
+                return !hasModificationOnSideTwo && branch.getOperationalLimitsGroup2(limitsModifInfos.getId()).isPresent();
+            }
+            case SIDE2 -> {
+                return !hasModificationOnSideOne && branch.getOperationalLimitsGroup1(limitsModifInfos.getId()).isPresent();
+            }
+            default -> {
+                return false;
+            }
+        }
+    }
+
+    // If we are changing applicability we may not find operational limits group where we should so check both sides
+    private void detectApplicabilityChange(Branch<?> branch, List<OperationalLimitsGroupModificationInfos> modificationInfos,
+                                           OperationalLimitsGroupModificationInfos modifiedLimitSetInfos, List<ReportNode> olgReports) {
+
+        OperationalLimitsGroup limitsGroup1 = branch.getOperationalLimitsGroup1(modifiedLimitSetInfos.getId()).orElse(null);
+        OperationalLimitsGroup limitsGroup2 = branch.getOperationalLimitsGroup2(modifiedLimitSetInfos.getId()).orElse(null);
+        if (limitsGroup1 == null && modifiedLimitSetInfos.getApplicability().equals(SIDE2)
+            || limitsGroup2 == null && modifiedLimitSetInfos.getApplicability().equals(SIDE1)) {
+            return;
+        } else if (limitsGroup1 != null && limitsGroup2 != null && (modifiedLimitSetInfos.getApplicability().equals(SIDE1)
+                || modifiedLimitSetInfos.getApplicability().equals(SIDE2))) {
+            if (shouldDeletedOtherSide(branch, modificationInfos, modifiedLimitSetInfos)) {
+                if (modifiedLimitSetInfos.getApplicability().equals(SIDE1)) {
+                    branch.removeOperationalLimitsGroup2(modifiedLimitSetInfos.getId());
+                } else {
+                    branch.removeOperationalLimitsGroup1(modifiedLimitSetInfos.getId());
+                }
+            }
+            return;
+        }
+
+        switch (modifiedLimitSetInfos.getApplicability()) {
+            case SIDE1 -> moveLimitSetToTheOtherSide(branch, modificationInfos, limitsGroup2, modifiedLimitSetInfos.getId(), true, olgReports);
+            case SIDE2 -> moveLimitSetToTheOtherSide(branch, modificationInfos, limitsGroup1, modifiedLimitSetInfos.getId(), false, olgReports);
+            case EQUIPMENT -> {
+                boolean applicabilityChanged = false;
+                if (limitsGroup1 == null && limitsGroup2 != null) {
+                    limitsGroup1 = branch.newOperationalLimitsGroup1(limitsGroup2.getId());
+                    copyOperationalLimitsGroup(limitsGroup1.newCurrentLimits(), limitsGroup2);
+                    applicabilityChanged = true;
+                }
+                if (limitsGroup2 == null && limitsGroup1 != null) {
+                    limitsGroup2 = branch.newOperationalLimitsGroup2(limitsGroup1.getId());
+                    copyOperationalLimitsGroup(limitsGroup2.newCurrentLimits(), limitsGroup1);
+                    applicabilityChanged = true;
+                }
+                if (applicabilityChanged) {
+                    olgReports.add(ReportNode.newRootReportNode().withMessageTemplate("network.modification.applicabilityChanged")
+                        .withUntypedValue(OPERATIONAL_LIMITS_GROUP_NAME, limitsGroup1.getId())
+                        .withUntypedValue(APPLICABILITY, EQUIPMENT.toString())
+                        .withSeverity(TypedValue.INFO_SEVERITY)
+                        .build());
+                }
+            }
+        }
+    }
+
     private void modifyOperationalLimitsGroups(Branch<?> branch, List<OperationalLimitsGroupModificationInfos> operationalLimitsInfos, List<ReportNode> olgReports) {
         for (OperationalLimitsGroupModificationInfos opLGModifInfos : operationalLimitsInfos) {
             if (opLGModifInfos.getModificationType() == null) {
@@ -90,13 +198,16 @@ private void modifyOperationalLimitsGroups(Branch<?> branch, List<OperationalLim
             OperationalLimitsGroupInfos.Applicability applicability = opLGModifInfos.getApplicability();
             // here the modifications on an applicability EQUIPMENT are separated into two separate applications of both sides
             // because iidm has two separated sets of opLGs on the network object (and for better logs)
+
+            detectApplicabilityChange(branch, operationalLimitsInfos, opLGModifInfos, olgReports);
+
             if (applicability == SIDE1
-                    || applicability == OperationalLimitsGroupInfos.Applicability.EQUIPMENT) {
+                    || applicability == EQUIPMENT) {
                 OperationalLimitsGroup operationalLimitsGroup1 = branch.getOperationalLimitsGroup1(opLGModifInfos.getId()).orElse(null);
                 applyModificationToOperationalLimitsGroup(branch::newOperationalLimitsGroup1, opLGModifInfos, operationalLimitsGroup1, olgReports, SIDE1);
             }
             if (applicability == SIDE2
-                    || applicability == OperationalLimitsGroupInfos.Applicability.EQUIPMENT) {
+                    || applicability == EQUIPMENT) {
                 OperationalLimitsGroup operationalLimitsGroup2 = branch.getOperationalLimitsGroup2(opLGModifInfos.getId()).orElse(null);
                 applyModificationToOperationalLimitsGroup(branch::newOperationalLimitsGroup2, opLGModifInfos, operationalLimitsGroup2, olgReports, SIDE2);
             }
diff --git a/src/main/resources/org/gridsuite/modification/reports.properties b/src/main/resources/org/gridsuite/modification/reports.properties
@@ -184,6 +184,7 @@ network.modification.noLimitSetSelectedOnSide1 = No limit set selected on side 1
 network.modification.noLimitSetSelectedOnSide2 = No limit set selected on side 2
 network.modification.limitSetAbsentOnSide1 = limit set '${selectedOperationalLimitsGroup}' on side 1 does not exist
 network.modification.limitSetAbsentOnSide2 = limit set '${selectedOperationalLimitsGroup}' on side 2 does not exist
+network.modification.applicabilityChanged = limit set ${operationalLimitsGroupName} applicability changed to ${applicability}
 network.modification.limits = Limits
 network.modification.activeLimitsSets = Active limits sets
 network.modification.limitsSets = Limits sets
diff --git a/src/test/java/org/gridsuite/modification/modifications/LineModificationTest.java b/src/test/java/org/gridsuite/modification/modifications/LineModificationTest.java
@@ -7,9 +7,7 @@
 package org.gridsuite.modification.modifications;
 
 import com.fasterxml.jackson.core.type.TypeReference;
-import com.powsybl.iidm.network.Line;
-import com.powsybl.iidm.network.Network;
-import com.powsybl.iidm.network.ThreeSides;
+import com.powsybl.iidm.network.*;
 import com.powsybl.iidm.network.extensions.ConnectablePosition;
 import com.powsybl.iidm.network.extensions.Measurement;
 import com.powsybl.iidm.network.extensions.Measurements;
@@ -20,13 +18,12 @@
 import org.gridsuite.modification.utils.NetworkCreation;
 import org.junit.jupiter.api.Test;
 
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
+import java.util.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.gridsuite.modification.NetworkModificationException.Type.LINE_NOT_FOUND;
+import static org.gridsuite.modification.dto.OperationalLimitsGroupInfos.Applicability.*;
+import static org.gridsuite.modification.dto.OperationalLimitsGroupModificationType.MODIFY_OR_ADD;
 import static org.junit.jupiter.api.Assertions.*;
 
 /**
@@ -163,6 +160,153 @@ void testConnection() {
         changeLineConnectionState(getNetwork().getLine("line1"), true);
     }
 
+    @Test
+    void testApplicabilityChangeFromSide1ToSide2() {
+        Line line = getNetwork().getLine("line1");
+        OperationalLimitsGroup limitsGroup = line.newOperationalLimitsGroup1("NewLimitsGroup1");
+        limitsGroup.newCurrentLimits()
+            .setPermanentLimit(10.0)
+            .beginTemporaryLimit().setName("IT10").setValue(15.0).setAcceptableDuration(600).endTemporaryLimit()
+            .add();
+
+        assertNotNull(line.getOperationalLimitsGroup1("NewLimitsGroup1"));
+        assertTrue(line.getOperationalLimitsGroup2("NewLimitsGroup1").isEmpty());
+
+        // Change from Side 1 -> Side 2
+        OperationalLimitsGroupModificationInfos opLimitsGroupInfos = OperationalLimitsGroupModificationInfos.builder()
+            .id("NewLimitsGroup1").applicability(SIDE2).modificationType(MODIFY_OR_ADD).build();
+        opLimitsGroupInfos.setCurrentLimits(new CurrentLimitsModificationInfos());
+        LineModificationInfos lineModificationInfos = LineModificationInfos.builder()
+            .equipmentId("line1")
+            .enableOLGModification(true)
+            .operationalLimitsGroups(Collections.singletonList(opLimitsGroupInfos)).build();
+
+        lineModificationInfos.toModification().apply(getNetwork());
+        assertTrue(line.getOperationalLimitsGroup1("NewLimitsGroup1").isEmpty());
+        assertNotNull(line.getOperationalLimitsGroup2("NewLimitsGroup1"));
+
+        // Test on the copy of the limit set
+        OperationalLimitsGroup opLimitsGroupOnLine = line.getOperationalLimitsGroup2("NewLimitsGroup1").get();
+        assertTrue(opLimitsGroupOnLine.getCurrentLimits().isPresent());
+        CurrentLimits currentLimits = opLimitsGroupOnLine.getCurrentLimits().get();
+        assertEquals(10.0, currentLimits.getPermanentLimit());
+        assertNotNull(currentLimits.getTemporaryLimit(600));
+        LoadingLimits.TemporaryLimit temporaryLimit = currentLimits.getTemporaryLimit(600);
+        assertEquals(15.0, temporaryLimit.getValue());
+        assertEquals(600, temporaryLimit.getAcceptableDuration());
+        assertEquals("IT10", temporaryLimit.getName());
+    }
+
+    @Test
+    void testApplicabilityChangeFromSide2ToEquipment() {
+        Line line = getNetwork().getLine("line1");
+        // Change from Side 2 -> Equipment
+        line.newOperationalLimitsGroup2("NewLimitsGroup2").newCurrentLimits()
+                .setPermanentLimit(10.0)
+                .beginTemporaryLimit().setName("IT10").setValue(15.0).setAcceptableDuration(600).endTemporaryLimit()
+                .add();
+
+        OperationalLimitsGroupModificationInfos opLimitsGroupInfos2 = OperationalLimitsGroupModificationInfos.builder()
+                .id("NewLimitsGroup2").applicability(EQUIPMENT).modificationType(MODIFY_OR_ADD).build();
+        opLimitsGroupInfos2.setCurrentLimits(new CurrentLimitsModificationInfos());
+
+        LineModificationInfos lineModificationInfos2 = LineModificationInfos.builder()
+                .equipmentId("line1")
+                .enableOLGModification(true)
+                .operationalLimitsGroups(Collections.singletonList(opLimitsGroupInfos2)).build();
+        lineModificationInfos2.toModification().apply(getNetwork());
+
+        lineModificationInfos2.toModification().apply(getNetwork());
+        assertNotNull(line.getOperationalLimitsGroup1("NewLimitsGroup2"));
+        assertNotNull(line.getOperationalLimitsGroup2("NewLimitsGroup2"));
+    }
+
+    @Test
+    void testApplicabilityChangeFromEquipmentToSide2() {
+        Line line = getNetwork().getLine("line1");
+        line.newOperationalLimitsGroup1("NewLimitsGroup3").newCurrentLimits()
+                .setPermanentLimit(10.0)
+                .add();
+        line.newOperationalLimitsGroup2("NewLimitsGroup3").newCurrentLimits()
+                .setPermanentLimit(10.0)
+                .add();
+        OperationalLimitsGroupModificationInfos opLimitsGroupInfos3 = OperationalLimitsGroupModificationInfos.builder()
+                .id("NewLimitsGroup3").applicability(SIDE2).modificationType(MODIFY_OR_ADD).build();
+        opLimitsGroupInfos3.setCurrentLimits(new CurrentLimitsModificationInfos());
+        LineModificationInfos lineModificationInfos3 = LineModificationInfos.builder()
+                .enableOLGModification(true)
+                .equipmentId("line1")
+                .operationalLimitsGroups(Collections.singletonList(opLimitsGroupInfos3)).build();
+
+        lineModificationInfos3.toModification().apply(getNetwork());
+        assertNotNull(line.getOperationalLimitsGroup2("NewLimitsGroup3"));
+        assertTrue(line.getOperationalLimitsGroup1("NewLimitsGroup3").isEmpty());
+    }
+
+    @Test
+    void testApplicabilityChangeFromSide2ToSide1() {
+        Line line = getNetwork().getLine("line1");
+        line.newOperationalLimitsGroup2("NewLimitsGroup4").newCurrentLimits()
+                .setPermanentLimit(10.0)
+                .add();
+        OperationalLimitsGroupModificationInfos opLimitsGroupInfos4 = OperationalLimitsGroupModificationInfos.builder()
+                .id("NewLimitsGroup4").applicability(SIDE2).modificationType(MODIFY_OR_ADD).build();
+        opLimitsGroupInfos4.setCurrentLimits(new CurrentLimitsModificationInfos());
+        LineModificationInfos lineModificationInfos4 = LineModificationInfos.builder()
+                .enableOLGModification(true)
+                .equipmentId("line1")
+                .operationalLimitsGroups(Collections.singletonList(opLimitsGroupInfos4)).build();
+
+        lineModificationInfos4.toModification().apply(getNetwork());
+        assertNotNull(line.getOperationalLimitsGroup1("NewLimitsGroup4"));
+        assertTrue(line.getOperationalLimitsGroup1("NewLimitsGroup4").isEmpty());
+    }
+
+    @Test
+    void testApplicabilityChangeFromSide1ToEquipment() {
+        Line line = getNetwork().getLine("line1");
+        line.newOperationalLimitsGroup1("NewLimitsGroup5").newCurrentLimits()
+                .setPermanentLimit(10.0)
+                .add();
+        OperationalLimitsGroupModificationInfos opLimitsGroupInfos5 = OperationalLimitsGroupModificationInfos.builder()
+                .id("NewLimitsGroup5").applicability(EQUIPMENT).modificationType(MODIFY_OR_ADD).build();
+        opLimitsGroupInfos5.setCurrentLimits(new CurrentLimitsModificationInfos());
+
+        LineModificationInfos lineModificationInfos5 = LineModificationInfos.builder()
+                .equipmentId("line1")
+                .enableOLGModification(true)
+                .operationalLimitsGroups(Collections.singletonList(opLimitsGroupInfos5)).build();
+        lineModificationInfos5.toModification().apply(getNetwork());
+
+        lineModificationInfos5.toModification().apply(getNetwork());
+        assertNotNull(line.getOperationalLimitsGroup1("NewLimitsGroup5"));
+        assertNotNull(line.getOperationalLimitsGroup2("NewLimitsGroup5"));
+    }
+
+    @Test
+    void testApplicabilityChangeFromEquipmentToSide1() {
+        Line line = getNetwork().getLine("line1");
+        line.newOperationalLimitsGroup1("NewLimitsGroup5").newCurrentLimits()
+                .setPermanentLimit(10.0)
+                .add();
+        line.newOperationalLimitsGroup2("NewLimitsGroup5").newCurrentLimits()
+                .setPermanentLimit(10.0)
+                .add();
+        OperationalLimitsGroupModificationInfos opLimitsGroupInfos5 = OperationalLimitsGroupModificationInfos.builder()
+                .id("NewLimitsGroup5").applicability(SIDE1).modificationType(MODIFY_OR_ADD).build();
+        opLimitsGroupInfos5.setCurrentLimits(new CurrentLimitsModificationInfos());
+
+        LineModificationInfos lineModificationInfos5 = LineModificationInfos.builder()
+                .equipmentId("line1")
+                .enableOLGModification(true)
+                .operationalLimitsGroups(Collections.singletonList(opLimitsGroupInfos5)).build();
+        lineModificationInfos5.toModification().apply(getNetwork());
+
+        lineModificationInfos5.toModification().apply(getNetwork());
+        assertNotNull(line.getOperationalLimitsGroup1("NewLimitsGroup5"));
+        assertTrue(line.getOperationalLimitsGroup2("NewLimitsGroup5").isEmpty());
+    }
+
     @Test
     void testConnectWhenNoSwitchesOpened() {
         getNetwork().getSwitch("v3dl1").setOpen(true);
diff --git a/src/test/java/org/gridsuite/modification/modifications/TwoWindingsTransformerModificationTest.java b/src/test/java/org/gridsuite/modification/modifications/TwoWindingsTransformerModificationTest.java
