Add relaxed solver modeling generators reactive limits

README.md

@@ -150,7 +150,9 @@ LoadFlow.run(network, parameters);
 ## Features
 
 The Knitro solver is used as a substitute for the **inner loop calculations** in the load flow process.
-The **outer loops** such as distributed slack, reactive limits, etc... operate identically as when using the Newton-Raphson method.
+The **outer loops** such as distributed slack, voltage monitoring, etc... operate identically as when using the Newton-Raphson method.
+Note that for the reactive limits outer loop case, it is run in the standard way only when the selected Knitro solver does not directly integrate reactive 
+limits into the optimization model (cf [Knitro Parameters](#knitro-parameters)).
 
 ### Configuration
 
@@ -175,6 +177,11 @@ parameters.addExtension(KnitroLoadFlowParameters.class, knitroLoadFlowParameters
     - **Knitro Solver Types**:
       - `STANDARD (default)` : the constraint satisfaction problem formulation and a direct substitute to the Newton-Raphson solver.
       - `RELAXED` : the optimisation problem formulation relaxing satisfaction problem.
+      - `USE_REACTIVE_LIMITS` : the optimization problem formulation relaxing satisfaction problem and integrating reactive limits in constraints.
+      Note that using this solver requires disabling the `useReactiveLimits` parameter in `LoadFlowParameters`, for compatibility reasons with the way outer 
+      loops are launched in Open-Load-Flow. Doing so, the Open-Load-Flow checks that disable voltage control when the reactive power bounds are not sufficiently 
+      large (see [OLF documentation](https://powsybl.readthedocs.io/projects/powsybl-open-loadflow/en/latest/loadflow/parameters.html)) are not performed, which may explain some of the differences in results between the Newton–Raphson solver and the Knitro solver. 
+      This will be addressed in a near future.
     - Use `setKnitroSolverType` in the `KnitroLoadFlowParameters` extension.
 
 2. **Voltage Bounds**:

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

@@ -31,7 +31,7 @@
  *  - Initialization and definition of variable bounds for the optimization problem.
  *  - Definition of constraints (including those evaluated via callbacks in {@link KnitroCallbacks}).
  *  - Representation of the constraint Jacobian for the problem.
- * This class can be extended to customize any of these features (e.g., in {@link RelaxedKnitroSolver.RelaxedKnitroProblem}).
+ * This class can be extended to customize any of these features (e.g., in {@link AbstractRelaxedKnitroSolver.AbstractRelaxedKnitroProblem}).
  * For example, if you modify the optimization problem, you may also need to update the initialization of additional variables.
  *
  * @author Jeanne Archambault {@literal <jeanne.archambault at artelys.com>}
@@ -51,27 +51,35 @@ public abstract class AbstractKnitroProblem extends KNProblem {
     protected final int numberOfPowerFlowVariables;
     protected List<Equation<AcVariableType, AcEquationType>> activeConstraints = new ArrayList<>();
     protected final List<Integer> nonlinearConstraintIndexes = new ArrayList<>();
+    protected final int numTotalVariables;
 
     protected AbstractKnitroProblem(LfNetwork network, EquationSystem<AcVariableType, AcEquationType> equationSystem,
                                     TargetVector<AcVariableType, AcEquationType> targetVector, JacobianMatrix<AcVariableType, AcEquationType> jacobianMatrix,
-                                    KnitroSolverParameters knitroParameters, int numTotalVariables) {
-        super(numTotalVariables, equationSystem.getIndex().getSortedEquationsToSolve().size());
+                                    KnitroSolverParameters knitroParameters) {
+        this(network, equationSystem, targetVector, jacobianMatrix, knitroParameters, 0, 0);
+    }
+
+    protected AbstractKnitroProblem(LfNetwork network, EquationSystem<AcVariableType, AcEquationType> equationSystem,
+                                    TargetVector<AcVariableType, AcEquationType> targetVector, JacobianMatrix<AcVariableType, AcEquationType> jacobianMatrix,
+                                    KnitroSolverParameters knitroParameters, int numAdditionalVariables, int numAdditionalConstraints) {
+        super(equationSystem.getIndex().getSortedVariablesToFind().size() + numAdditionalVariables,
+                equationSystem.getIndex().getSortedEquationsToSolve().size() + numAdditionalConstraints);
+        this.numberOfPowerFlowVariables = equationSystem.getIndex().getSortedVariablesToFind().size();
+        this.numTotalVariables = numberOfPowerFlowVariables + numAdditionalVariables;
         this.network = network;
         this.equationSystem = equationSystem;
         this.targetVector = targetVector;
         this.jacobianMatrix = jacobianMatrix;
         this.knitroParameters = knitroParameters;
-        this.numberOfPowerFlowVariables = equationSystem.getIndex().getSortedVariablesToFind().size();
     }
 
     /**
      * Initializes variables (types, bounds, initial values).
      * Can be overridden by subclasses to add additional variables (e.g., slack variables).
      *
      * @param voltageInitializer The voltage initializer to use.
-     * @param numTotalVariables  Total number of variables including any additional ones.
      */
-    protected void initializeVariables(VoltageInitializer voltageInitializer, int numTotalVariables) throws KNException {
+    protected void initializeVariables(VoltageInitializer voltageInitializer) throws KNException {
         List<Integer> variableTypes = new ArrayList<>(Collections.nCopies(numTotalVariables, KNConstants.KN_VARTYPE_CONTINUOUS));
         List<Double> lowerBounds = new ArrayList<>(Collections.nCopies(numTotalVariables, -KNConstants.KN_INFINITY));
         List<Double> upperBounds = new ArrayList<>(Collections.nCopies(numTotalVariables, KNConstants.KN_INFINITY));
@@ -95,7 +103,10 @@ protected void initializeVariables(VoltageInitializer voltageInitializer, int nu
         }
 
         // Allow subclasses to modify bounds and initial values (e.g., for slack variables)
-        initializeCustomizedVariables(lowerBounds, upperBounds, initialValues, numTotalVariables);
+        initializeCustomizedVariables(lowerBounds, upperBounds, initialValues);
+
+        // Set up scaling factors
+        setUpScalingFactors();
 
         setVarLoBnds(lowerBounds);
         setVarUpBnds(upperBounds);
@@ -110,10 +121,18 @@ protected void initializeVariables(VoltageInitializer voltageInitializer, int nu
      * @param lowerBounds Lower bounds list to modify.
      * @param upperBounds Upper bounds list to modify.
      * @param initialValues Initial values list to modify.
-     * @param numTotalVariables Total number of variables.
      */
     protected void initializeCustomizedVariables(List<Double> lowerBounds, List<Double> upperBounds,
-                                                 List<Double> initialValues, int numTotalVariables) {
+                                                 List<Double> initialValues) {
+        // no customization by default
+    }
+
+    /**
+     * Allows subclasses to utilize scaling.
+     * Default implementation does nothing.
+     *
+     */
+    protected void setUpScalingFactors() throws KNException {
         // no customization by default
     }
 
@@ -131,7 +150,7 @@ protected void setupConstraints() throws KNException {
         NonLinearExternalSolverUtils solverUtils = new NonLinearExternalSolverUtils();
 
         // add linear constraints and fill the list of non-linear constraints
-        addLinearConstraints(activeConstraints, solverUtils, nonlinearConstraintIndexes);
+        addLinearConstraints(activeConstraints, solverUtils);
 
         // pass to Knitro the indexes of non-linear constraints, that will be evaluated in the callback function
         setMainCallbackCstIndexes(nonlinearConstraintIndexes);
@@ -145,14 +164,12 @@ protected void setupConstraints() throws KNException {
      *
      * @param sortedEquationsToSolve Sorted list of equations to solve.
      * @param solverUtils Utilities to extract linear constraints.
-     * @param nonLinearConstraintIds Output list of indices of non-linear constraints.
      */
     protected void addLinearConstraints(List<Equation<AcVariableType, AcEquationType>> sortedEquationsToSolve,
-                                        NonLinearExternalSolverUtils solverUtils,
-                                        List<Integer> nonLinearConstraintIds) {
+                                        NonLinearExternalSolverUtils solverUtils) {
 
         for (int equationId = 0; equationId < sortedEquationsToSolve.size(); equationId++) {
-            addConstraint(equationId, sortedEquationsToSolve, solverUtils, nonLinearConstraintIds);
+            addConstraint(equationId, sortedEquationsToSolve, solverUtils);
         }
     }
 
@@ -163,10 +180,9 @@ protected void addLinearConstraints(List<Equation<AcVariableType, AcEquationType
      * @param equationId Index of the equation in the list.
      * @param sortedEquationsToSolve List of all equations to solve.
      * @param solverUtils Utilities to extract linear constraint components.
-     * @param nonLinearConstraintIds Output list of non-linear constraint indices.
      */
     protected void addConstraint(int equationId, List<Equation<AcVariableType, AcEquationType>> sortedEquationsToSolve,
-                                 NonLinearExternalSolverUtils solverUtils, List<Integer> nonLinearConstraintIds) {
+                                 NonLinearExternalSolverUtils solverUtils) {
 
         Equation<AcVariableType, AcEquationType> equation = sortedEquationsToSolve.get(equationId);
         AcEquationType equationType = equation.getType();
@@ -190,7 +206,7 @@ protected void addConstraint(int equationId, List<Equation<AcVariableType, AcEqu
                 throw new PowsyblException("Failed to process linear constraint for equation #" + equationId, e);
             }
         } else {
-            nonLinearConstraintIds.add(equationId);
+            nonlinearConstraintIndexes.add(equationId);
         }
     }
 

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

@@ -33,7 +33,7 @@
  *      - Configuration of the external Knitro solver.
  *      - Creation of the optimization problem (extending {@link AbstractKnitroProblem}).
  *      - Processing of the obtained solution.
- * This class can be extended to add custom behavior to any of these features (e.g., in {@link RelaxedKnitroSolver}).
+ * This class can be extended to add custom behavior to any of these features (e.g., in {@link AbstractRelaxedKnitroSolver}).
  * For example, if you modify the optimization problem, you may also need to update the solution-processing logic.
  *
  * @author Pierre Arvy {@literal <pierre.arvy at artelys.com>}