Resilient knitro solver implementation

.gitignore

@@ -18,3 +18,6 @@ org.eclipse.jdt.groovy.core.prefs
 
 # Generated readthedocs pages
 build-docs/
+
+# Testing
+outputs

README.md

@@ -29,7 +29,7 @@ By participating, you are expected to uphold this code. Please report unacceptab
 PowSyBl Open Load Flow Knitro Solver is an extension to [PowSyBl Open Load Flow](https://github.com/powsybl/powsybl-open-loadflow) allowing to solve
 the load flow equations with the **non-linear solver Knitro** instead of the default **Newton-Raphson** method.
 
-The Knitro solver extension models the load flow problem as a **constraint satisfaction problem** (without an objective function).
+The Knitro solver extension offers two different ways to model the load flow problem: either as a **constraint satisfaction problem** (without an objective function) or as an **optimisation problem** with relaxed constraints (and an objective function minimizing the violations). 
 
 ## Getting Started
 
@@ -168,29 +168,36 @@ parameters.addExtension(KnitroLoadFlowParameters.class, knitroLoadFlowParameters
 
 ### Knitro Parameters
 
-1. **Voltage Bounds**:
+1. **Knitro Solver Type**:
+    - Specifies the way to model the load flow problem : 
+    - **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 `setKnitroSolverType` in the `KnitroLoadFlowParameters` extension.
+
+2. **Voltage Bounds**:
     - Default range: **0.5 p.u. to 1.5 p.u.** : they define lower and upper bounds of voltages.
     - Modify using:
         - `setLowerVoltageBound`
         - `setUpperVoltageBound`
 
-2. **Jacobian Matrix Usage**:
+3. **Jacobian Matrix Usage**:
     - The solver utilizes the **Jacobian matrix** for solving successive linear approximations of the problem.
     - **Gradient Computation Modes**:
         - `1 (exact)`: Gradients computed in PowSyBl are provided to Knitro.
         - `2 (forward)`: Knitro computes gradients via forward finite differences.
         - `3 (central)`: Knitro computes gradients via central finite differences.
     - Use `setGradientComputationMode` in the `KnitroLoadFlowParameters` extension.
 
-3. **Jacobian Sparsity**:
+4. **Jacobian Sparsity**:
     - Default: **Sparse form** (highly recommended, improves calculation as load flow problems are highly sparse problems).
     - To specify dense form:
         - Use `setGradientUserRoutineKnitro` in the `KnitroLoadFlowParameters` extension.
     - **Options**:
         - `1 (dense)`: All constraints are considered as dependent of all variables.
         - `2 (sparse)`: Derivatives are computed only for variables involved in the constraints (recommended).
 
-4. **Maximum Iterations**:
+5. **Maximum Iterations**:
     - Default: **200**
     - Modify using `setMaxIterations`.
 

pom.xml

@@ -39,6 +39,24 @@
             <organization>Artelys</organization>
             <organizationUrl>http://www.artelys.com</organizationUrl>
         </developer>
+        <developer>
+            <name>Martin Debouté</name>
+            <email>[email protected]</email>
+            <organization>Artelys</organization>
+            <organizationUrl>http://www.artelys.com</organizationUrl>
+        </developer>
+        <developer>
+            <name>Amine Makhen</name>
+            <email>[email protected]</email>
+            <organization>Artelys</organization>
+            <organizationUrl>http://www.artelys.com</organizationUrl>
+        </developer>
+        <developer>
+            <name>Pierre Arvy</name>
+            <email>[email protected]</email>
+            <organization>Artelys</organization>
+            <organizationUrl>http://www.artelys.com</organizationUrl>
+        </developer>
     </developers>
 
     <properties>
@@ -85,6 +103,11 @@
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
+            <dependency>
+                <groupId>org.slf4j</groupId>
+                <artifactId>slf4j-simple</artifactId>
+                <version>2.0.13</version>
+            </dependency>
         </dependencies>
     </dependencyManagement>
 

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

@@ -0,0 +1,187 @@
+/**
+ * Copyright (c) 2024, 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.artelys.knitro.api.*;
+import com.powsybl.commons.PowsyblException;
+import com.powsybl.commons.report.ReportNode;
+import com.powsybl.openloadflow.ac.equations.AcEquationType;
+import com.powsybl.openloadflow.ac.equations.AcVariableType;
+import com.powsybl.openloadflow.ac.solver.AbstractAcSolver;
+import com.powsybl.openloadflow.ac.solver.AcSolverResult;
+import com.powsybl.openloadflow.ac.solver.AcSolverStatus;
+import com.powsybl.openloadflow.ac.solver.AcSolverUtil;
+import com.powsybl.openloadflow.equations.*;
+import com.powsybl.openloadflow.network.LfBus;
+import com.powsybl.openloadflow.network.LfNetwork;
+import com.powsybl.openloadflow.network.util.VoltageInitializer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+
+import static com.google.common.primitives.Doubles.toArray;
+
+/**
+ * Abstract base class for Knitro solvers, providing common functionality.
+ *
+ * @author Pierre Arvy {@literal <pierre.arvy at artelys.com>}
+ * @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 abstract class AbstractKnitroSolver extends AbstractAcSolver {
+
+    protected static final Logger LOGGER = LoggerFactory.getLogger(AbstractKnitroSolver.class);
+
+    protected KnitroSolverParameters knitroParameters;
+
+    public AbstractKnitroSolver(LfNetwork network, KnitroSolverParameters knitroParameters,
+                                EquationSystem<AcVariableType, AcEquationType> equationSystem,
+                                JacobianMatrix<AcVariableType, AcEquationType> j, TargetVector<AcVariableType, AcEquationType> targetVector,
+                                EquationVector<AcVariableType, AcEquationType> equationVector,
+                                boolean detailedReport) {
+
+        super(network, equationSystem, j, targetVector, equationVector, detailedReport);
+        this.knitroParameters = knitroParameters;
+    }
+
+    /**
+     * Sets Knitro solver parameters based on the provided KnitroSolverParameters object.
+     * Uses the improved parameter set from RelaxedKnitroSolver.
+     *
+     * @param solver The Knitro solver instance to configure.
+     * @throws KNException if Knitro fails to accept a parameter.
+     */
+    protected void setSolverParameters(KNSolver solver) throws KNException {
+        LOGGER.info("Configuring Knitro solver parameters...");
+
+        solver.setParam(KNConstants.KN_PARAM_GRADOPT, knitroParameters.getGradientComputationMode());
+        solver.setParam(KNConstants.KN_PARAM_FEASTOL, knitroParameters.getRelConvEps());
+        solver.setParam(KNConstants.KN_PARAM_FEASTOLABS, knitroParameters.getAbsConvEps());
+        solver.setParam(KNConstants.KN_PARAM_OPTTOL, knitroParameters.getRelOptEps());
+        solver.setParam(KNConstants.KN_PARAM_OPTTOLABS, knitroParameters.getAbsOptEps());
+        solver.setParam(KNConstants.KN_PARAM_MAXIT, knitroParameters.getMaxIterations());
+        solver.setParam(KNConstants.KN_PARAM_HESSOPT, knitroParameters.getHessianComputationMode());
+        solver.setParam(KNConstants.KN_PARAM_SOLTYPE, KNConstants.KN_SOLTYPE_BESTFEAS);
+        solver.setParam(KNConstants.KN_PARAM_OUTLEV, 3);
+
+        LOGGER.info("Knitro parameters set: GRADOPT={}, HESSOPT={}, FEASTOL={}, OPTTOL={}, MAXIT={}",
+                knitroParameters.getGradientComputationMode(),
+                knitroParameters.getHessianComputationMode(),
+                knitroParameters.getRelConvEps(),
+                knitroParameters.getRelOptEps(),
+                knitroParameters.getMaxIterations());
+    }
+
+    /**
+     * Creates the Knitro problem instance. Must be implemented by subclasses.
+     *
+     * @param voltageInitializer The voltage initializer to use.
+     * @return The created Knitro problem instance.
+     * @throws KNException if an error occurs while creating the problem.
+     */
+    protected abstract KNProblem createKnitroProblem(VoltageInitializer voltageInitializer);
+
+    /**
+     * Processes the solution after solving. Can be overridden by subclasses for additional processing.
+     *
+     * @param solver The Knitro solver instance.
+     * @param solution The solution obtained from Knitro.
+     * @param problemInstance The problem instance.
+     */
+    protected void processSolution(KNSolver solver, KNSolution solution, KNProblem problemInstance) {
+        // Default implementation: log solution details
+        LOGGER.info("==== Solution Summary ====");
+        LOGGER.info("Objective value            = {}", solution.getObjValue());
+        try {
+            LOGGER.info("Feasibility violation      = {}", solver.getAbsFeasError());
+            LOGGER.info("Optimality violation       = {}", solver.getAbsOptError());
+
+            LOGGER.debug("Optimal x");
+            for (int i = 0; i < solution.getX().size(); i++) {
+                LOGGER.debug(" x[{}] = {}", i, solution.getX().get(i));
+            }
+            LOGGER.debug("Optimal constraint values (with corresponding multiplier)");
+            List<Double> constraintValues = solver.getConstraintValues();
+            for (int i = 0; i < problemInstance.getNumCons(); i++) {
+                LOGGER.debug(" c[{}] = {} (lambda = {} )", i, constraintValues.get(i), solution.getLambda().get(i));
+            }
+            LOGGER.debug("Constraint violation");
+            for (int i = 0; i < problemInstance.getNumCons(); i++) {
+                LOGGER.debug(" violation[{}] = {} ", i, solver.getConViol(i));
+            }
+        } catch (KNException e) {
+            LOGGER.warn("Failed to get some solution details", e);
+        }
+    }
+
+    /**
+     * Gets the solution from the solver. Can be overridden by subclasses.
+     *
+     * @param solver The Knitro solver instance.
+     * @return The solution.
+     */
+    protected KNSolution getSolution(KNSolver solver) {
+        return solver.getSolution();
+    }
+
+    /**
+     * Updates the network with the solution if required.
+     *
+     * @param solution The solution to apply.
+     * @param solverStatus The solver status.
+     */
+    protected void updateNetworkIfRequired(KNSolution solution, AcSolverStatus solverStatus) {
+        if (solverStatus == AcSolverStatus.CONVERGED || knitroParameters.isAlwaysUpdateNetwork()) {
+            equationSystem.getStateVector().set(toArray(solution.getX()));
+            for (Equation<AcVariableType, AcEquationType> equation : equationSystem.getEquations()) {
+                for (EquationTerm<AcVariableType, AcEquationType> term : equation.getTerms()) {
+                    term.setStateVector(equationSystem.getStateVector());
+                }
+            }
+            AcSolverUtil.updateNetwork(network, equationSystem);
+        }
+    }
+
+    @Override
+    public AcSolverResult run(VoltageInitializer voltageInitializer, ReportNode reportNode) {
+        int nbIter;
+        AcSolverStatus acStatus;
+        KNProblem instance;
+
+        try {
+            instance = createKnitroProblem(voltageInitializer);
+        } catch (Exception e) {
+            throw new PowsyblException("Exception while trying to build Knitro Problem", e);
+        }
+
+        try (KNSolver solver = new KNSolver(instance)) {
+            solver.initProblem();
+            setSolverParameters(solver);
+            solver.solve();
+
+            KNSolution solution = getSolution(solver);
+            acStatus = KnitroStatus.fromStatusCode(solution.getStatus()).toAcSolverStatus();
+            NonLinearExternalSolverUtils.logKnitroStatus(KnitroStatus.fromStatusCode(solution.getStatus()));
+            nbIter = solver.getNumberIters();
+
+            processSolution(solver, solution, instance);
+            updateNetworkIfRequired(solution, acStatus);
+
+        } catch (KNException e) {
+            throw new PowsyblException("Exception while trying to solve with Knitro", e);
+        }
+
+        double slackBusActivePowerMismatch = network.getSlackBuses().stream()
+                .mapToDouble(LfBus::getMismatchP)
+                .sum();
+        return new AcSolverResult(acStatus, nbIter, slackBusActivePowerMismatch);
+    }
+}
+