Support of static var compensator with VoltagePerReactivePowerControl extension

src/main/java/com/powsybl/openloadflow/OpenLoadFlowParameters.java

@@ -44,6 +44,8 @@ public enum LowImpedanceBranchMode {
 
     private double slackBusPMaxMismatch = SLACK_BUS_P_MAX_MISMATCH_DEFAULT_VALUE;
 
+    private boolean voltagePerReactivePowerControl = VOLTAGE_PER_REACTIVE_POWER_CONTROL_DEFAULT_VALUE;
+
     @Override
     public String getName() {
         return "open-load-flow-parameters";
@@ -133,6 +135,15 @@ public OpenLoadFlowParameters setAddRatioToLinesWithDifferentNominalVoltageAtBot
         return this;
     }
 
+    public boolean isVoltagePerReactivePowerControl() {
+        return voltagePerReactivePowerControl;
+    }
+
+    public OpenLoadFlowParameters setVoltagePerReactivePowerControl(boolean voltagePerReactivePowerControl) {
+        this.voltagePerReactivePowerControl = voltagePerReactivePowerControl;
+        return this;
+    }
+
     public static OpenLoadFlowParameters load() {
         return new OpenLoadFlowConfigLoader().load(PlatformConfig.defaultConfig());
     }
@@ -149,6 +160,7 @@ public String toString() {
                 ", plausibleActivePowerLimit=" + plausibleActivePowerLimit +
                 ", addRatioToLinesWithDifferentNominalVoltageAtBothEnds=" + addRatioToLinesWithDifferentNominalVoltageAtBothEnds +
                 ", slackBusPMaxMismatch=" + slackBusPMaxMismatch +
+                ", voltagePerReactivePowerControl=" + voltagePerReactivePowerControl +
                 ')';
     }
 
@@ -172,6 +184,7 @@ public OpenLoadFlowParameters load(PlatformConfig platformConfig) {
                         .setPlausibleActivePowerLimit(config.getDoubleProperty(PLAUSIBLE_ACTIVE_POWER_LIMIT_PARAM_NAME, PLAUSIBLE_ACTIVE_POWER_LIMIT_DEFAULT_VALUE))
                         .setAddRatioToLinesWithDifferentNominalVoltageAtBothEnds(config.getBooleanProperty(ADD_RATIO_TO_LINES_WITH_DIFFERENT_NOMINAL_VOLTAGE_AT_BOTH_ENDS_NAME, ADD_RATIO_TO_LINES_WITH_DIFFERENT_NOMINAL_VOLTAGE_AT_BOTH_ENDS_DEFAULT_VALUE))
                         .setSlackBusPMaxMismatch(config.getDoubleProperty(SLACK_BUS_P_MAX_MISMATCH_NAME, SLACK_BUS_P_MAX_MISMATCH_DEFAULT_VALUE))
+                        .setVoltagePerReactivePowerControl(VOLTAGE_PER_REACTIVE_POWER_CONTROL_DEFAULT_VALUE)
                 );
             return parameters;
         }

src/main/java/com/powsybl/openloadflow/OpenLoadFlowProvider.java

@@ -148,6 +148,7 @@ public static AcLoadFlowParameters createAcParameters(Network network, MatrixFac
         LOGGER.info("Add ratio to lines with different nominal voltage at both ends: {}", parametersExt.isAddRatioToLinesWithDifferentNominalVoltageAtBothEnds());
         LOGGER.info("Slack bus Pmax mismatch: {}", parametersExt.getSlackBusPMaxMismatch());
         LOGGER.info("Connected component mode: {}", parameters.getConnectedComponentMode());
+        LOGGER.info("Voltage per reactive power control: {}", parametersExt.isVoltagePerReactivePowerControl());
 
         List<OuterLoop> outerLoops = new ArrayList<>();
         if (parameters.isDistributedSlack()) {
@@ -183,7 +184,8 @@ public static AcLoadFlowParameters createAcParameters(Network network, MatrixFac
                                         branchesWithCurrent,
                                         parameters.getConnectedComponentMode() == LoadFlowParameters.ConnectedComponentMode.MAIN,
                                         parameters.getCountriesToBalance(),
-                                        parameters.isDistributedSlack() && parameters.getBalanceType() == LoadFlowParameters.BalanceType.PROPORTIONAL_TO_CONFORM_LOAD);
+                                        parameters.isDistributedSlack() && parameters.getBalanceType() == LoadFlowParameters.BalanceType.PROPORTIONAL_TO_CONFORM_LOAD,
+                                        parametersExt.isVoltagePerReactivePowerControl());
     }
 
     private LoadFlowResult runAc(Network network, LoadFlowParameters parameters, OpenLoadFlowParameters parametersExt, Reporter reporter) {

src/main/java/com/powsybl/openloadflow/ac/ReactiveLimitsOuterLoop.java

@@ -30,8 +30,6 @@ public class ReactiveLimitsOuterLoop implements OuterLoop {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(ReactiveLimitsOuterLoop.class);
 
-    private static final double Q_EPS = Math.pow(10, -5); // 10^-5 in p.u => 10^-3 in Mw
-
     private static final Comparator<PvToPqBus> BY_NOMINAL_V_COMPARATOR = Comparator.comparingDouble(
         pvToPqBus -> pvToPqBus.controllerBus.getVoltageControl()
             .map(vc -> -vc.getControlledBus().getNominalV())
@@ -196,10 +194,12 @@ private void checkPqBus(LfBus controllerCapableBus, List<PqToPvBus> pqToPvBuses)
         double minQ = controllerCapableBus.getMinQ();
         double maxQ = controllerCapableBus.getMaxQ();
         double q = controllerCapableBus.getGenerationTargetQ();
-        if (Math.abs(q - maxQ) < Q_EPS && controllerCapableBus.getV().eval() > getBusTargetV(controllerCapableBus)) { // bus produce too much reactive power
+        double distanceToMaxQ = Math.abs(q - maxQ);
+        double distanceToMinQ = Math.abs(q - minQ);
+        if (distanceToMaxQ < distanceToMinQ  && controllerCapableBus.getV().eval() > getBusTargetV(controllerCapableBus)) { // bus produce too much reactive power
             pqToPvBuses.add(new PqToPvBus(controllerCapableBus, ReactiveLimitDirection.MAX));
         }
-        if (Math.abs(q - minQ) < Q_EPS && controllerCapableBus.getV().eval() < getBusTargetV(controllerCapableBus)) { // bus absorb too much reactive power
+        if (distanceToMaxQ > distanceToMinQ && controllerCapableBus.getV().eval() < getBusTargetV(controllerCapableBus)) { // bus absorb too much reactive power
             pqToPvBuses.add(new PqToPvBus(controllerCapableBus, ReactiveLimitDirection.MIN));
         }
     }
@@ -219,7 +219,12 @@ public OuterLoopStatus check(OuterLoopContext context, Reporter reporter) {
             if (bus.isVoltageControllerEnabled() && !bus.isDisabled()) {
                 checkPvBus(bus, pvToPqBuses, remainingPvBusCount);
             } else if (bus.hasVoltageControllerCapability() && !bus.isDisabled()) {
-                checkPqBus(bus, pqToPvBuses);
+                if (!bus.hasGeneratorsWithSlope()) {
+                    checkPqBus(bus, pqToPvBuses);
+                } else {
+                    // we don't support switching PQ to PV for bus with one controller with slope.
+                    LOGGER.warn("Controller bus '{}' wants to control back voltage with slope: not supported", bus.getId());
+                }
             }
         }
 

src/main/java/com/powsybl/openloadflow/ac/equations/AcEquationSystem.java

@@ -60,9 +60,7 @@ private static void createBusEquations(LfNetwork network, VariableSet variableSe
     private static void createVoltageControlEquations(VoltageControl voltageControl, LfBus bus, VariableSet variableSet,
                                                       EquationSystem equationSystem, AcEquationSystemCreationParameters creationParameters) {
         if (voltageControl.isVoltageControlLocal()) {
-            EquationTerm vTerm = EquationTerm.createVariableTerm(bus, VariableType.BUS_V, variableSet, bus.getV().eval());
-            equationSystem.createEquation(bus.getNum(), EquationType.BUS_V).addTerm(vTerm);
-            bus.setV(vTerm);
+            createLocalVoltageControlEquation(bus, variableSet, equationSystem, creationParameters);
         } else if (bus.isVoltageControlled()) {
             // remote controlled: set voltage equation on this controlled bus
             createVoltageControlledBusEquations(voltageControl, equationSystem, variableSet, creationParameters);
@@ -73,6 +71,18 @@ private static void createVoltageControlEquations(VoltageControl voltageControl,
         }
     }
 
+    private static void createLocalVoltageControlEquation(LfBus bus, VariableSet variableSet, EquationSystem equationSystem, AcEquationSystemCreationParameters creationParameters) {
+        EquationTerm vTerm = EquationTerm.createVariableTerm(bus, VariableType.BUS_V, variableSet, bus.getV().eval());
+        bus.setV(vTerm);
+        if (bus.hasGeneratorsWithSlope()) {
+            // take first generator with slope: network loading ensures that there's only one generator with slope
+            double slope = bus.getGeneratorsControllingVoltageWithSlope().get(0).getSlope();
+            createBusWithSlopeEquation(bus, slope, creationParameters, variableSet, equationSystem, vTerm);
+            return;
+        }
+        equationSystem.createEquation(bus.getNum(), EquationType.BUS_V).addTerm(vTerm);
+    }
+
     private static void createShuntEquations(VariableSet variableSet, EquationSystem equationSystem, LfBus bus) {
         for (LfShunt shunt : bus.getShunts()) {
             ShuntCompensatorReactiveFlowEquationTerm q = new ShuntCompensatorReactiveFlowEquationTerm(shunt, bus, variableSet);
@@ -208,8 +218,8 @@ private static void createNonImpedantBranch(VariableSet variableSet, EquationSys
                                                 LfBranch branch, LfBus bus1, LfBus bus2) {
         Optional<Equation> v1 = equationSystem.getEquation(bus1.getNum(), EquationType.BUS_V);
         Optional<Equation> v2 = equationSystem.getEquation(bus2.getNum(), EquationType.BUS_V);
-        boolean hasV1 = v1.isPresent() && v1.get().isActive(); // may be inactive is the equation has been created for sensitivity
-        boolean hasV2 = v2.isPresent() && v2.get().isActive(); // may be inactive is the equation has been created for sensitivity
+        boolean hasV1 = v1.isPresent() && v1.get().isActive(); // may be inactive if the equation has been created for sensitivity
+        boolean hasV2 = v2.isPresent() && v2.get().isActive(); // may be inactive if the equation has been created for sensitivity
         if (!(hasV1 && hasV2)) {
             // create voltage magnitude coupling equation
             // 0 = v1 - v2 * rho
@@ -284,6 +294,19 @@ private static void createDiscreteVoltageControlEquation(LfBus bus,  VariableSet
             });
     }
 
+    private static void createBusWithSlopeEquation(LfBus bus, double slope, AcEquationSystemCreationParameters creationParameters, VariableSet variableSet, EquationSystem equationSystem, EquationTerm vTerm) {
+        // we only support one generator controlling voltage with a non zero slope at a bus.
+        // equation is: V + slope * qSVC = targetV
+        // which is modeled here with: V + slope * (sum_branch qBranch) = TargetV - slope * qLoads + slope * qGenerators
+        Equation eq = equationSystem.createEquation(bus.getNum(), EquationType.BUS_V_SLOPE);
+        eq.addTerm(vTerm);
+        List<EquationTerm> controllerBusReactiveTerms = createReactiveTerms(bus, variableSet, creationParameters);
+        eq.setData(new DistributionData(bus.getNum(), slope)); // for later use
+        for (EquationTerm eqTerm : controllerBusReactiveTerms) {
+            eq.addTerm(EquationTerm.multiply(eqTerm, slope));
+        }
+    }
+
     public static void createR1DistributionEquations(EquationSystem equationSystem, VariableSet variableSet,
                                                      List<LfBranch> controllerBranches) {
         if (controllerBranches.size() > 1) {

src/main/java/com/powsybl/openloadflow/ac/equations/AcEquationSystemUpdater.java

@@ -40,18 +40,26 @@ private void updateControlledBus(VoltageControl voltageControl, EquationSystem e
         LfBus controlledBus = voltageControl.getControlledBus();
         Set<LfBus> controllerBuses = voltageControl.getControllerBuses();
 
-        // clean reactive power distribution equations
-        controllerBuses.forEach(b -> equationSystem.removeEquation(b.getNum(), EquationType.ZERO_Q));
-
-        // controlled bus has a voltage equation only if one of the controller bus has voltage control on
-        List<LfBus> controllerBusesWithVoltageControlOn = controllerBuses.stream()
-            .filter(LfBus::isVoltageControllerEnabled)
-            .collect(Collectors.toList());
-        equationSystem.createEquation(controlledBus.getNum(), EquationType.BUS_V).setActive(!controllerBusesWithVoltageControlOn.isEmpty());
-
-        // create reactive power equations on controller buses that have voltage control on
-        if (!controllerBusesWithVoltageControlOn.isEmpty()) {
-            AcEquationSystem.createReactivePowerDistributionEquations(equationSystem, variableSet, creationParameters, controllerBusesWithVoltageControlOn);
+        LfBus firstControllerBus = controllerBuses.iterator().next();
+        if (firstControllerBus.hasGeneratorsWithSlope()) {
+            // we only support one controlling static var compensator without any other controlling generators
+            // we don't support controller bus that wants to control back voltage with slope.
+            if (!firstControllerBus.isVoltageControllerEnabled()) {
+                equationSystem.createEquation(controlledBus.getNum(), EquationType.BUS_V_SLOPE).setActive(false);
+            }
+        } else {
+            // controlled bus has a voltage equation only if one of the controller bus has voltage control on
+            List<LfBus> controllerBusesWithVoltageControlOn = controllerBuses.stream()
+                    .filter(LfBus::isVoltageControllerEnabled)
+                    .collect(Collectors.toList());
+            // clean reactive power distribution equations
+            controllerBuses.forEach(b -> equationSystem.removeEquation(b.getNum(), EquationType.ZERO_Q));
+            // is there one static var compensator with a non-zero slope
+            equationSystem.createEquation(controlledBus.getNum(), EquationType.BUS_V).setActive(!controllerBusesWithVoltageControlOn.isEmpty());
+            // create reactive power equations on controller buses that have voltage control on
+            if (!controllerBusesWithVoltageControlOn.isEmpty()) {
+                AcEquationSystem.createReactivePowerDistributionEquations(equationSystem, variableSet, creationParameters, controllerBusesWithVoltageControlOn);
+            }
         }
     }
 

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

@@ -58,14 +58,17 @@ public class AcLoadFlowParameters {
 
     private final boolean distributedOnConformLoad;
 
+    private final boolean voltagePerReactivePowerControl;
+
     public AcLoadFlowParameters(SlackBusSelector slackBusSelector, VoltageInitializer voltageInitializer,
                                 NewtonRaphsonStoppingCriteria stoppingCriteria, List<OuterLoop> outerLoops,
                                 MatrixFactory matrixFactory, boolean voltageRemoteControl,
                                 boolean phaseControl, boolean transformerVoltageControlOn, boolean minImpedance,
                                 boolean twtSplitShuntAdmittance, boolean breakers, double plausibleActivePowerLimit,
                                 boolean forceA1Var, boolean addRatioToLinesWithDifferentNominalVoltageAtBothEnds,
                                 Set<String> branchesWithCurrent, boolean computeMainConnectedComponentOnly,
-                                Set<Country> countriesToBalance, boolean distributedOnConformLoad) {
+                                Set<Country> countriesToBalance, boolean distributedOnConformLoad,
+                                boolean voltagePerReactivePowerControl) {
         this.slackBusSelector = Objects.requireNonNull(slackBusSelector);
         this.voltageInitializer = Objects.requireNonNull(voltageInitializer);
         this.stoppingCriteria = Objects.requireNonNull(stoppingCriteria);
@@ -84,6 +87,7 @@ public AcLoadFlowParameters(SlackBusSelector slackBusSelector, VoltageInitialize
         this.computeMainConnectedComponentOnly = computeMainConnectedComponentOnly;
         this.countriesToBalance = countriesToBalance;
         this.distributedOnConformLoad = distributedOnConformLoad;
+        this.voltagePerReactivePowerControl = voltagePerReactivePowerControl;
     }
 
     public SlackBusSelector getSlackBusSelector() {
@@ -161,4 +165,8 @@ public Set<Country> getCountriesToBalance() {
     public boolean isDistributedOnConformLoad() {
         return  distributedOnConformLoad;
     }
+
+    public boolean isVoltagePerReactivePowerControl() {
+        return voltagePerReactivePowerControl;
+    }
 }

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

@@ -60,7 +60,8 @@ public static List<LfNetwork> createNetworks(Object network, AcLoadFlowParameter
                                                                         parameters.getCountriesToBalance(),
                                                                         parameters.isDistributedOnConformLoad(),
                                                                         parameters.isPhaseControl(),
-                                                                        parameters.isVoltageRemoteControl());
+                                                                        parameters.isVoltageRemoteControl(),
+                                                                        parameters.isVoltagePerReactivePowerControl());
         return LfNetwork.load(network, networkParameters, reporter);
     }
 

src/main/java/com/powsybl/openloadflow/dc/DcLoadFlowEngine.java

@@ -46,7 +46,8 @@ public DcLoadFlowEngine(LfNetwork network, MatrixFactory matrixFactory, boolean
     public DcLoadFlowEngine(Object network, DcLoadFlowParameters parameters, Reporter reporter) {
         LfNetworkParameters lfNetworkParameters = new LfNetworkParameters(parameters.getSlackBusSelector(), false, false, false, false,
                 parameters.getPlausibleActivePowerLimit(), false, parameters.isComputeMainConnectedComponentOnly(), parameters.getCountriesToBalance(),
-                parameters.isDistributedSlack() && parameters.getBalanceType() == LoadFlowParameters.BalanceType.PROPORTIONAL_TO_CONFORM_LOAD, false, false);
+                parameters.isDistributedSlack() && parameters.getBalanceType() == LoadFlowParameters.BalanceType.PROPORTIONAL_TO_CONFORM_LOAD,
+                false, false, false);
         this.networks = LfNetwork.load(network, lfNetworkParameters, reporter);
         this.parameters = Objects.requireNonNull(parameters);
     }

src/main/java/com/powsybl/openloadflow/equations/Equation.java

@@ -170,6 +170,11 @@ private static double getRho1DistributionTarget(LfNetwork network, int num, Dist
         return controllerBranch.getPiModel().getR1() - firstControllerBranch.getPiModel().getR1();
     }
 
+    private static double createBusWithSlopeTarget(LfBus bus, DistributionData data) {
+        double slope = data.getC();
+        return getBusTargetV(bus) - slope * (bus.getLoadTargetQ() - bus.getGenerationTargetQ());
+    }
+
     void initTarget(LfNetwork network, double[] targets) {
         switch (type) {
             case BUS_P:
@@ -184,6 +189,10 @@ void initTarget(LfNetwork network, double[] targets) {
                 targets[column] = getBusTargetV(network.getBus(num));
                 break;
 
+            case BUS_V_SLOPE:
+                targets[column] = createBusWithSlopeTarget(network.getBus(num), getData());
+                break;
+
             case BUS_PHI:
                 targets[column] = 0;
                 break;

src/main/java/com/powsybl/openloadflow/equations/EquationType.java

@@ -16,6 +16,7 @@ public enum EquationType {
     BUS_I("b_i", ElementType.BUS),
     BUS_Q("q", ElementType.BUS),
     BUS_V("v", ElementType.BUS),
+    BUS_V_SLOPE("v_slope", ElementType.BUS),
     BUS_PHI("\u03C6", ElementType.BUS),
     BRANCH_P("t", ElementType.BRANCH),
     BRANCH_I("i", ElementType.BRANCH),

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

@@ -32,6 +32,12 @@ public interface LfBus extends LfElement {
 
     boolean isVoltageControlled();
 
+    List<LfGenerator> getGeneratorsControllingVoltageWithSlope();
+
+    boolean hasGeneratorsWithSlope();
+
+    void removeGeneratorSlopes();
+
     /**
      * Get the number of time, voltage control status has be set from true to false.
      *

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

@@ -52,4 +52,8 @@ public interface LfGenerator {
     void updateState();
 
     LfBus getControlledBus(LfNetwork lfNetwork);
+
+    double getSlope();
+
+    void setSlope(double slope);
 }