Avoid slack distribution to fictitious loads

docs/loadflow/parameters.md

@@ -111,6 +111,8 @@ $$
 If `balanceType` equals to `PROPORTIONAL_TO_LOAD`, the power factor remains constant scaling the global $P0$ and $Q0$ of the load.
 If `balanceType` equals to `PROPORTIONAL_TO_CONFORM_LOAD`, the power factor remains constant scaling only the variable parts. Thus, we fully rely on [load detail extension](inv:powsyblcore:*:*:#load-detail-extension).
 
+In both cases, slack is not distributed to fictitious loads. A load can be fictitious by setting its boolean attribute `isFictitious` or by having a `loadType` equal to `LoadType.FICTITIOUS`.
+
 The default value for `loadPowerFactorConstant` property is `false`.
 
 **slackBusPMaxMismatch**  

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

@@ -33,7 +33,7 @@ public final class LfAction {
     private record TapPositionChange(LfBranch branch, int value, boolean isRelative) {
     }
 
-    private record LoadShift(String loadId, LfLoad load, PowerShift powerShift) {
+    private record LoadShift(String loadId, LfLoad lfLoad, PowerShift powerShift) {
     }
 
     private record GeneratorChange(LfGenerator generator, double activePowerValue, boolean isRelative) {
@@ -136,21 +136,9 @@ private static Optional<LfAction> create(LoadAction action, LfNetwork lfNetwork,
         Terminal terminal = load.getTerminal();
         Bus bus = Networks.getBus(terminal, breakers);
         if (bus != null) {
-            double activePowerShift = 0;
-            double reactivePowerShift = 0;
-            OptionalDouble activePowerValue = action.getActivePowerValue();
-            OptionalDouble reactivePowerValue = action.getReactivePowerValue();
-            if (activePowerValue.isPresent()) {
-                activePowerShift = action.isRelativeValue() ? activePowerValue.getAsDouble() : activePowerValue.getAsDouble() - load.getP0();
-            }
-            if (reactivePowerValue.isPresent()) {
-                reactivePowerShift = action.isRelativeValue() ? reactivePowerValue.getAsDouble() : reactivePowerValue.getAsDouble() - load.getQ0();
-            }
-            // In case of a power shift, we suppose that the shift on a load P0 is exactly the same on the variable active power
-            // of P0 that could be described in a LoadDetail extension.
-            PowerShift powerShift = new PowerShift(activePowerShift / PerUnit.SB, activePowerShift / PerUnit.SB, reactivePowerShift / PerUnit.SB);
             LfLoad lfLoad = lfNetwork.getLoadById(load.getId());
             if (lfLoad != null) {
+                PowerShift powerShift = PowerShift.createPowerShift(load, action);
                 return Optional.of(new LfAction(action.getId(), null, null, null, new LoadShift(load.getId(), lfLoad, powerShift), null, null, null));
             }
         }
@@ -318,13 +306,13 @@ private void applyTapPositionChange() {
     }
 
     private void applyLoadShift() {
-        LfLoad load = loadShift.load();
-        if (!load.isOriginalLoadDisabled(loadShift.loadId())) {
+        String loadId = loadShift.loadId();
+        LfLoad lfLoad = loadShift.lfLoad();
+        if (!lfLoad.isOriginalLoadDisabled(loadId)) {
             PowerShift shift = loadShift.powerShift();
-            load.setTargetP(load.getTargetP() + shift.getActive());
-            load.setTargetQ(load.getTargetQ() + shift.getReactive());
-            load.setAbsVariableTargetP(load.getAbsVariableTargetP()
-                    + Math.signum(shift.getActive()) * Math.abs(shift.getVariableActive()));
+            lfLoad.setTargetP(lfLoad.getTargetP() + shift.getActive());
+            lfLoad.setTargetQ(lfLoad.getTargetQ() + shift.getReactive());
+            lfLoad.setAbsVariableTargetP(lfLoad.getAbsVariableTargetP() + Math.signum(shift.getActive()) * Math.abs(shift.getVariableActive()));
         }
     }
 

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

@@ -147,7 +147,7 @@ public void apply(LoadFlowParameters.BalanceType balanceType) {
             LfLoad load = e.getKey();
             LfLostLoad lostLoad = e.getValue();
             PowerShift shift = lostLoad.getPowerShift();
-            load.setTargetP(load.getTargetP() - getUpdatedLoadP0(load, balanceType, shift.getActive(), shift.getVariableActive()));
+            load.setTargetP(load.getTargetP() - getUpdatedLoadP0(load, balanceType, shift.getActive(), shift.getVariableActive(), lostLoad.getNotParticipatingLoadP0()));
             load.setTargetQ(load.getTargetQ() - shift.getReactive());
             load.setAbsVariableTargetP(load.getAbsVariableTargetP() - Math.abs(shift.getVariableActive()));
             lostLoad.getOriginalIds().forEach(loadId -> load.setOriginalLoadDisabled(loadId, true));
@@ -189,16 +189,17 @@ public void apply(LoadFlowParameters.BalanceType balanceType) {
         }
     }
 
-    private static double getUpdatedLoadP0(LfLoad load, LoadFlowParameters.BalanceType balanceType, double initialP0, double initialVariableActivePower) {
+    private static double getUpdatedLoadP0(LfLoad lfLoad, LoadFlowParameters.BalanceType balanceType, double initialP0, double initialVariableActivePower, double notParticipatingLoadP0) {
         double factor = 0;
-        if (load.getOriginalLoadCount() > 0) {
+        double loadVariableTargetP = lfLoad.getAbsVariableTargetP();
+        if (loadVariableTargetP != 0 && lfLoad.getOriginalLoadCount() > 0) {
             if (balanceType == LoadFlowParameters.BalanceType.PROPORTIONAL_TO_LOAD) {
-                factor = Math.abs(initialP0) / load.getAbsVariableTargetP();
+                factor = (Math.abs(initialP0) - Math.abs(notParticipatingLoadP0)) / loadVariableTargetP;
             } else if (balanceType == LoadFlowParameters.BalanceType.PROPORTIONAL_TO_CONFORM_LOAD) {
-                factor = initialVariableActivePower / load.getAbsVariableTargetP();
+                factor = initialVariableActivePower / loadVariableTargetP;
             }
         }
-        return initialP0 + (load.getTargetP() - load.getInitialTargetP()) * factor;
+        return initialP0 + (lfLoad.getTargetP() - lfLoad.getInitialTargetP()) * factor;
     }
 
     public Set<LfBus> getLoadAndGeneratorBuses() {

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

@@ -22,6 +22,8 @@ public interface LfLoad extends PropertyBag {
 
     LfBus getBus();
 
+    boolean isOriginalLoadNotParticipating(String originalId);
+
     Optional<LfLoadModel> getLoadModel();
 
     double getInitialTargetP();
@@ -44,7 +46,7 @@ public interface LfLoad extends PropertyBag {
 
     List<String> getOriginalIds();
 
-    double getOriginalLoadCount();
+    int getOriginalLoadCount();
 
     boolean isOriginalLoadDisabled(String originalId);
 

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

@@ -19,8 +19,8 @@
 public class LfLostLoad {
 
     private final PowerShift powerShift = new PowerShift();
-
     private final Set<String> ids = new LinkedHashSet<>();
+    private double notParticipatingLoadP0 = 0.0;
 
     public PowerShift getPowerShift() {
         return powerShift;
@@ -30,6 +30,22 @@ public Set<String> getOriginalIds() {
         return ids;
     }
 
+    /**
+     * Updates the contribution of loads that do not participate to slack distribution
+     */
+    public void updateNotParticipatingLoadP0(LfLoad load, String originalLoadId, PowerShift powerShift) {
+        if (load.isOriginalLoadNotParticipating(originalLoadId)) {
+            notParticipatingLoadP0 += Math.abs(powerShift.getActive());
+        }
+    }
+
+    /**
+     * Returns the contribution of loads that do not participate to slack distribution
+     */
+    public double getNotParticipatingLoadP0() {
+        return notParticipatingLoadP0;
+    }
+
     @Override
     public String toString() {
         return "LfLostLoad(" +

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

@@ -7,6 +7,11 @@
  */
 package com.powsybl.openloadflow.network;
 
+import com.powsybl.action.LoadAction;
+import com.powsybl.iidm.network.Load;
+import com.powsybl.openloadflow.network.impl.LfLoadImpl;
+import com.powsybl.openloadflow.util.PerUnit;
+
 import java.util.Objects;
 
 /**
@@ -56,4 +61,30 @@ public String toString() {
                 + variableActive + ", "
                 + reactive + ")";
     }
+
+    /**
+     * Returns the power shift for a complete loss of a load
+     */
+    public static PowerShift createPowerShift(Load load, boolean slackDistributionOnConformLoad) {
+        double variableActivePower = Math.abs(LfLoadImpl.getAbsVariableTargetPPerUnit(load, slackDistributionOnConformLoad));
+        return new PowerShift(load.getP0() / PerUnit.SB,
+                variableActivePower,
+                load.getQ0() / PerUnit.SB); // ensurePowerFactorConstant is not supported.
+    }
+
+    /**
+     * Returns the power shift for a load action.
+     */
+    public static PowerShift createPowerShift(Load load, LoadAction loadAction) {
+        double activePowerShift = loadAction.getActivePowerValue().stream().map(a -> loadAction.isRelativeValue() ? a : a - load.getP0()).findAny().orElse(0);
+        double reactivePowerShift = loadAction.getReactivePowerValue().stream().map(r -> loadAction.isRelativeValue() ? r : r - load.getQ0()).findAny().orElse(0);
+
+        // In case of a power shift, we suppose that the shift on a load P0 is exactly the same on the variable active power
+        // of P0 that could be described in a LoadDetail extension.
+        // Note that fictitious loads have a zero variable active power shift.
+        double variableActivePower = LfLoadImpl.isLoadNotParticipating(load) ? 0.0 : activePowerShift;
+        return new PowerShift(activePowerShift / PerUnit.SB,
+                variableActivePower / PerUnit.SB,
+                reactivePowerShift / PerUnit.SB);
+    }
 }

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

@@ -10,6 +10,7 @@
 import com.powsybl.iidm.network.DanglingLine;
 import com.powsybl.iidm.network.LccConverterStation;
 import com.powsybl.iidm.network.Load;
+import com.powsybl.iidm.network.LoadType;
 import com.powsybl.iidm.network.extensions.LoadDetail;
 import com.powsybl.iidm.network.util.HvdcUtils;
 import com.powsybl.openloadflow.network.*;
@@ -29,15 +30,15 @@ public class LfLoadImpl extends AbstractLfInjection implements LfLoad {
 
     private final LfLoadModel loadModel;
 
-    private final List<Ref<Load>> loadsRefs = new ArrayList<>();
+    private final Map<String, Ref<Load>> loadsRefs = new HashMap<>();
 
     private final List<Ref<LccConverterStation>> lccCsRefs = new ArrayList<>();
 
     private double targetQ = 0;
 
     private boolean ensurePowerFactorConstantByLoad = false;
 
-    private final List<Double> loadsAbsVariableTargetP = new ArrayList<>();
+    private final HashMap<String, Double> loadsAbsVariableTargetP = new HashMap<>();
 
     private double absVariableTargetP = 0;
 
@@ -63,7 +64,7 @@ public String getId() {
 
     @Override
     public List<String> getOriginalIds() {
-        return Stream.concat(loadsRefs.stream().map(r -> r.get().getId()),
+        return Stream.concat(loadsRefs.values().stream().map(r -> r.get().getId()),
                              lccCsRefs.stream().map(r -> r.get().getId()))
                 .toList();
     }
@@ -73,13 +74,21 @@ public LfBus getBus() {
         return bus;
     }
 
+    @Override
+    public boolean isOriginalLoadNotParticipating(String originalLoadId) {
+        if (loadsRefs.get(originalLoadId) == null) {
+            return false;
+        }
+        return isLoadNotParticipating(loadsRefs.get(originalLoadId).get());
+    }
+
     @Override
     public Optional<LfLoadModel> getLoadModel() {
         return Optional.ofNullable(loadModel);
     }
 
     void add(Load load, LfNetworkParameters parameters) {
-        loadsRefs.add(Ref.create(load, parameters.isCacheEnabled()));
+        loadsRefs.put(load.getId(), Ref.create(load, parameters.isCacheEnabled()));
         loadsDisablingStatus.put(load.getId(), false);
         double p0 = load.getP0();
         double q0 = load.getQ0();
@@ -97,8 +106,8 @@ void add(Load load, LfNetworkParameters parameters) {
         if (p0 < 0 || hasVariableActivePower || reactiveOnlyLoad) {
             ensurePowerFactorConstantByLoad = true;
         }
-        double absTargetP = getAbsVariableTargetP(load);
-        loadsAbsVariableTargetP.add(absTargetP);
+        double absTargetP = getAbsVariableTargetPPerUnit(load, distributedOnConformLoad);
+        loadsAbsVariableTargetP.put(load.getId(), absTargetP);
         absVariableTargetP += absTargetP;
     }
 
@@ -158,7 +167,10 @@ public void setAbsVariableTargetP(double absVariableTargetP) {
         this.absVariableTargetP = absVariableTargetP;
     }
 
-    private double getAbsVariableTargetP(Load load) {
+    public static double getAbsVariableTargetPPerUnit(Load load, boolean distributedOnConformLoad) {
+        if (isLoadNotParticipating(load)) {
+            return 0.0;
+        }
         double varP;
         if (distributedOnConformLoad) {
             varP = load.getExtension(LoadDetail.class) == null ? 0 : load.getExtension(LoadDetail.class).getVariableActivePower();
@@ -169,17 +181,17 @@ private double getAbsVariableTargetP(Load load) {
     }
 
     @Override
-    public double getOriginalLoadCount() {
+    public int getOriginalLoadCount() {
         return loadsRefs.size();
     }
 
-    private double getParticipationFactor(int i) {
+    private double getParticipationFactor(String originalLoadId) {
         // FIXME
         // After a load contingency or a load action, only the global variable targetP is updated.
         // The list loadsAbsVariableTargetP never changes. It is not an issue for security analysis as the network is
         // never updated. Excepted if loadPowerFactorConstant is true, the new targetQ could be wrong after a load contingency
         // or a load action.
-        return absVariableTargetP != 0 ? loadsAbsVariableTargetP.get(i) / absVariableTargetP : 0;
+        return absVariableTargetP != 0 ? loadsAbsVariableTargetP.get(originalLoadId) / absVariableTargetP : 0;
     }
 
     private double calculateP() {
@@ -199,9 +211,9 @@ public void updateState(boolean loadPowerFactorConstant, boolean breakers) {
         double pv = p == EvaluableConstants.NAN ? 1 : calculateP() / targetP; // extract part of p that is dependent to voltage
         double qv = q == EvaluableConstants.NAN ? 1 : calculateQ() / targetQ;
         double diffLoadTargetP = targetP - initialTargetP;
-        for (int i = 0; i < loadsRefs.size(); i++) {
-            Load load = loadsRefs.get(i).get();
-            double diffP0 = diffLoadTargetP * getParticipationFactor(i) * PerUnit.SB;
+        for (Ref<Load> refLoad : loadsRefs.values()) {
+            Load load = refLoad.get();
+            double diffP0 = diffLoadTargetP * getParticipationFactor(load.getId()) * PerUnit.SB;
             double updatedP0 = load.getP0() + diffP0;
             double updatedQ0 = load.getQ0() + (loadPowerFactorConstant ? getPowerFactor(load) * diffP0 : 0.0);
             load.getTerminal()
@@ -223,9 +235,9 @@ public void updateState(boolean loadPowerFactorConstant, boolean breakers) {
     @Override
     public double calculateNewTargetQ(double diffTargetP) {
         double newLoadTargetQ = 0;
-        for (int i = 0; i < loadsRefs.size(); i++) {
-            Load load = loadsRefs.get(i).get();
-            double updatedQ0 = load.getQ0() / PerUnit.SB + getPowerFactor(load) * diffTargetP * getParticipationFactor(i);
+        for (Ref<Load> refLoad : loadsRefs.values()) {
+            Load load = refLoad.get();
+            double updatedQ0 = load.getQ0() / PerUnit.SB + getPowerFactor(load) * diffTargetP * getParticipationFactor(load.getId());
             newLoadTargetQ += updatedQ0;
         }
         return newLoadTargetQ;
@@ -255,6 +267,14 @@ private static double getPowerFactor(Load load) {
         return load.getP0() != 0 ? load.getQ0() / load.getP0() : 1;
     }
 
+    /**
+     * Returns true if the load does not participate to slack distribution
+     */
+    public static boolean isLoadNotParticipating(Load load) {
+        // Fictitious loads that do not participate to slack distribution.
+        return load.isFictitious() || LoadType.FICTITIOUS.equals(load.getLoadType());
+    }
+
     @Override
     public Evaluable getP() {
         return p;