Remedial action: partial support of GeneratorAction

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

@@ -17,6 +17,7 @@ public class BusDcState extends ElementState<LfBus> {
     private final double loadTargetP;
     private final Map<String, Double> generatorsTargetP;
     private final Map<String, Boolean> participatingGenerators;
+    private final Map<String, Boolean> disablingStatusGenerators;
     private final double absVariableLoadTargetP;
     private final Map<String, Boolean> loadsDisablingStatus;
 
@@ -25,6 +26,7 @@ public BusDcState(LfBus bus) {
         this.loadTargetP = bus.getLoadTargetP();
         this.generatorsTargetP = bus.getGenerators().stream().collect(Collectors.toMap(LfGenerator::getId, LfGenerator::getTargetP));
         this.participatingGenerators = bus.getGenerators().stream().collect(Collectors.toMap(LfGenerator::getId, LfGenerator::isParticipating));
+        this.disablingStatusGenerators = bus.getGenerators().stream().collect(Collectors.toMap(LfGenerator::getId, LfGenerator::isDisabled));
         this.absVariableLoadTargetP = bus.getAggregatedLoads().getAbsVariableLoadTargetP();
         this.loadsDisablingStatus = bus.getAggregatedLoads().getLoadsDisablingStatus();
     }
@@ -35,6 +37,7 @@ public void restore() {
         element.setLoadTargetP(loadTargetP);
         element.getGenerators().forEach(g -> g.setTargetP(generatorsTargetP.get(g.getId())));
         element.getGenerators().forEach(g -> g.setParticipating(participatingGenerators.get(g.getId())));
+        element.getGenerators().forEach(g -> g.setDisabled(disablingStatusGenerators.get(g.getId())));
         element.getAggregatedLoads().setAbsVariableLoadTargetP(absVariableLoadTargetP);
         element.getAggregatedLoads().setLoadsDisablingStatus(loadsDisablingStatus);
     }

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

@@ -10,8 +10,8 @@
 import com.powsybl.iidm.network.Load;
 import com.powsybl.iidm.network.Network;
 import com.powsybl.iidm.network.Terminal;
-import com.powsybl.loadflow.LoadFlowParameters;
 import com.powsybl.openloadflow.graph.GraphConnectivity;
+import com.powsybl.openloadflow.network.impl.AbstractLfGenerator;
 import com.powsybl.openloadflow.network.impl.Networks;
 import com.powsybl.openloadflow.util.PerUnit;
 import com.powsybl.security.action.*;
@@ -20,6 +20,7 @@
 
 /**
  * @author Anne Tilloy <anne.tilloy at rte-france.com>
+ * @author Jean-Luc Bouchot (Artelys) <jlbouchot at gmail.com>
  */
 public final class LfAction {
 
@@ -65,6 +66,26 @@ private LoadShift(LfBus bus, String loadId, PowerShift powerShift) {
         }
     }
 
+    public static final class GeneratorChange {
+
+        private final LfGenerator generator;
+
+        private final double deltaTargetP;
+
+        private GeneratorChange(LfGenerator generator, double deltaTargetP) {
+            this.generator = generator;
+            this.deltaTargetP = deltaTargetP;
+        }
+
+        public LfGenerator getGenerator() {
+            return generator;
+        }
+
+        public double getDeltaTargetP() {
+            return deltaTargetP;
+        }
+    }
+
     private final String id;
 
     private final LfBranch disabledBranch; // switch to open
@@ -75,13 +96,16 @@ private LoadShift(LfBus bus, String loadId, PowerShift powerShift) {
 
     private final LoadShift loadShift;
 
+    private final GeneratorChange generatorChange;
+
     private LfAction(String id, LfBranch disabledBranch, LfBranch enabledBranch, TapPositionChange tapPositionChange,
-                     LoadShift loadShift) {
+                     LoadShift loadShift, GeneratorChange generatorChange) {
         this.id = Objects.requireNonNull(id);
         this.disabledBranch = disabledBranch;
         this.enabledBranch = enabledBranch;
         this.tapPositionChange = tapPositionChange;
         this.loadShift = loadShift;
+        this.generatorChange = generatorChange;
     }
 
     public static Optional<LfAction> create(Action action, LfNetwork lfNetwork, Network network, boolean breakers) {
@@ -100,6 +124,9 @@ public static Optional<LfAction> create(Action action, LfNetwork lfNetwork, Netw
             case LoadAction.NAME:
                 return create((LoadAction) action, lfNetwork, network, breakers);
 
+            case GeneratorAction.NAME:
+                return create((GeneratorAction) action, lfNetwork);
+
             default:
                 throw new UnsupportedOperationException("Unsupported action type: " + action.getType());
         }
@@ -124,7 +151,7 @@ private static Optional<LfAction> create(LoadAction action, LfNetwork lfNetwork,
             // 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);
-            return Optional.of(new LfAction(action.getId(), null, null, null, new LoadShift(lfBus, load.getId(), powerShift)));
+            return Optional.of(new LfAction(action.getId(), null, null, null, new LoadShift(lfBus, load.getId(), powerShift), null));
         }
         return Optional.empty(); // could be in another component or in contingency.
     }
@@ -136,7 +163,7 @@ private static Optional<LfAction> create(PhaseTapChangerTapPositionAction action
                 throw new UnsupportedOperationException("Phase tap changer tap connection action: only one tap in the branch {" + action.getTransformerId() + "}");
             } else {
                 var tapPositionChange = new TapPositionChange(branch, action.getTapPosition(), action.isRelativeValue());
-                return Optional.of(new LfAction(action.getId(), null, null, tapPositionChange, null));
+                return Optional.of(new LfAction(action.getId(), null, null, tapPositionChange, null, null));
             }
         }
         return Optional.empty(); // could be in another component
@@ -146,7 +173,7 @@ private static Optional<LfAction> create(LineConnectionAction action, LfNetwork
         LfBranch branch = lfNetwork.getBranchById(action.getLineId());
         if (branch != null) {
             if (action.isOpenSide1() && action.isOpenSide2()) {
-                return Optional.of(new LfAction(action.getId(), branch, null, null, null));
+                return Optional.of(new LfAction(action.getId(), branch, null, null, null, null));
             } else {
                 throw new UnsupportedOperationException("Line connection action: only open line at both sides is supported yet.");
             }
@@ -164,11 +191,32 @@ private static Optional<LfAction> create(SwitchAction action, LfNetwork lfNetwor
             } else {
                 enabledBranch = branch;
             }
-            return Optional.of(new LfAction(action.getId(), disabledBranch, enabledBranch, null, null));
+            return Optional.of(new LfAction(action.getId(), disabledBranch, enabledBranch, null, null, null));
         }
         return Optional.empty(); // could be in another component
     }
 
+    private static Optional<LfAction> create(GeneratorAction action, LfNetwork lfNetwork) {
+        LfGenerator generator = lfNetwork.getGeneratorById(action.getGeneratorId());
+        if (generator != null) {
+            Optional<Double> activePowerValue = action.getActivePowerValue();
+            Optional<Boolean> relativeValue = action.isActivePowerRelativeValue();
+            if (relativeValue.isPresent() && activePowerValue.isPresent()) {
+                double deltaTargetP;
+                if (relativeValue.get().equals(Boolean.TRUE)) {
+                    deltaTargetP = activePowerValue.get() / PerUnit.SB;
+                } else {
+                    deltaTargetP = activePowerValue.get() / PerUnit.SB - generator.getInitialTargetP();
+                }
+                var generatorChange = new GeneratorChange(generator, deltaTargetP);
+                return Optional.of(new LfAction(action.getId(), null, null, null, null, generatorChange));
+            } else {
+                throw new UnsupportedOperationException("Generator action: configuration not supported yet.");
+            }
+        }
+        return Optional.empty();
+    }
+
     public String getId() {
         return id;
     }
@@ -181,7 +229,7 @@ public LfBranch getEnabledBranch() {
         return enabledBranch;
     }
 
-    public static void apply(List<LfAction> actions, LfNetwork network, LfContingency contingency, LoadFlowParameters.BalanceType balanceType) {
+    public static void apply(List<LfAction> actions, LfNetwork network, LfContingency contingency, LfNetworkParameters networkParameters) {
         Objects.requireNonNull(actions);
         Objects.requireNonNull(network);
 
@@ -190,7 +238,7 @@ public static void apply(List<LfAction> actions, LfNetwork network, LfContingenc
 
         // then process remaining changes of actions
         for (LfAction action : actions) {
-            action.apply(balanceType);
+            action.apply(networkParameters);
         }
     }
 
@@ -243,14 +291,15 @@ public void updateConnectivity(GraphConnectivity<LfBus, LfBranch> connectivity)
         }
     }
 
-    public void apply(LoadFlowParameters.BalanceType balanceType) {
+    public void apply(LfNetworkParameters networkParameters) {
         if (tapPositionChange != null) {
             LfBranch branch = tapPositionChange.getBranch();
             int tapPosition = branch.getPiModel().getTapPosition();
             int value = tapPositionChange.getValue();
             int newTapPosition = tapPositionChange.isRelative() ? tapPosition + value : value;
             branch.getPiModel().setTapPosition(newTapPosition);
         }
+
         if (loadShift != null) {
             LfBus bus = loadShift.bus;
             String loadId = loadShift.loadId;
@@ -262,5 +311,16 @@ public void apply(LoadFlowParameters.BalanceType balanceType) {
                         + Math.signum(shift.getActive()) * Math.abs(shift.getVariableActive()) * PerUnit.SB);
             }
         }
+
+        if (generatorChange != null) {
+            LfGenerator generator = generatorChange.getGenerator();
+            if (!generator.isDisabled()) {
+                generator.setTargetP(generator.getTargetP() + generatorChange.getDeltaTargetP());
+                if (!AbstractLfGenerator.checkActivePowerControl(generator.getId(), generator.getTargetP(), generator.getMinP(), generator.getMaxP(),
+                        networkParameters.getPlausibleActivePowerLimit(), null)) {
+                    generator.setParticipating(false);
+                }
+            }
+        }
     }
 }

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

@@ -170,6 +170,7 @@ public void apply(LoadFlowParameters.BalanceType balanceType) {
             LfBus bus = generator.getBus();
             generatorBuses.add(bus);
             generator.setParticipating(false);
+            generator.setDisabled(true);
             if (generator.getGeneratorControlType() != LfGenerator.GeneratorControlType.OFF) {
                 generator.setGeneratorControlType(LfGenerator.GeneratorControlType.OFF);
             } else {

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

@@ -43,6 +43,8 @@ enum ReactiveRangeMode {
 
     double getTargetQ();
 
+    double getInitialTargetP();
+
     double getTargetP();
 
     void setTargetP(double targetP);
@@ -92,4 +94,10 @@ default void setSlope(double slope) {
     ControlledSide getControlledBranchSide();
 
     double getRemoteTargetQ();
+
+    default boolean isDisabled() {
+        return false;
+    }
+
+    void setDisabled(boolean disabled);
 }

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

@@ -30,6 +30,8 @@ public abstract class AbstractLfGenerator extends AbstractPropertyBag implements
 
     protected final LfNetwork network;
 
+    protected double initialTargetP;
+
     protected double targetP;
 
     protected LfBus bus;
@@ -48,9 +50,12 @@ public abstract class AbstractLfGenerator extends AbstractPropertyBag implements
 
     protected double remoteTargetQ = Double.NaN;
 
+    private boolean disabled;
+
     protected AbstractLfGenerator(LfNetwork network, double targetP) {
         this.network = Objects.requireNonNull(network);
         this.targetP = targetP;
+        this.initialTargetP = targetP;
     }
 
     @Override
@@ -71,6 +76,11 @@ public boolean isFictitious() {
         return false;
     }
 
+    @Override
+    public double getInitialTargetP() {
+        return initialTargetP / PerUnit.SB;
+    }
+
     @Override
     public double getTargetP() {
         return targetP / PerUnit.SB;
@@ -302,37 +312,47 @@ public void setParticipating(boolean participating) {
         // nothing to do
     }
 
-    protected boolean checkActivePowerControl(double targetP, double minP, double maxP, LfNetworkParameters parameters,
-                                              LfNetworkLoadingReport report) {
+    public static boolean checkActivePowerControl(String generatorId, double targetP, double minP, double maxP, double plausibleActivePowerLimit,
+                                                  LfNetworkLoadingReport report) {
         boolean participating = true;
         if (Math.abs(targetP) < POWER_EPSILON_SI) {
             LOGGER.trace("Discard generator '{}' from active power control because targetP ({}) equals 0",
-                    getId(), targetP);
-            report.generatorsDiscardedFromActivePowerControlBecauseTargetEqualsToZero++;
+                    generatorId, targetP);
+            if (report != null) {
+                report.generatorsDiscardedFromActivePowerControlBecauseTargetEqualsToZero++;
+            }
             participating = false;
         }
         if (targetP > maxP) {
             LOGGER.trace("Discard generator '{}' from active power control because targetP ({}) > maxP ({})",
-                    getId(), targetP, maxP);
-            report.generatorsDiscardedFromActivePowerControlBecauseTargetPGreaterThanMaxP++;
+                    generatorId, targetP, maxP);
+            if (report != null) {
+                report.generatorsDiscardedFromActivePowerControlBecauseTargetPGreaterThanMaxP++;
+            }
             participating = false;
         }
         if (targetP < minP && minP > 0) {
             LOGGER.trace("Discard generator '{}' from active power control because targetP ({}) < minP ({})",
-                    getId(), targetP, minP);
-            report.generatorsDiscardedFromActivePowerControlBecauseTargetPLowerThanMinP++;
+                    generatorId, targetP, minP);
+            if (report != null) {
+                report.generatorsDiscardedFromActivePowerControlBecauseTargetPLowerThanMinP++;
+            }
             participating = false;
         }
-        if (maxP > parameters.getPlausibleActivePowerLimit()) {
+        if (maxP > plausibleActivePowerLimit) {
             LOGGER.trace("Discard generator '{}' from active power control because maxP ({}) > {}} MW",
-                    getId(), maxP, parameters.getPlausibleActivePowerLimit());
-            report.generatorsDiscardedFromActivePowerControlBecauseMaxPNotPlausible++;
+                    generatorId, maxP, plausibleActivePowerLimit);
+            if (report != null) {
+                report.generatorsDiscardedFromActivePowerControlBecauseMaxPNotPlausible++;
+            }
             participating = false;
         }
         if ((maxP - minP) < POWER_EPSILON_SI) {
             LOGGER.trace("Discard generator '{}' from active power control because maxP ({} MW) equals minP ({} MW)",
-                    getId(), maxP, minP);
-            report.generatorsDiscardedFromActivePowerControlBecauseMaxPEqualsMinP++;
+                    generatorId, maxP, minP);
+            if (report != null) {
+                report.generatorsDiscardedFromActivePowerControlBecauseMaxPEqualsMinP++;
+            }
             participating = false;
         }
         return participating;
@@ -342,4 +362,14 @@ protected boolean checkActivePowerControl(double targetP, double minP, double ma
     public String toString() {
         return getId();
     }
+
+    @Override
+    public boolean isDisabled() {
+        return disabled;
+    }
+
+    @Override
+    public void setDisabled(boolean disabled) {
+        this.disabled = disabled;
+    }
 }

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

@@ -46,7 +46,8 @@ private LfBatteryImpl(Battery battery, LfNetwork network, LfNetworkParameters pa
             }
         }
 
-        if (!checkActivePowerControl(battery.getTargetP(), battery.getMinP(), battery.getMaxP(), parameters, report)) {
+        if (!checkActivePowerControl(getId(), battery.getTargetP(), battery.getMinP(), battery.getMaxP(),
+                parameters.getPlausibleActivePowerLimit(), report)) {
             participating = false;
         }
     }

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

@@ -37,6 +37,7 @@ private LfGeneratorImpl(Generator generator, LfNetwork network, LfNetworkParamet
         this.generatorRef = Ref.create(generator, parameters.isCacheEnabled());
         participating = true;
         droop = DEFAULT_DROOP;
+
         // get participation factor and droop from extension
         ActivePowerControl<Generator> activePowerControl = generator.getExtension(ActivePowerControl.class);
         if (activePowerControl != null) {
@@ -49,7 +50,8 @@ private LfGeneratorImpl(Generator generator, LfNetwork network, LfNetworkParamet
             }
         }
 
-        if (!checkActivePowerControl(generator.getTargetP(), generator.getMinP(), generator.getMaxP(), parameters, report)) {
+        if (!checkActivePowerControl(generator.getId(), generator.getTargetP(), generator.getMinP(), generator.getMaxP(),
+                parameters.getPlausibleActivePowerLimit(), report)) {
             participating = false;
         }