Newton raphson new stopping criteria

src/main/java/com/powsybl/openloadflow/ac/nr/DefaultNewtonRaphsonStoppingCriteria.java

@@ -6,6 +6,9 @@
  */
 package com.powsybl.openloadflow.ac.nr;
 
+import com.powsybl.openloadflow.ac.equations.AcEquationType;
+import com.powsybl.openloadflow.ac.equations.AcVariableType;
+import com.powsybl.openloadflow.equations.EquationSystem;
 import com.powsybl.openloadflow.equations.Vectors;
 import net.jafama.FastMath;
 
@@ -30,7 +33,7 @@ public DefaultNewtonRaphsonStoppingCriteria(double convEpsPerEq) {
     }
 
     @Override
-    public TestResult test(double[] fx) {
+    public TestResult test(double[] fx, EquationSystem<AcVariableType, AcEquationType> equationSystem) {
         // calculate norm L2 of equations mismatch vector
         double norm = Vectors.norm2(fx);
         boolean stop = norm < FastMath.sqrt(convEpsPerEq * convEpsPerEq * fx.length);

src/main/java/com/powsybl/openloadflow/ac/nr/LineSearchStateVectorScaling.java

@@ -49,11 +49,12 @@ public void apply(double[] dx, EquationSystem<AcVariableType, AcEquationType> eq
     }
 
     @Override
-    public NewtonRaphsonStoppingCriteria.TestResult applyAfter(StateVector stateVector,
+    public NewtonRaphsonStoppingCriteria.TestResult applyAfter(EquationSystem<AcVariableType, AcEquationType> equationSystem,
                                                                EquationVector<AcVariableType, AcEquationType> equationVector,
                                                                TargetVector<AcVariableType, AcEquationType> targetVector,
                                                                NewtonRaphsonStoppingCriteria stoppingCriteria,
                                                                NewtonRaphsonStoppingCriteria.TestResult testResult) {
+        StateVector stateVector = equationSystem.getStateVector();
         if (lastTestResult != null) {
             double stepSize = 1;
             NewtonRaphsonStoppingCriteria.TestResult currentTestResult = testResult;
@@ -78,7 +79,7 @@ public NewtonRaphsonStoppingCriteria.TestResult applyAfter(StateVector stateVect
                 equationVector.minus(targetVector);
 
                 // and recompute new norm
-                currentTestResult = stoppingCriteria.test(equationVector.getArray());
+                currentTestResult = stoppingCriteria.test(equationVector.getArray(), equationSystem);
 
                 iteration++;
             }

src/main/java/com/powsybl/openloadflow/ac/nr/MaxVoltageChangeStateVectorScaling.java

@@ -12,7 +12,6 @@
 import com.powsybl.openloadflow.ac.equations.AcVariableType;
 import com.powsybl.openloadflow.equations.EquationSystem;
 import com.powsybl.openloadflow.equations.EquationVector;
-import com.powsybl.openloadflow.equations.StateVector;
 import com.powsybl.openloadflow.equations.TargetVector;
 import com.powsybl.openloadflow.equations.Vectors;
 import org.slf4j.Logger;
@@ -80,7 +79,7 @@ public void apply(double[] dx, EquationSystem<AcVariableType, AcEquationType> eq
     }
 
     @Override
-    public NewtonRaphsonStoppingCriteria.TestResult applyAfter(StateVector stateVector,
+    public NewtonRaphsonStoppingCriteria.TestResult applyAfter(EquationSystem<AcVariableType, AcEquationType> equationSystem,
                                                                EquationVector<AcVariableType, AcEquationType> equationVector,
                                                                TargetVector<AcVariableType, AcEquationType> targetVector,
                                                                NewtonRaphsonStoppingCriteria stoppingCriteria,

src/main/java/com/powsybl/openloadflow/ac/nr/NewtonRaphson.java

@@ -96,9 +96,9 @@ private NewtonRaphsonStatus runIteration(StateVectorScaling svScaling) {
             }
 
             // test stopping criteria and log norm(fx)
-            NewtonRaphsonStoppingCriteria.TestResult testResult = parameters.getStoppingCriteria().test(equationVector.getArray());
+            NewtonRaphsonStoppingCriteria.TestResult testResult = parameters.getStoppingCriteria().test(equationVector.getArray(), equationSystem);
 
-            testResult = svScaling.applyAfter(equationSystem.getStateVector(), equationVector, targetVector,
+            testResult = svScaling.applyAfter(equationSystem, equationVector, targetVector,
                                               parameters.getStoppingCriteria(), testResult);
 
             LOGGER.debug("|f(x)|={}", testResult.getNorm());
@@ -214,7 +214,7 @@ public NewtonRaphsonResult run(VoltageInitializer voltageInitializer) {
 
         Vectors.minus(equationVector.getArray(), targetVector.getArray());
 
-        NewtonRaphsonStoppingCriteria.TestResult initialTestResult = parameters.getStoppingCriteria().test(equationVector.getArray());
+        NewtonRaphsonStoppingCriteria.TestResult initialTestResult = parameters.getStoppingCriteria().test(equationVector.getArray(), equationSystem);
         LOGGER.debug("|f(x0)|={}", initialTestResult.getNorm());
 
         StateVectorScaling svScaling = StateVectorScaling.fromMode(parameters.getStateVectorScalingMode(), initialTestResult);

src/main/java/com/powsybl/openloadflow/ac/nr/NewtonRaphsonStoppingCriteria.java

@@ -6,6 +6,10 @@
  */
 package com.powsybl.openloadflow.ac.nr;
 
+import com.powsybl.openloadflow.ac.equations.AcEquationType;
+import com.powsybl.openloadflow.ac.equations.AcVariableType;
+import com.powsybl.openloadflow.equations.EquationSystem;
+
 /**
  * @author Geoffroy Jamgotchian <geoffroy.jamgotchian at rte-france.com>
  */
@@ -31,5 +35,5 @@ public double getNorm() {
         }
     }
 
-    TestResult test(double[] fx);
+    TestResult test(double[] fx, EquationSystem<AcVariableType, AcEquationType> equationSystem);
 }

src/main/java/com/powsybl/openloadflow/ac/nr/NewtonRaphsonStoppingCriteriaType.java

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2023, Coreso SA (https://www.coreso.eu/) and TSCNET Services GmbH (https://www.tscnet.eu/)
+ * 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.ac.nr;
+
+/**
+ * @author Alexandre Le Jean <alexandre.le-jean at artelys.com>
+ */
+public enum NewtonRaphsonStoppingCriteriaType {
+    UNIFORM_CRITERIA,
+    PER_EQUATION_TYPE_CRITERIA
+}

src/main/java/com/powsybl/openloadflow/ac/nr/NoneStateVectorScaling.java

@@ -11,7 +11,6 @@
 import com.powsybl.openloadflow.ac.equations.AcVariableType;
 import com.powsybl.openloadflow.equations.EquationSystem;
 import com.powsybl.openloadflow.equations.EquationVector;
-import com.powsybl.openloadflow.equations.StateVector;
 import com.powsybl.openloadflow.equations.TargetVector;
 
 /**
@@ -30,7 +29,7 @@ public void apply(double[] dx, EquationSystem<AcVariableType, AcEquationType> eq
     }
 
     @Override
-    public NewtonRaphsonStoppingCriteria.TestResult applyAfter(StateVector stateVector,
+    public NewtonRaphsonStoppingCriteria.TestResult applyAfter(EquationSystem<AcVariableType, AcEquationType> equationSystem,
                                                                EquationVector<AcVariableType, AcEquationType> equationVector,
                                                                TargetVector<AcVariableType, AcEquationType> targetVector,
                                                                NewtonRaphsonStoppingCriteria stoppingCriteria,

src/main/java/com/powsybl/openloadflow/ac/nr/PerEquationTypeStoppingCriteria.java

@@ -0,0 +1,107 @@
+/**
+ * Copyright (c) 2023, Coreso SA (https://www.coreso.eu/) and TSCNET Services GmbH (https://www.tscnet.eu/)
+ * 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.ac.nr;
+
+import com.powsybl.commons.PowsyblException;
+import com.powsybl.openloadflow.ac.equations.AcEquationType;
+import com.powsybl.openloadflow.ac.equations.AcVariableType;
+import com.powsybl.openloadflow.equations.EquationSystem;
+import com.powsybl.openloadflow.equations.Vectors;
+import com.powsybl.openloadflow.util.PerUnit;
+
+/**
+ * @author Alexandre Le Jean <alexandre.le-jean at artelys.com>
+ */
+public class PerEquationTypeStoppingCriteria implements NewtonRaphsonStoppingCriteria {
+
+    private final double maxDefaultAngleMismatch;
+
+    private final double maxDefaultRatioMismatch;
+
+    private final double maxDefaultSusceptanceMismatch;
+
+    private final double maxActivePowerMismatch;
+
+    private final double maxReactivePowerMismatch;
+
+    private final double maxVoltageMismatch;
+
+    public PerEquationTypeStoppingCriteria(double maxActivePowerMismatch,
+                                           double maxReactivePowerMismatch, double maxVoltageMismatch,
+                                           double maxDefaultAngleMismatch, double maxDefaultRatioMismatch,
+                                           double maxDefaultSusceptanceMismatch) {
+        this.maxActivePowerMismatch = maxActivePowerMismatch;
+        this.maxReactivePowerMismatch = maxReactivePowerMismatch;
+        this.maxVoltageMismatch = maxVoltageMismatch;
+        this.maxDefaultAngleMismatch = maxDefaultAngleMismatch;
+        this.maxDefaultRatioMismatch = maxDefaultRatioMismatch;
+        this.maxDefaultSusceptanceMismatch = maxDefaultSusceptanceMismatch;
+    }
+
+    private double computeNorm(double[] fx) {
+        return Vectors.norm2(fx);
+    }
+
+    private boolean computeStop(double[] fx, EquationSystem<AcVariableType, AcEquationType> equationSystem) {
+        for (var eq : equationSystem.getIndex().getSortedEquationsToSolve()) {
+            var type = eq.getType();
+            var idx = eq.getColumn();
+            switch (type) {
+                case BRANCH_TARGET_P:
+                case BUS_TARGET_P:
+                case DUMMY_TARGET_P:
+                    if (Math.abs(fx[idx]) * PerUnit.SB >= maxActivePowerMismatch) {
+                        return false;
+                    }
+                    break;
+                case BRANCH_TARGET_Q:
+                case BUS_TARGET_Q:
+                case DISTR_Q:
+                case DUMMY_TARGET_Q:
+                    if (Math.abs(fx[idx]) * PerUnit.SB >= maxReactivePowerMismatch) {
+                        return false;
+                    }
+                    break;
+                case BUS_TARGET_V:
+                case BUS_TARGET_V_WITH_SLOPE:
+                case ZERO_V:
+                    if (Math.abs(fx[idx]) >= maxVoltageMismatch) {
+                        return false;
+                    }
+                    break;
+                case BRANCH_TARGET_RHO1:
+                case DISTR_RHO:
+                    if (Math.abs(fx[idx]) >= maxDefaultRatioMismatch) {
+                        return false;
+                    }
+                    break;
+                case DISTR_SHUNT_B:
+                case SHUNT_TARGET_B:
+                    if (Math.abs(fx[idx]) >= maxDefaultSusceptanceMismatch) {
+                        return false;
+                    }
+                    break;
+                case BUS_TARGET_PHI:
+                case ZERO_PHI:
+                case BRANCH_TARGET_ALPHA1:
+                    if (Math.abs(fx[idx]) >= maxDefaultAngleMismatch) {
+                        return false;
+                    }
+                    break;
+                default:
+                    throw new PowsyblException("Unknown equation term");
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public TestResult test(double[] fx, EquationSystem<AcVariableType, AcEquationType> equationSystem) {
+        return new TestResult(computeStop(fx, equationSystem), computeNorm(fx));
+    }
+}

src/main/java/com/powsybl/openloadflow/ac/nr/StateVectorScaling.java

@@ -11,7 +11,6 @@
 import com.powsybl.openloadflow.ac.equations.AcVariableType;
 import com.powsybl.openloadflow.equations.EquationSystem;
 import com.powsybl.openloadflow.equations.EquationVector;
-import com.powsybl.openloadflow.equations.StateVector;
 import com.powsybl.openloadflow.equations.TargetVector;
 
 import java.util.Objects;
@@ -48,7 +47,7 @@ static StateVectorScaling fromMode(StateVectorScalingMode mode, NewtonRaphsonSto
     /**
      * Apply scaling to state vector after equation mismatches and norm have been calculated.
      */
-    NewtonRaphsonStoppingCriteria.TestResult applyAfter(StateVector stateVector,
+    NewtonRaphsonStoppingCriteria.TestResult applyAfter(EquationSystem<AcVariableType, AcEquationType> equationSystem,
                                                         EquationVector<AcVariableType, AcEquationType> equationVector,
                                                         TargetVector<AcVariableType, AcEquationType> targetVector,
                                                         NewtonRaphsonStoppingCriteria stoppingCriteria,

src/test/java/com/powsybl/openloadflow/OpenLoadFlowParametersTest.java

@@ -8,6 +8,7 @@
 
 import com.google.common.jimfs.Configuration;
 import com.google.common.jimfs.Jimfs;
+import com.powsybl.commons.PowsyblException;
 import com.powsybl.commons.config.InMemoryPlatformConfig;
 import com.powsybl.commons.config.MapModuleConfig;
 import com.powsybl.commons.config.PlatformConfig;
@@ -115,6 +116,22 @@ void testInvalidOpenLoadflowConfig() {
         assertEquals("No enum constant com.powsybl.openloadflow.network.SlackBusSelectionMode.Invalid", exception.getMessage());
     }
 
+    @Test
+    void testInvalidOpenLoadflowConfigNewtonRaphson() {
+        MapModuleConfig olfModuleConfig = platformConfig.createModuleConfig("open-loadflow-default-parameters");
+        olfModuleConfig.setStringProperty("newtonRaphsonStoppingCriteriaType", "Invalid");
+
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> LoadFlowParameters.load(platformConfig));
+        assertEquals("No enum constant com.powsybl.openloadflow.ac.nr.NewtonRaphsonStoppingCriteriaType.Invalid", exception.getMessage());
+
+        OpenLoadFlowParameters openLoadFlowParameters = OpenLoadFlowParameters.create(new LoadFlowParameters());
+        assertThrows(PowsyblException.class, () -> openLoadFlowParameters.setMaxAngleMismatch(-1));
+        assertThrows(PowsyblException.class, () -> openLoadFlowParameters.setMaxVoltageMismatch(-1));
+        assertThrows(PowsyblException.class, () -> openLoadFlowParameters.setMaxRatioMismatch(-1));
+        assertThrows(PowsyblException.class, () -> openLoadFlowParameters.setMaxActivePowerMismatch(-1));
+        assertThrows(PowsyblException.class, () -> openLoadFlowParameters.setMaxReactivePowerMismatch(-1));
+    }
+
     @Test
     void testFirstSlackBusSelector() throws IOException {
         Path cfgDir = Files.createDirectory(fileSystem.getPath("config"));

src/test/java/com/powsybl/openloadflow/OpenLoadFlowProviderTest.java

@@ -85,7 +85,7 @@ void testGetExtendedVoltageInitializer() {
     @Test
     void specificParametersTest() {
         OpenLoadFlowProvider provider = new OpenLoadFlowProvider();
-        assertEquals(30, provider.getSpecificParameters().size());
+        assertEquals(37, provider.getSpecificParameters().size());
         LoadFlowParameters parameters = new LoadFlowParameters();
 
         provider.loadSpecificParameters(Collections.emptyMap())