Multiple scaling modifications

iidm/iidm-modification/src/main/java/com/powsybl/iidm/modification/scalable/GeneratorScalable.java

@@ -154,4 +154,11 @@ public double scale(Network n, double asked, ScalingParameters parameters) {
 
         return done;
     }
+
+    double availablePowerInPercentageOfAsked(Network network, double asked, double scalingPercentage) {
+        var generator = network.getGenerator(id);
+        var availablePower = generator.getMaxP() - generator.getTargetP();
+        var askedPower = asked * scalingPercentage / 100;
+        return askedPower > availablePower ? availablePower / askedPower : 100.0;
+    }
 }

iidm/iidm-modification/src/main/java/com/powsybl/iidm/modification/scalable/ProportionalScalable.java

@@ -8,11 +8,12 @@
 
 import com.powsybl.iidm.network.Network;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Objects;
-import java.util.stream.Collectors;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static com.powsybl.iidm.modification.scalable.ScalingParameters.DistributionMode.STACKING_UP;
+import static com.powsybl.iidm.modification.scalable.ScalingParameters.Priority.VENTILATION;
+import static com.powsybl.iidm.modification.scalable.ScalingParameters.Priority.VOLUME;
 
 /**
  * Scalable that divides scale proportionally between multiple scalable.
@@ -23,12 +24,12 @@
 class ProportionalScalable extends AbstractCompoundScalable {
     private static final double EPSILON = 1e-2;
 
-    private static final class ScalablePercentage {
+    static final class ScalablePercentage {
         private final Scalable scalable;
         private final float percentage;
         private double iterationPercentage;
 
-        private ScalablePercentage(Scalable scalable, float percentage) {
+        ScalablePercentage(Scalable scalable, float percentage) {
             this.scalable = scalable;
             this.percentage = percentage;
             this.iterationPercentage = percentage;
@@ -61,6 +62,11 @@ void setIterationPercentage(double iterationPercentage) {
 
     private final List<ScalablePercentage> scalablePercentageList;
 
+    ProportionalScalable() {
+        // Initialisation if the list
+        this.scalablePercentageList = new ArrayList<>();
+    }
+
     ProportionalScalable(List<Float> percentages, List<Scalable> scalables) {
         checkPercentages(percentages, scalables);
         this.scalablePercentageList = new ArrayList<>();
@@ -70,7 +76,11 @@ void setIterationPercentage(double iterationPercentage) {
     }
 
     Collection<Scalable> getScalables() {
-        return scalablePercentageList.stream().map(ScalablePercentage::getScalable).collect(Collectors.toList());
+        return scalablePercentageList.stream().map(ScalablePercentage::getScalable).toList();
+    }
+
+    List<ScalablePercentage> getScalablePercentageList() {
+        return scalablePercentageList;
     }
 
     private static void checkPercentages(List<Float> percentages, List<Scalable> scalables) {
@@ -128,8 +138,7 @@ private double scaleIteration(Network n, double asked, ScalingParameters paramet
             Scalable s = scalablePercentage.getScalable();
             double iterationPercentage = scalablePercentage.getIterationPercentage();
             double askedOnScalable = iterationPercentage / 100 * asked;
-            double doneOnScalable = 0;
-            doneOnScalable = s.scale(n, askedOnScalable, parameters);
+            double doneOnScalable = s.scale(n, askedOnScalable, parameters);
             if (Math.abs(doneOnScalable - askedOnScalable) > EPSILON) {
                 scalablePercentage.setIterationPercentage(0);
             }
@@ -143,7 +152,7 @@ public double scale(Network n, double asked, ScalingParameters parameters) {
         Objects.requireNonNull(n);
         Objects.requireNonNull(parameters);
         reinitIterationPercentage();
-        if (parameters.isIterative()) {
+        if (parameters.getPriority() == VOLUME) {
             return iterativeScale(n, asked, parameters);
         } else {
             return scaleIteration(n, asked, parameters);
@@ -154,5 +163,25 @@ private void reinitIterationPercentage() {
         scalablePercentageList.forEach(scalablePercentage -> scalablePercentage.setIterationPercentage(scalablePercentage.getPercentage()));
     }
 
+    /**
+     * Compute the power that can be scaled on the network while keeping the ventilation percentages valid.
+     * This method is only used if the distribution is not STACKING_UP and if the scaling priority is VENTILATION.
+     * @param asked power that shall be scaled on the network
+     * @param scalingParameters scaling parameters
+     * @param network network on which the scaling shall be done
+     * @return the effective power value that can be safely scaled while keeping the ventilation percentages valid
+     */
+    double resizeAskedForVentilation(Network network, double asked, ScalingParameters scalingParameters) {
+        if (scalingParameters.getDistributionMode() != STACKING_UP && scalingParameters.getPriority() == VENTILATION) {
+            AtomicReference<Double> resizingPercentage = new AtomicReference<>(1.0);
+            scalablePercentageList.forEach(scalablePercentage ->
+                resizingPercentage.set(Math.min(((GeneratorScalable) scalablePercentage.getScalable()).availablePowerInPercentageOfAsked(network, asked, scalablePercentage.getPercentage()), resizingPercentage.get()))
+            );
+            return asked * resizingPercentage.get();
+        } else {
+            return asked;
+        }
+    }
+
 }