Fix limits handling in slack distribution on generators

src/main/java/com/powsybl/openloadflow/ac/outerloop/DistributedSlackOuterLoop.java

@@ -56,7 +56,8 @@ public void initialize(AcOuterLoopContext context) {
     @Override
     public OuterLoopResult check(AcOuterLoopContext context, ReportNode reportNode) {
         double slackBusActivePowerMismatch = context.getLastSolverResult().getSlackBusActivePowerMismatch();
-        boolean shouldDistributeSlack = Math.abs(slackBusActivePowerMismatch) > slackBusPMaxMismatch / PerUnit.SB;
+        double absMismatch = Math.abs(slackBusActivePowerMismatch);
+        boolean shouldDistributeSlack = absMismatch > slackBusPMaxMismatch / PerUnit.SB && absMismatch > ActivePowerDistribution.P_RESIDUE_EPS;
 
         if (!shouldDistributeSlack) {
             LOGGER.debug("Already balanced");

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

@@ -18,6 +18,7 @@
 public class BusDcState extends ElementState<LfBus> {
 
     private final Map<String, Double> generatorsTargetP;
+    private final Map<String, Double> generatorsInitialTargetP;
     private final Map<String, Boolean> participatingGenerators;
     private final Map<String, Boolean> disablingStatusGenerators;
     private final List<LoadDcState> loadStates;
@@ -45,6 +46,7 @@ protected void restore(LfLoad load) {
     public BusDcState(LfBus bus) {
         super(bus);
         this.generatorsTargetP = bus.getGenerators().stream().collect(Collectors.toMap(LfGenerator::getId, LfGenerator::getTargetP));
+        this.generatorsInitialTargetP = bus.getGenerators().stream().collect(Collectors.toMap(LfGenerator::getId, LfGenerator::getInitialTargetP));
         this.participatingGenerators = bus.getGenerators().stream().collect(Collectors.toMap(LfGenerator::getId, LfGenerator::isParticipating));
         this.disablingStatusGenerators = bus.getGenerators().stream().collect(Collectors.toMap(LfGenerator::getId, LfGenerator::isDisabled));
         loadStates = bus.getLoads().stream().map(load -> createLoadState().save(load)).toList();
@@ -58,6 +60,7 @@ protected LoadDcState createLoadState() {
     public void restore() {
         super.restore();
         element.getGenerators().forEach(g -> g.setTargetP(generatorsTargetP.get(g.getId())));
+        element.getGenerators().forEach(g -> g.setInitialTargetP(generatorsInitialTargetP.get(g.getId())));
         element.getGenerators().forEach(g -> g.setParticipating(participatingGenerators.get(g.getId())));
         element.getGenerators().forEach(g -> g.setDisabled(disablingStatusGenerators.get(g.getId())));
         for (int i = 0; i < loadStates.size(); i++) {

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

@@ -334,6 +334,7 @@ private void applyGeneratorChange(LfNetworkParameters networkParameters) {
         if (!generator.isDisabled()) {
             double newTargetP = generatorChange.isRelative() ? generator.getTargetP() + generatorChange.activePowerValue() : generatorChange.activePowerValue();
             generator.setTargetP(newTargetP);
+            generator.setInitialTargetP(newTargetP);
             if (!AbstractLfGenerator.checkActivePowerControl(generator.getId(), generator.getTargetP(), generator.getMinP(), generator.getMaxP(),
                     networkParameters.getPlausibleActivePowerLimit(), networkParameters.isUseActiveLimits(), null)) {
                 generator.setParticipating(false);

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

@@ -15,7 +15,6 @@
 import java.io.UncheckedIOException;
 import java.io.Writer;
 import java.util.*;
-import java.util.stream.Collectors;
 
 /**
  * @author Geoffroy Jamgotchian {@literal <geoffroy.jamgotchian at rte-france.com>}
@@ -61,8 +60,8 @@ public LfContingency(String id, int index, int createdSynchronousComponentsCount
         for (LfBus bus : disabledNetwork.getBuses()) {
             disconnectedLoadActivePower += bus.getLoadTargetP();
             disconnectedGenerationActivePower += bus.getGenerationTargetP();
-            disconnectedElementIds.addAll(bus.getGenerators().stream().map(LfGenerator::getId).collect(Collectors.toList()));
-            disconnectedElementIds.addAll(bus.getLoads().stream().flatMap(l -> l.getOriginalIds().stream()).collect(Collectors.toList()));
+            disconnectedElementIds.addAll(bus.getGenerators().stream().map(LfGenerator::getId).toList());
+            disconnectedElementIds.addAll(bus.getLoads().stream().flatMap(l -> l.getOriginalIds().stream()).toList());
             bus.getControllerShunt().ifPresent(shunt -> disconnectedElementIds.addAll(shunt.getOriginalIds()));
             bus.getShunt().ifPresent(shunt -> disconnectedElementIds.addAll(shunt.getOriginalIds()));
         }
@@ -75,7 +74,7 @@ public LfContingency(String id, int index, int createdSynchronousComponentsCount
             disconnectedGenerationActivePower += generator.getTargetP();
             disconnectedElementIds.add(generator.getOriginalId());
         }
-        disconnectedElementIds.addAll(disabledNetwork.getBranches().stream().map(LfBranch::getId).collect(Collectors.toList()));
+        disconnectedElementIds.addAll(disabledNetwork.getBranches().stream().map(LfBranch::getId).toList());
         // FIXME: shuntsShift has to be included in the disconnected elements.
     }
 
@@ -156,14 +155,15 @@ public void apply(LoadFlowParameters.BalanceType balanceType) {
         Set<LfBus> generatorBuses = new HashSet<>();
         for (LfGenerator generator : lostGenerators) {
             generator.setTargetP(0);
+            generator.setInitialTargetP(0);
             LfBus bus = generator.getBus();
             generatorBuses.add(bus);
             generator.setParticipating(false);
             generator.setDisabled(true);
             if (generator.getGeneratorControlType() != LfGenerator.GeneratorControlType.OFF) {
                 generator.setGeneratorControlType(LfGenerator.GeneratorControlType.OFF);
-                bus.getGeneratorVoltageControl().ifPresent(vc -> vc.updateReactiveKeys());
-                bus.getGeneratorReactivePowerControl().ifPresent(rc -> rc.updateReactiveKeys());
+                bus.getGeneratorVoltageControl().ifPresent(GeneratorVoltageControl::updateReactiveKeys);
+                bus.getGeneratorReactivePowerControl().ifPresent(GeneratorReactivePowerControl::updateReactiveKeys);
             } else {
                 bus.setGenerationTargetQ(bus.getGenerationTargetQ() - generator.getTargetQ());
             }

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

@@ -64,6 +64,10 @@ static double qToK(LfGenerator generator, double q) {
 
     double getInitialTargetP();
 
+    void setInitialTargetP(double initialTargetP);
+
+    void setInitialTargetPToTargetP();
+
     double getTargetP();
 
     void setTargetP(double targetP);

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

@@ -43,6 +43,7 @@ protected NetworkState(LfNetwork network, List<BusState> busStates, List<BranchS
     public static NetworkState save(LfNetwork network) {
         Objects.requireNonNull(network);
         LOGGER.trace("Saving network state");
+        network.getBuses().stream().flatMap(b -> b.getGenerators().stream()).forEach(LfGenerator::setInitialTargetPToTargetP);
         List<BusState> busStates = ElementState.save(network.getBuses(), BusState::save);
         List<BranchState> branchStates = ElementState.save(network.getBranches(), BranchState::save);
         List<HvdcState> hvdcStates = ElementState.save(network.getHvdcs(), HvdcState::save);

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

@@ -27,6 +27,14 @@ public double getInitialTargetP() {
         return initialTargetP;
     }
 
+    public void setInitialTargetP(double initialTargetP) {
+        this.initialTargetP = initialTargetP;
+    }
+
+    public void setInitialTargetPToTargetP() {
+        initialTargetP = targetP;
+    }
+
     public double getTargetP() {
         return targetP;
     }

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

@@ -73,6 +73,16 @@ public double getTargetP() {
         }
     }
 
+    @Override
+    public void setInitialTargetP(double initialTargetP) {
+        // no-op
+    }
+
+    @Override
+    public void setInitialTargetPToTargetP() {
+        // no-op
+    }
+
     @Override
     public double getLossFactor() {
         return lossFactor;

src/main/java/com/powsybl/openloadflow/network/util/ActivePowerDistribution.java

@@ -13,7 +13,10 @@
 
 import java.util.Collection;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 /**
  * @author Geoffroy Jamgotchian {@literal <geoffroy.jamgotchian at rte-france.com>}
@@ -25,15 +28,13 @@ public final class ActivePowerDistribution {
      */
     public static final double P_RESIDUE_EPS = Math.pow(10, -5);
 
-    public record StepResult(double done, boolean movedBuses) { }
-
     public interface Step {
 
         String getElementType();
 
         List<ParticipatingElement> getParticipatingElements(Collection<LfBus> buses);
 
-        StepResult run(List<ParticipatingElement> participatingElements, int iteration, double remainingMismatch);
+        double run(List<ParticipatingElement> participatingElements, int iteration, double remainingMismatch);
     }
 
     public record Result(int iteration, double remainingMismatch, boolean movedBuses) { }
@@ -54,25 +55,26 @@ public Result run(LfNetwork network, double activePowerMismatch) {
 
     public Result run(Collection<LfBus> buses, double activePowerMismatch) {
         List<ParticipatingElement> participatingElements = step.getParticipatingElements(buses);
+        final Map<ParticipatingElement, Double> initialP = participatingElements.stream()
+                .collect(Collectors.toUnmodifiableMap(Function.identity(), ParticipatingElement::getTargetP));
 
         int iteration = 0;
         double remainingMismatch = activePowerMismatch;
-        boolean movedBuses = false;
         while (!participatingElements.isEmpty()
                 && Math.abs(remainingMismatch) > P_RESIDUE_EPS) {
 
             if (ParticipatingElement.participationFactorNorm(participatingElements) > 0.0) {
-                StepResult stepResult = step.run(participatingElements, iteration, remainingMismatch);
-                remainingMismatch -= stepResult.done();
-                if (stepResult.movedBuses()) {
-                    movedBuses = true;
-                }
+                double done = step.run(participatingElements, iteration, remainingMismatch);
+                remainingMismatch -= done;
             } else {
                 break;
             }
             iteration++;
         }
 
+        final boolean movedBuses = initialP.entrySet().stream()
+                .anyMatch(e -> Math.abs(e.getKey().getTargetP() - e.getValue()) > P_RESIDUE_EPS);
+
         return new Result(iteration, remainingMismatch, movedBuses);
     }
 

src/main/java/com/powsybl/openloadflow/network/util/GenerationActivePowerDistributionStep.java

@@ -16,6 +16,7 @@
 
 import java.util.Collection;
 import java.util.Iterator;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -55,16 +56,27 @@ public List<ParticipatingElement> getParticipatingElements(Collection<LfBus> bus
                 .flatMap(bus -> bus.getGenerators().stream())
                 .filter(generator -> isParticipating(generator) && getParticipationFactor(generator) != 0)
                 .map(generator -> new ParticipatingElement(generator, getParticipationFactor(generator)))
-                .collect(Collectors.toList());
+                .collect(Collectors.toCollection(LinkedList::new));
     }
 
     @Override
-    public ActivePowerDistribution.StepResult run(List<ParticipatingElement> participatingElements, int iteration, double remainingMismatch) {
+    public double run(List<ParticipatingElement> participatingElements, int iteration, double remainingMismatch) {
         // normalize participation factors at each iteration start as some
         // generators might have reach a limit and have been discarded
         ParticipatingElement.normalizeParticipationFactors(participatingElements);
 
         double done = 0d;
+        double mismatch = remainingMismatch;
+        if (iteration == 0) {
+            // "undo" everything from targetP to go back to initialP
+            for (ParticipatingElement participatingGenerator : participatingElements) {
+                LfGenerator generator = (LfGenerator) participatingGenerator.getElement();
+                done += generator.getInitialTargetP() - generator.getTargetP();
+                mismatch -= generator.getInitialTargetP() - generator.getTargetP();
+                generator.setTargetP(generator.getInitialTargetP());
+            }
+        }
+
         int modifiedBuses = 0;
         int generatorsAtMax = 0;
         int generatorsAtMin = 0;
@@ -85,12 +97,12 @@ public ActivePowerDistribution.StepResult run(List<ParticipatingElement> partici
                 minP = Math.max(minP, 0);
             }
 
-            double newTargetP = targetP + remainingMismatch * factor;
-            if (remainingMismatch > 0 && newTargetP > maxP) {
+            double newTargetP = targetP + mismatch * factor;
+            if (mismatch > 0 && newTargetP > maxP) {
                 newTargetP = maxP;
                 generatorsAtMax++;
                 it.remove();
-            } else if (remainingMismatch < 0 && newTargetP < minP) {
+            } else if (mismatch < 0 && newTargetP < minP) {
                 newTargetP = minP;
                 generatorsAtMin++;
                 it.remove();
@@ -106,10 +118,10 @@ public ActivePowerDistribution.StepResult run(List<ParticipatingElement> partici
         }
 
         LOGGER.debug("{} MW / {} MW distributed at iteration {} to {} generators ({} at max power, {} at min power)",
-                done * PerUnit.SB, remainingMismatch * PerUnit.SB, iteration, modifiedBuses,
+                done * PerUnit.SB, mismatch * PerUnit.SB, iteration, modifiedBuses,
                 generatorsAtMax, generatorsAtMin);
 
-        return new ActivePowerDistribution.StepResult(done, modifiedBuses != 0);
+        return done;
     }
 
     private double getParticipationFactor(LfGenerator generator) {

src/main/java/com/powsybl/openloadflow/network/util/LoadActivePowerDistributionStep.java

@@ -15,6 +15,7 @@
 
 import java.util.Collection;
 import java.util.Iterator;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -42,15 +43,15 @@ public List<ParticipatingElement> getParticipatingElements(Collection<LfBus> bus
                 .filter(bus -> bus.isParticipating() && !bus.isDisabled() && !bus.isFictitious())
                 .flatMap(bus -> bus.getLoads().stream())
                 .map(load -> new ParticipatingElement(load, getParticipationFactor(load)))
-                .collect(Collectors.toList());
+                .collect(Collectors.toCollection(LinkedList::new));
     }
 
     private double getParticipationFactor(LfLoad load) {
         return load.getAbsVariableTargetP();
     }
 
     @Override
-    public ActivePowerDistribution.StepResult run(List<ParticipatingElement> participatingElements, int iteration, double remainingMismatch) {
+    public double run(List<ParticipatingElement> participatingElements, int iteration, double remainingMismatch) {
         // normalize participation factors at each iteration start as some
         // loads might have reach zero and have been discarded.
         ParticipatingElement.normalizeParticipationFactors(participatingElements);
@@ -84,7 +85,7 @@ public ActivePowerDistribution.StepResult run(List<ParticipatingElement> partici
         LOGGER.debug("{} MW / {} MW distributed at iteration {} to {} buses ({} at min consumption)",
                 -done * PerUnit.SB, -remainingMismatch * PerUnit.SB, iteration, modifiedBuses, loadsAtMin);
 
-        return new ActivePowerDistribution.StepResult(done, modifiedBuses != 0);
+        return done;
     }
 
     private static void ensurePowerFactorConstant(LfLoad load, double newLoadTargetP) {

src/main/java/com/powsybl/openloadflow/network/util/ParticipatingElement.java

@@ -35,6 +35,16 @@ public double getFactor() {
         return factor;
     }
 
+    public double getTargetP() {
+        if (element instanceof LfGenerator generator) {
+            return generator.getTargetP();
+        } else if (element instanceof LfLoad load) {
+            return load.getTargetP();
+        } else {
+            return Double.NaN;
+        }
+    }
+
     public static double participationFactorNorm(List<ParticipatingElement> participatingElements) {
         return participatingElements.stream()
                 .mapToDouble(participatingGenerator -> participatingGenerator.factor)