feat(solver): Scaling P, Q slack variables and tests with jacobienne

Signed-off-by: Yoann Anezin <[email protected]>

Signed-off-by: Yoann Anezin <[email protected]>

Author: YoannAnezin

src/main/java/com/powsybl/openloadflow/knitro/solver/KnitroLoadFlowParameters.java

@@ -13,6 +13,7 @@
 /**
  * @author Jeanne Archambault {@literal <jeanne.archambault at artelys.com>}
  * @author Martin Debouté {@literal <martin.deboute at artelys.com>}
+ * @author Amine Makhen {@literal <amine.makhen at artelys.com>}
  */
 public class KnitroLoadFlowParameters extends AbstractExtension<LoadFlowParameters> {
 

src/main/java/com/powsybl/openloadflow/knitro/solver/KnitroSolverFactory.java

@@ -25,6 +25,7 @@
 /**
  * @author Pierre Arvy {@literal <pierre.arvy at artelys.com>}
  * @author Martin Debouté {@literal <martin.deboute at artelys.com>}
+ * @author Amine Makhen {@literal <amine.makhen at artelys.com>}
  */
 @AutoService(AcSolverFactory.class)
 public class KnitroSolverFactory implements AcSolverFactory {

src/main/java/com/powsybl/openloadflow/knitro/solver/KnitroSolverParameters.java

@@ -5,9 +5,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  * SPDX-License-Identifier: MPL-2.0
  */
+
 package com.powsybl.openloadflow.knitro.solver;
 
-import com.artelys.knitro.api.KNConstants;
 import com.powsybl.openloadflow.ac.solver.AcSolverParameters;
 import com.powsybl.openloadflow.ac.solver.LineSearchStateVectorScaling;
 import com.powsybl.openloadflow.ac.solver.MaxVoltageChangeStateVectorScaling;
@@ -25,8 +25,8 @@ public class KnitroSolverParameters implements AcSolverParameters {
     public static final int DEFAULT_GRADIENT_COMPUTATION_MODE = 1; // Specifies how the Jacobian matrix is computed
     public static final int DEFAULT_GRADIENT_USER_ROUTINE = 2; // If the user chooses to pass the exact Jacobian to knitro, specifies the sparsity pattern for the Jacobian matrix.
     public static final int DEFAULT_HESSIAN_COMPUTATION_MODE = 6; // Specifies how the Hessian matrix is computed. 6 means that the Hessian is approximated using the L-BFGS method, which is a quasi-Newton method.
-    public static final double DEFAULT_LOWER_VOLTAGE_BOUND = 0; // Lower bound for voltage magnitude
-    public static final double DEFAULT_UPPER_VOLTAGE_BOUND = 5; // Upper bound for voltage magnitude
+    public static final double DEFAULT_LOWER_VOLTAGE_BOUND = 0.5; // Lower bound for voltage magnitude
+    public static final double DEFAULT_UPPER_VOLTAGE_BOUND = 2; // Upper bound for voltage magnitude
     public static final int DEFAULT_MAX_ITERATIONS = 200;
     public static final double DEFAULT_STOPPING_CRITERIA = Math.pow(10, -6);
     public static final StateVectorScalingMode DEFAULT_STATE_VECTOR_SCALING_MODE = StateVectorScalingMode.NONE;

src/main/java/com/powsybl/openloadflow/knitro/solver/KnitroSolverReacLim.java

@@ -0,0 +1,94 @@
+/**
+ * Copyright (c) 2025, Artelys (http://www.artelys.com/)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+package com.powsybl.openloadflow.knitro.solver;
+
+import com.powsybl.iidm.network.Network;
+import com.powsybl.iidm.network.*;
+import com.powsybl.loadflow.LoadFlow;
+import com.powsybl.loadflow.LoadFlowParameters;
+import com.powsybl.loadflow.LoadFlowResult;
+import com.powsybl.openloadflow.OpenLoadFlowParameters;
+
+import java.util.*;
+
+
+import static org.ejml.UtilEjml.assertTrue;
+
+/**
+ * @author Pierre Arvy {@literal <pierre.arvy at artelys.com>}
+ * @author Yoann Anezin {@literal <yoann.anezin at artelys.com>}
+ */
+public class ReacLimitsTestsUtils {
+    private static final double DEFAULT_TOLERANCE = 1e-3;
+
+    public ArrayList<Integer> countAndSwitch(Network network, HashMap<String,Double> listMinQ, HashMap<String,Double> listMaxQ) throws Exception {
+        int nmbSwitchQmin = 0;
+        int nmbSwitchQmax = 0;
+        int previousNmbBusPV = 0;
+        ArrayList<Integer> switches = new ArrayList<>();
+        for (Generator g : network.getGenerators()) {
+            ArrayList<String> busVisited = new ArrayList<>();
+            if (g.isVoltageRegulatorOn() && !busVisited.contains(g.getId())) {
+                busVisited.add(g.getId());
+                previousNmbBusPV += 1;
+            }
+            Terminal t = g.getTerminal();
+            double v = t.getBusView().getBus().getV();
+            if (g.isVoltageRegulatorOn()) {
+                double Qming = g.getReactiveLimits().getMinQ(g.getTerminal().getBusView().getBus().getP());
+                double Qmaxg = g.getReactiveLimits().getMaxQ(g.getTerminal().getBusView().getBus().getP());
+                if (!(v + DEFAULT_TOLERANCE > g.getTargetV() && v - DEFAULT_TOLERANCE < g.getTargetV())) {
+                    if (-t.getQ() + DEFAULT_TOLERANCE > Qming &&
+                            -t.getQ() - DEFAULT_TOLERANCE < Qming) {
+                        nmbSwitchQmin++;
+                        assertTrue(v > g.getTargetV(), "V below its target on  Qmin switch of bus "
+                                + t.getBusView().getBus().getId() + ". Current generator checked : " + g.getId());
+                        g.setTargetQ(listMinQ.get(g.getId()));
+                    } else if (-t.getQ() + DEFAULT_TOLERANCE > Qmaxg &&
+                            -t.getQ() - DEFAULT_TOLERANCE < Qmaxg) {
+                        nmbSwitchQmax++;
+                        assertTrue(v < g.getTargetV(), "V above its target on a Qmax switch of bus "
+                                + t.getBusView().getBus().getId() + ". Current generator checked : " + g.getId());
+                        g.setTargetQ(listMaxQ.get(g.getId()));
+                    } else {
+                        throw new Exception("Value of Q not matching Qmin nor Qmax on the switch of bus "
+                                + t.getBusView().getBus().getId() + ". Current generator checked : " + g.getId());
+                    }
+                    g.setVoltageRegulatorOn(false);
+
+                }
+            }
+        }
+        switches.add(nmbSwitchQmin);
+        switches.add(nmbSwitchQmax);
+        switches.add(previousNmbBusPV);
+        return switches;
+    }
+
+    public void verifNewtonRaphson (Network network, LoadFlowParameters parameters, LoadFlow.Runner loadFlowRunner, int nbreIter) {
+        OpenLoadFlowParameters.get(parameters).setVoltageInitModeOverride(OpenLoadFlowParameters.VoltageInitModeOverride.NONE);
+        parameters.setVoltageInitMode(LoadFlowParameters.VoltageInitMode.PREVIOUS_VALUES);
+        OpenLoadFlowParameters.get(parameters).setMaxNewtonRaphsonIterations(nbreIter)
+                .setReportedFeatures(Collections.singleton(OpenLoadFlowParameters.ReportedFeatures.NEWTON_RAPHSON_LOAD_FLOW));
+        OpenLoadFlowParameters.get(parameters).setAcSolverType("NEWTON_RAPHSON");
+        LoadFlowResult result = loadFlowRunner.run(network, parameters);
+        assertTrue(result.isFullyConverged());
+    }
+
+    public void checkSwitches(Network network, HashMap<String,Double> listMinQ, HashMap<String,Double> listMaxQ) {
+        try {
+            ArrayList<Integer> switches = countAndSwitch(network, listMinQ, listMaxQ);
+            assertTrue(switches.get(2) > switches.get(1) + switches.get(0),
+                    "No control on any voltage magnitude : all buses switched");
+            System.out.println(switches.get(0) + " switches to PQ with Q = Qlow and " + switches.get(1) + " with Q = Qup");
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/com/powsybl/openloadflow/knitro/solver/ReacLimitsTestsUtils.java

@@ -45,12 +45,12 @@ public class ResilientKnitroSolver extends AbstractAcSolver {
 
     // Penalty weights in the objective function
     private final double wK = 1.0;
-    private final double wP = 100.0;
-    private final double wQ = 50.0;
-    private final double wV = 1.0;
+    private final double wP = 1.0;
+    private final double wQ = 1.0;
+    private final double wV = 100.0;
 
     // Lambda
-    private final double lambda = 2.0;
+    private final double lambda = 3.0;
 
     // Number of Load Flows (LF) variables in the system
     private final int numLFVariables;
@@ -557,6 +557,9 @@ private ResilientKnitroProblem(
             // Initialize slack variables (≥ 0, initial value = 0)
             for (int i = slackStartIndex; i < numTotalVariables; i++) {
                 lowerBounds.set(i, 0.0);
+//                if (i >= slackVStartIndex) {
+//                    upperBounds.set(i, 0.0);
+//                }
             }
 
             // Set bounds for voltage variables based on Knitro parameters