From 5bee729aa0d814d5fd0a7a785f8395862ccecf05 Mon Sep 17 00:00:00 2001 From: Pauline Jean-Marie Date: Wed, 23 Oct 2024 17:20:12 +0200 Subject: [PATCH] wip for range actions --- .../openrao/raoapi/RaoParametersCommons.java | 12 +- ...sonRangeActionsOptimizationParameters.java | 100 +------- .../JsonOpenRaoSearchTreeParameters.java | 69 +++++ ...sonRangeActionsOptimizationParameters.java | 121 +++++++++ .../RangeActionsOptimizationParameters.java | 194 ++------------ .../OpenRaoSearchTreeParameters.java | 32 +++ ...enRaoSearchTreeParametersConfigLoader.java | 55 ++++ .../RangeActionsOptimizationParameters.java | 241 ++++++++++++++++++ .../raoapi/json/JsonRaoParametersTest.java | 39 +-- .../parameters/RaoParametersConfigTest.java | 56 ++-- .../RaoParametersConsistencyTest.java | 17 +- .../RaoParametersYamlConfigTest.java | 77 +++--- .../RaoParametersWithExtension_v2.json | 19 +- .../RaoParameters_config_withOLFParams.json | 17 -- ...aoParameters_config_withoutExtensions.json | 17 -- .../src/test/resources/RaoParameters_v2.json | 17 -- .../test/resources/config_withExtensions.yml | 13 +- .../config_withPartialExtensions.yml | 10 +- .../resources/config_withoutExtensions.yml | 15 +- .../searchtreerao/commons/RaoUtil.java | 5 +- .../commons/parameters/TreeParameters.java | 10 +- .../algorithms/IteratingLinearOptimizer.java | 7 +- .../algorithms/fillers/CoreProblemFiller.java | 25 +- .../linearproblem/LinearProblem.java | 2 +- .../linearproblem/LinearProblemBuilder.java | 15 +- .../linearproblem/OpenRaoMPSolver.java | 2 +- .../IteratingLinearOptimizerParameters.java | 26 +- .../searchtree/algorithms/Leaf.java | 1 + .../parameters/SearchTreeParameters.java | 30 ++- .../searchtreerao/commons/RaoUtilTest.java | 6 +- .../parameters/TreeParametersTest.java | 22 +- .../IteratingLinearOptimizerTest.java | 3 +- .../algorithms/LinearProblemBuilderTest.java | 19 +- .../algorithms/LinearProblemTest.java | 2 +- .../ContinuousRangeActionGroupFillerTest.java | 7 +- .../fillers/CoreProblemFillerTest.java | 17 +- .../fillers/DiscretePstGroupFillerTest.java | 12 +- .../fillers/DiscretePstTapFillerTest.java | 12 +- .../fillers/MaxLoopFlowFillerTest.java | 6 +- .../fillers/MaxMinMarginFillerTest.java | 19 +- .../MaxMinRelativeMarginFillerTest.java | 14 +- .../algorithms/fillers/MnecFillerTest.java | 19 +- .../fillers/RaUsageLimitsFillerTest.java | 40 +-- ...mizedCnecFillerMarginDecreaseRuleTest.java | 12 +- .../linearproblem/OpenRaoMPSolverTest.java | 2 +- .../parameters/SearchTreeParametersTest.java | 12 +- .../openrao/tests/steps/CommonTestData.java | 14 - 47 files changed, 867 insertions(+), 615 deletions(-) create mode 100644 ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/json/extensions/JsonOpenRaoSearchTreeParameters.java create mode 100644 ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/json/extensions/JsonRangeActionsOptimizationParameters.java create mode 100644 ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/extensions/OpenRaoSearchTreeParameters.java create mode 100644 ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/extensions/OpenRaoSearchTreeParametersConfigLoader.java create mode 100644 ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/extensions/RangeActionsOptimizationParameters.java diff --git a/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/RaoParametersCommons.java b/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/RaoParametersCommons.java index 39c2376957..9f46292cae 100644 --- a/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/RaoParametersCommons.java +++ b/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/RaoParametersCommons.java @@ -31,16 +31,18 @@ private RaoParametersCommons() { // range actions optimization parameters public static final String RANGE_ACTIONS_OPTIMIZATION = "range-actions-optimization"; public static final String RANGE_ACTIONS_OPTIMIZATION_SECTION = "rao-range-actions-optimization"; + public static final String ST_RANGE_ACTIONS_OPTIMIZATION_SECTION = "search-tree-range-actions-optimization"; + public static final String MAX_MIP_ITERATIONS = "max-mip-iterations"; - public static final String PST_PENALTY_COST = "pst-penalty-cost"; + public static final String PST_RA_MIN_IMPACT_THRESHOLD = "pst-ra-min-impact-threshold"; public static final String PST_SENSITIVITY_THRESHOLD = "pst-sensitivity-threshold"; public static final String PST_MODEL = "pst-model"; - public static final String HVDC_PENALTY_COST = "hvdc-penalty-cost"; + public static final String HVDC_RA_MIN_IMPACT_THRESHOLD = "hvdc-ra-min-impact-threshold"; public static final String HVDC_SENSITIVITY_THRESHOLD = "hvdc-sensitivity-threshold"; - public static final String INJECTION_RA_PENALTY_COST = "injection-ra-penalty-cost"; + public static final String INJECTION_RA_MIN_IMPACT_THRESHOLD = "injection-ra-min-impact-threshold"; public static final String INJECTION_RA_SENSITIVITY_THRESHOLD = "injection-ra-sensitivity-threshold"; public static final String LINEAR_OPTIMIZATION_SOLVER = "linear-optimization-solver"; - public static final String LINEAR_OPTIMIZATION_SOLVER_SECTION = "rao-linear-optimization-solver"; + public static final String LINEAR_OPTIMIZATION_SOLVER_SECTION = "search-tree-linear-optimization-solver"; public static final String SOLVER = "solver"; public static final String RELATIVE_MIP_GAP = "relative-mip-gap"; public static final String SOLVER_SPECIFIC_PARAMETERS = "solver-specific-parameters"; @@ -120,6 +122,8 @@ private RaoParametersCommons() { public static final String PTDF_BOUNDARIES = "ptdf-boundaries"; public static final String PTDF_SUM_LOWER_BOUND = "ptdf-sum-lower-bound"; + public static final String SEARCH_TREE_PARAMETERS = "open-rao-search-tree-parameters"; + public static PtdfApproximation stringToPtdfApproximation(String string) { try { return PtdfApproximation.valueOf(string); diff --git a/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/json/JsonRangeActionsOptimizationParameters.java b/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/json/JsonRangeActionsOptimizationParameters.java index 90dde1a5e2..6d628c1ce9 100644 --- a/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/json/JsonRangeActionsOptimizationParameters.java +++ b/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/json/JsonRangeActionsOptimizationParameters.java @@ -7,7 +7,6 @@ package com.powsybl.openrao.raoapi.json; import com.powsybl.openrao.commons.OpenRaoException; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; import com.powsybl.openrao.raoapi.parameters.RaoParameters; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.core.JsonParser; @@ -26,111 +25,30 @@ private JsonRangeActionsOptimizationParameters() { static void serialize(RaoParameters parameters, JsonGenerator jsonGenerator) throws IOException { jsonGenerator.writeObjectFieldStart(RANGE_ACTIONS_OPTIMIZATION); - jsonGenerator.writeNumberField(MAX_MIP_ITERATIONS, parameters.getRangeActionsOptimizationParameters().getMaxMipIterations()); - jsonGenerator.writeNumberField(PST_PENALTY_COST, parameters.getRangeActionsOptimizationParameters().getPstPenaltyCost()); - jsonGenerator.writeNumberField(PST_SENSITIVITY_THRESHOLD, parameters.getRangeActionsOptimizationParameters().getPstSensitivityThreshold()); - jsonGenerator.writeObjectField(PST_MODEL, parameters.getRangeActionsOptimizationParameters().getPstModel()); - jsonGenerator.writeNumberField(HVDC_PENALTY_COST, parameters.getRangeActionsOptimizationParameters().getHvdcPenaltyCost()); - jsonGenerator.writeNumberField(HVDC_SENSITIVITY_THRESHOLD, parameters.getRangeActionsOptimizationParameters().getHvdcSensitivityThreshold()); - jsonGenerator.writeNumberField(INJECTION_RA_PENALTY_COST, parameters.getRangeActionsOptimizationParameters().getInjectionRaPenaltyCost()); - jsonGenerator.writeNumberField(INJECTION_RA_SENSITIVITY_THRESHOLD, parameters.getRangeActionsOptimizationParameters().getInjectionRaSensitivityThreshold()); - jsonGenerator.writeObjectField(RA_RANGE_SHRINKING, parameters.getRangeActionsOptimizationParameters().getRaRangeShrinking()); - jsonGenerator.writeObjectFieldStart(LINEAR_OPTIMIZATION_SOLVER); - jsonGenerator.writeObjectField(SOLVER, parameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().getSolver()); - jsonGenerator.writeNumberField(RELATIVE_MIP_GAP, parameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().getRelativeMipGap()); - jsonGenerator.writeStringField(SOLVER_SPECIFIC_PARAMETERS, parameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().getSolverSpecificParameters()); - jsonGenerator.writeEndObject(); + jsonGenerator.writeNumberField(PST_RA_MIN_IMPACT_THRESHOLD, parameters.getRangeActionsOptimizationParameters().getPstRAMinImpactThreshold()); + jsonGenerator.writeNumberField(HVDC_RA_MIN_IMPACT_THRESHOLD, parameters.getRangeActionsOptimizationParameters().getHvdcRAMinImpactThreshold()); + jsonGenerator.writeNumberField(INJECTION_RA_MIN_IMPACT_THRESHOLD, parameters.getRangeActionsOptimizationParameters().getInjectionRAMinImpactThreshold()); jsonGenerator.writeEndObject(); } static void deserialize(JsonParser jsonParser, RaoParameters raoParameters) throws IOException { while (!jsonParser.nextToken().isStructEnd()) { switch (jsonParser.getCurrentName()) { - case MAX_MIP_ITERATIONS: + case PST_RA_MIN_IMPACT_THRESHOLD: jsonParser.nextToken(); - raoParameters.getRangeActionsOptimizationParameters().setMaxMipIterations(jsonParser.getIntValue()); + raoParameters.getRangeActionsOptimizationParameters().setPstRAMinImpactThreshold(jsonParser.getDoubleValue()); break; - case PST_PENALTY_COST: + case HVDC_RA_MIN_IMPACT_THRESHOLD: jsonParser.nextToken(); - raoParameters.getRangeActionsOptimizationParameters().setPstPenaltyCost(jsonParser.getDoubleValue()); + raoParameters.getRangeActionsOptimizationParameters().setHvdcRAMinImpactThreshold(jsonParser.getDoubleValue()); break; - case PST_SENSITIVITY_THRESHOLD: + case INJECTION_RA_MIN_IMPACT_THRESHOLD: jsonParser.nextToken(); - raoParameters.getRangeActionsOptimizationParameters().setPstSensitivityThreshold(jsonParser.getDoubleValue()); - break; - case PST_MODEL: - raoParameters.getRangeActionsOptimizationParameters().setPstModel(stringToPstModel(jsonParser.nextTextValue())); - break; - case HVDC_PENALTY_COST: - jsonParser.nextToken(); - raoParameters.getRangeActionsOptimizationParameters().setHvdcPenaltyCost(jsonParser.getDoubleValue()); - break; - case HVDC_SENSITIVITY_THRESHOLD: - jsonParser.nextToken(); - raoParameters.getRangeActionsOptimizationParameters().setHvdcSensitivityThreshold(jsonParser.getDoubleValue()); - break; - case INJECTION_RA_PENALTY_COST: - jsonParser.nextToken(); - raoParameters.getRangeActionsOptimizationParameters().setInjectionRaPenaltyCost(jsonParser.getDoubleValue()); - break; - case INJECTION_RA_SENSITIVITY_THRESHOLD: - jsonParser.nextToken(); - raoParameters.getRangeActionsOptimizationParameters().setInjectionRaSensitivityThreshold(jsonParser.getDoubleValue()); - break; - case LINEAR_OPTIMIZATION_SOLVER: - jsonParser.nextToken(); - deserializeLinearOptimizationSolver(jsonParser, raoParameters); - break; - case RA_RANGE_SHRINKING: - raoParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(stringToRaRangeShrinking(jsonParser.nextTextValue())); + raoParameters.getRangeActionsOptimizationParameters().setInjectionRAMinImpactThreshold(jsonParser.getDoubleValue()); break; default: throw new OpenRaoException(String.format("Cannot deserialize range action optimization parameters: unexpected field in %s (%s)", RANGE_ACTIONS_OPTIMIZATION, jsonParser.getCurrentName())); } } } - - private static void deserializeLinearOptimizationSolver(JsonParser jsonParser, RaoParameters raoParameters) throws IOException { - while (!jsonParser.nextToken().isStructEnd()) { - switch (jsonParser.getCurrentName()) { - case SOLVER: - raoParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().setSolver(stringToSolver(jsonParser.nextTextValue())); - break; - case RELATIVE_MIP_GAP: - jsonParser.nextToken(); - raoParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().setRelativeMipGap(jsonParser.getDoubleValue()); - break; - case SOLVER_SPECIFIC_PARAMETERS: - jsonParser.nextToken(); - raoParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().setSolverSpecificParameters(jsonParser.getValueAsString()); - break; - default: - throw new OpenRaoException(String.format("Cannot deserialize linear optimization solver in range action optimization parameters: unexpected field in %s (%s)", LINEAR_OPTIMIZATION_SOLVER, jsonParser.getCurrentName())); - } - } - } - - private static RangeActionsOptimizationParameters.PstModel stringToPstModel(String string) { - try { - return RangeActionsOptimizationParameters.PstModel.valueOf(string); - } catch (IllegalArgumentException e) { - throw new OpenRaoException(String.format("Unknown Pst model: %s", string)); - } - } - - private static RangeActionsOptimizationParameters.RaRangeShrinking stringToRaRangeShrinking(String string) { - try { - return RangeActionsOptimizationParameters.RaRangeShrinking.valueOf(string); - } catch (IllegalArgumentException e) { - throw new OpenRaoException(String.format("Unknown Pst variation range shrinking: %s", string)); - } - } - - private static RangeActionsOptimizationParameters.Solver stringToSolver(String string) { - try { - return RangeActionsOptimizationParameters.Solver.valueOf(string); - } catch (IllegalArgumentException e) { - throw new OpenRaoException(String.format("Unknown solver: %s", string)); - } - } } diff --git a/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/json/extensions/JsonOpenRaoSearchTreeParameters.java b/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/json/extensions/JsonOpenRaoSearchTreeParameters.java new file mode 100644 index 0000000000..a75e363436 --- /dev/null +++ b/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/json/extensions/JsonOpenRaoSearchTreeParameters.java @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2024, RTE (http://www.rte-france.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.openrao.raoapi.json.extensions; + +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonToken; +import com.fasterxml.jackson.databind.DeserializationContext; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.google.auto.service.AutoService; +import com.powsybl.openrao.commons.OpenRaoException; +import com.powsybl.openrao.raoapi.json.*; +import com.powsybl.openrao.raoapi.parameters.extensions.OpenRaoSearchTreeParameters; + +import java.io.IOException; + +import static com.powsybl.openrao.raoapi.RaoParametersCommons.*; + +@AutoService(JsonRaoParameters.ExtensionSerializer.class) +public class JsonOpenRaoSearchTreeParameters implements JsonRaoParameters.ExtensionSerializer { + @Override + public void serialize(OpenRaoSearchTreeParameters parameters, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + jsonGenerator.writeStartObject(); + JsonRangeActionsOptimizationParameters.serialize(parameters, jsonGenerator); + jsonGenerator.writeEndObject(); + } + + @Override + public OpenRaoSearchTreeParameters deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { + return deserializeAndUpdate(jsonParser, deserializationContext, new OpenRaoSearchTreeParameters()); + } + + @Override + public OpenRaoSearchTreeParameters deserializeAndUpdate(JsonParser parser, DeserializationContext deserializationContext, OpenRaoSearchTreeParameters parameters) throws IOException { + while (parser.nextToken() != JsonToken.END_OBJECT) { + switch (parser.getCurrentName()) { + case RANGE_ACTIONS_OPTIMIZATION: + parser.nextToken(); + JsonRangeActionsOptimizationParameters.deserialize(parser, parameters); + break; + default: + throw new OpenRaoException("Unexpected field in open rao search tree parameters: " + parser.getCurrentName()); + } + } + return parameters; + } + + @Override + public String getExtensionName() { + return SEARCH_TREE_PARAMETERS; + } + + @Override + public String getCategoryName() { + return "rao-parameters"; + } + + @Override + public Class getExtensionClass() { + return OpenRaoSearchTreeParameters.class; + } + +} diff --git a/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/json/extensions/JsonRangeActionsOptimizationParameters.java b/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/json/extensions/JsonRangeActionsOptimizationParameters.java new file mode 100644 index 0000000000..217c89760c --- /dev/null +++ b/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/json/extensions/JsonRangeActionsOptimizationParameters.java @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2023, RTE (http://www.rte-france.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/. + */ +package com.powsybl.openrao.raoapi.json.extensions; + +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.core.JsonParser; +import com.powsybl.openrao.commons.OpenRaoException; +import com.powsybl.openrao.raoapi.parameters.extensions.OpenRaoSearchTreeParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters; + +import java.io.IOException; + +import static com.powsybl.openrao.raoapi.RaoParametersCommons.*; + +/** + * @author Godelaine de Montmorillon {@literal } + */ +final class JsonRangeActionsOptimizationParameters { + + private JsonRangeActionsOptimizationParameters() { + } + + static void serialize(OpenRaoSearchTreeParameters parameters, JsonGenerator jsonGenerator) throws IOException { + jsonGenerator.writeObjectFieldStart(RANGE_ACTIONS_OPTIMIZATION); + jsonGenerator.writeNumberField(MAX_MIP_ITERATIONS, parameters.getRangeActionsOptimizationParameters().getMaxMipIterations()); + jsonGenerator.writeNumberField(PST_SENSITIVITY_THRESHOLD, parameters.getRangeActionsOptimizationParameters().getPstSensitivityThreshold()); + jsonGenerator.writeObjectField(PST_MODEL, parameters.getRangeActionsOptimizationParameters().getPstModel()); + jsonGenerator.writeNumberField(HVDC_SENSITIVITY_THRESHOLD, parameters.getRangeActionsOptimizationParameters().getHvdcSensitivityThreshold()); + jsonGenerator.writeNumberField(INJECTION_RA_SENSITIVITY_THRESHOLD, parameters.getRangeActionsOptimizationParameters().getInjectionRaSensitivityThreshold()); + jsonGenerator.writeObjectField(RA_RANGE_SHRINKING, parameters.getRangeActionsOptimizationParameters().getRaRangeShrinking()); + jsonGenerator.writeObjectFieldStart(LINEAR_OPTIMIZATION_SOLVER); + jsonGenerator.writeObjectField(SOLVER, parameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().getSolver()); + jsonGenerator.writeNumberField(RELATIVE_MIP_GAP, parameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().getRelativeMipGap()); + jsonGenerator.writeStringField(SOLVER_SPECIFIC_PARAMETERS, parameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().getSolverSpecificParameters()); + jsonGenerator.writeEndObject(); + jsonGenerator.writeEndObject(); + } + + static void deserialize(JsonParser jsonParser, OpenRaoSearchTreeParameters searchTreeParameters) throws IOException { + while (!jsonParser.nextToken().isStructEnd()) { + switch (jsonParser.getCurrentName()) { + case MAX_MIP_ITERATIONS: + jsonParser.nextToken(); + searchTreeParameters.getRangeActionsOptimizationParameters().setMaxMipIterations(jsonParser.getIntValue()); + break; + case PST_SENSITIVITY_THRESHOLD: + jsonParser.nextToken(); + searchTreeParameters.getRangeActionsOptimizationParameters().setPstSensitivityThreshold(jsonParser.getDoubleValue()); + break; + case PST_MODEL: + searchTreeParameters.getRangeActionsOptimizationParameters().setPstModel(stringToPstModel(jsonParser.nextTextValue())); + break; + case HVDC_SENSITIVITY_THRESHOLD: + jsonParser.nextToken(); + searchTreeParameters.getRangeActionsOptimizationParameters().setHvdcSensitivityThreshold(jsonParser.getDoubleValue()); + break; + case INJECTION_RA_SENSITIVITY_THRESHOLD: + jsonParser.nextToken(); + searchTreeParameters.getRangeActionsOptimizationParameters().setInjectionRaSensitivityThreshold(jsonParser.getDoubleValue()); + break; + case LINEAR_OPTIMIZATION_SOLVER: + jsonParser.nextToken(); + deserializeLinearOptimizationSolver(jsonParser, searchTreeParameters); + break; + case RA_RANGE_SHRINKING: + searchTreeParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(stringToRaRangeShrinking(jsonParser.nextTextValue())); + break; + default: + throw new OpenRaoException(String.format("Cannot deserialize range action optimization parameters: unexpected field in %s (%s)", RANGE_ACTIONS_OPTIMIZATION, jsonParser.getCurrentName())); + } + } + } + + private static void deserializeLinearOptimizationSolver(JsonParser jsonParser, OpenRaoSearchTreeParameters searchTreeParameters) throws IOException { + while (!jsonParser.nextToken().isStructEnd()) { + switch (jsonParser.getCurrentName()) { + case SOLVER: + searchTreeParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().setSolver(stringToSolver(jsonParser.nextTextValue())); + break; + case RELATIVE_MIP_GAP: + jsonParser.nextToken(); + searchTreeParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().setRelativeMipGap(jsonParser.getDoubleValue()); + break; + case SOLVER_SPECIFIC_PARAMETERS: + jsonParser.nextToken(); + searchTreeParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().setSolverSpecificParameters(jsonParser.getValueAsString()); + break; + default: + throw new OpenRaoException(String.format("Cannot deserialize linear optimization solver in range action optimization parameters: unexpected field in %s (%s)", LINEAR_OPTIMIZATION_SOLVER, jsonParser.getCurrentName())); + } + } + } + + private static RangeActionsOptimizationParameters.PstModel stringToPstModel(String string) { + try { + return RangeActionsOptimizationParameters.PstModel.valueOf(string); + } catch (IllegalArgumentException e) { + throw new OpenRaoException(String.format("Unknown Pst model: %s", string)); + } + } + + private static RangeActionsOptimizationParameters.RaRangeShrinking stringToRaRangeShrinking(String string) { + try { + return RangeActionsOptimizationParameters.RaRangeShrinking.valueOf(string); + } catch (IllegalArgumentException e) { + throw new OpenRaoException(String.format("Unknown Pst variation range shrinking: %s", string)); + } + } + + private static RangeActionsOptimizationParameters.Solver stringToSolver(String string) { + try { + return RangeActionsOptimizationParameters.Solver.valueOf(string); + } catch (IllegalArgumentException e) { + throw new OpenRaoException(String.format("Unknown solver: %s", string)); + } + } +} diff --git a/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/RangeActionsOptimizationParameters.java b/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/RangeActionsOptimizationParameters.java index 00896bb9d5..3763688efc 100644 --- a/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/RangeActionsOptimizationParameters.java +++ b/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/RangeActionsOptimizationParameters.java @@ -7,7 +7,6 @@ package com.powsybl.openrao.raoapi.parameters; -import com.powsybl.openrao.commons.OpenRaoException; import com.powsybl.commons.config.PlatformConfig; import java.util.Objects; @@ -23,177 +22,37 @@ public class RangeActionsOptimizationParameters { // Default values - private static final int DEFAULT_MAX_MIP_ITERATIONS = 10; - private static final double DEFAULT_PST_PENALTY_COST = 0.01; - private static final double DEFAULT_PST_SENSITIVITY_THRESHOLD = 1e-6; - private static final PstModel DEFAULT_PST_MODEL = PstModel.CONTINUOUS; - private static final double DEFAULT_HVDC_PENALTY_COST = 0.001; - private static final double DEFAULT_HVDC_SENSITIVITY_THRESHOLD = 1e-6; - private static final double DEFAULT_INJECTION_RA_PENALTY_COST = 0.001; - private static final double DEFAULT_INJECTION_RA_SENSITIVITY_THRESHOLD = 1e-6; - private static final RaRangeShrinking DEFAULT_RA_RANGE_SHRINKING = RaRangeShrinking.DISABLED; + private static final double DEFAULT_PST_RA_MIN_IMPACT_THRESHOLD = 0.01; + private static final double DEFAULT_HVDC_RA_MIN_IMPACT_THRESHOLD = 0.001; + private static final double DEFAULT_INJECTION_RA_MIN_IMPACT_THRESHOLD = 0.001; // Attributes - private int maxMipIterations = DEFAULT_MAX_MIP_ITERATIONS; - private double pstPenaltyCost = DEFAULT_PST_PENALTY_COST; - private double pstSensitivityThreshold = DEFAULT_PST_SENSITIVITY_THRESHOLD; - private PstModel pstModel = DEFAULT_PST_MODEL; - private double hvdcPenaltyCost = DEFAULT_HVDC_PENALTY_COST; - private double hvdcSensitivityThreshold = DEFAULT_HVDC_SENSITIVITY_THRESHOLD; - private double injectionRaPenaltyCost = DEFAULT_INJECTION_RA_PENALTY_COST; - private double injectionRaSensitivityThreshold = DEFAULT_INJECTION_RA_SENSITIVITY_THRESHOLD; - private LinearOptimizationSolver linearOptimizationSolver = new LinearOptimizationSolver(); - private RaRangeShrinking raRangeShrinking = DEFAULT_RA_RANGE_SHRINKING; - - public enum PstModel { - CONTINUOUS, - APPROXIMATED_INTEGERS - } - - public enum RaRangeShrinking { - DISABLED, - ENABLED, - ENABLED_IN_FIRST_PRAO_AND_CRAO - } - - public static class LinearOptimizationSolver { - private static final Solver DEFAULT_SOLVER = Solver.CBC; - public static final double DEFAULT_RELATIVE_MIP_GAP = 0.0001; - public static final String DEFAULT_SOLVER_SPECIFIC_PARAMETERS = null; - private Solver solver = DEFAULT_SOLVER; - private double relativeMipGap = DEFAULT_RELATIVE_MIP_GAP; - private String solverSpecificParameters = DEFAULT_SOLVER_SPECIFIC_PARAMETERS; - - public Solver getSolver() { - return solver; - } - - public void setSolver(Solver solver) { - this.solver = solver; - } - - public double getRelativeMipGap() { - return relativeMipGap; - } - - public void setRelativeMipGap(double relativeMipGap) { - this.relativeMipGap = relativeMipGap; - } - - public String getSolverSpecificParameters() { - return solverSpecificParameters; - } - - public void setSolverSpecificParameters(String solverSpecificParameters) { - this.solverSpecificParameters = solverSpecificParameters; - } - - public static LinearOptimizationSolver load(PlatformConfig platformConfig) { - Objects.requireNonNull(platformConfig); - LinearOptimizationSolver parameters = new LinearOptimizationSolver(); - platformConfig.getOptionalModuleConfig(LINEAR_OPTIMIZATION_SOLVER_SECTION) - .ifPresent(config -> { - parameters.setSolver(config.getEnumProperty(SOLVER, Solver.class, DEFAULT_SOLVER)); - parameters.setRelativeMipGap(config.getDoubleProperty(RELATIVE_MIP_GAP, DEFAULT_RELATIVE_MIP_GAP)); - parameters.setSolverSpecificParameters(config.getStringProperty(SOLVER_SPECIFIC_PARAMETERS, DEFAULT_SOLVER_SPECIFIC_PARAMETERS)); - }); - return parameters; - } - } - - public enum Solver { - CBC, - SCIP, - XPRESS - } + private double pstRAMinImpactThreshold = DEFAULT_PST_RA_MIN_IMPACT_THRESHOLD; + private double hvdcRAMinImpactThreshold = DEFAULT_HVDC_RA_MIN_IMPACT_THRESHOLD; + private double injectionRAMinImpactThreshold = DEFAULT_INJECTION_RA_MIN_IMPACT_THRESHOLD; // Getters and setters - public int getMaxMipIterations() { - return maxMipIterations; - } - - public void setMaxMipIterations(int maxMipIterations) { - this.maxMipIterations = maxMipIterations; - } - - public double getPstPenaltyCost() { - return pstPenaltyCost; - } - - public void setPstPenaltyCost(double pstPenaltyCost) { - this.pstPenaltyCost = pstPenaltyCost; - } - - public double getPstSensitivityThreshold() { - return pstSensitivityThreshold; + public double getPstRAMinImpactThreshold() { + return pstRAMinImpactThreshold; } - public void setPstSensitivityThreshold(double pstSensitivityThreshold) { - if (pstSensitivityThreshold < 1e-6) { - throw new OpenRaoException("pstSensitivityThreshold should be greater than 1e-6, to avoid numerical issues."); - } - this.pstSensitivityThreshold = pstSensitivityThreshold; + public void setPstRAMinImpactThreshold(double pstRAMinImpactThreshold) { + this.pstRAMinImpactThreshold = pstRAMinImpactThreshold; } - public double getHvdcPenaltyCost() { - return hvdcPenaltyCost; + public double getHvdcRAMinImpactThreshold() { + return hvdcRAMinImpactThreshold; } - public void setHvdcPenaltyCost(double hvdcPenaltyCost) { - this.hvdcPenaltyCost = hvdcPenaltyCost; + public void setHvdcRAMinImpactThreshold(double hvdcRAMinImpactThreshold) { + this.hvdcRAMinImpactThreshold = hvdcRAMinImpactThreshold; } - public double getHvdcSensitivityThreshold() { - return hvdcSensitivityThreshold; + public double getInjectionRAMinImpactThreshold() { + return injectionRAMinImpactThreshold; } - public void setHvdcSensitivityThreshold(double hvdcSensitivityThreshold) { - if (hvdcSensitivityThreshold < 1e-6) { - throw new OpenRaoException("hvdcSensitivityThreshold should be greater than 1e-6, to avoid numerical issues."); - } - this.hvdcSensitivityThreshold = hvdcSensitivityThreshold; - } - - public double getInjectionRaPenaltyCost() { - return injectionRaPenaltyCost; - } - - public void setInjectionRaPenaltyCost(double injectionRaPenaltyCost) { - this.injectionRaPenaltyCost = injectionRaPenaltyCost; - } - - public double getInjectionRaSensitivityThreshold() { - return injectionRaSensitivityThreshold; - } - - public void setInjectionRaSensitivityThreshold(double injectionRaSensitivityThreshold) { - if (injectionRaSensitivityThreshold < 1e-6) { - throw new OpenRaoException("injectionRaSensitivityThreshold should be greater than 1e-6, to avoid numerical issues."); - } - this.injectionRaSensitivityThreshold = injectionRaSensitivityThreshold; - } - - public LinearOptimizationSolver getLinearOptimizationSolver() { - return linearOptimizationSolver; - } - - public void setPstModel(PstModel pstModel) { - this.pstModel = pstModel; - } - - public PstModel getPstModel() { - return pstModel; - } - - public void setLinearOptimizationSolver(LinearOptimizationSolver linearOptimizationSolver) { - this.linearOptimizationSolver = linearOptimizationSolver; - } - - public void setRaRangeShrinking(RaRangeShrinking raRangeShrinking) { - this.raRangeShrinking = raRangeShrinking; - } - - public RaRangeShrinking getRaRangeShrinking() { - return raRangeShrinking; + public void setInjectionRAMinImpactThreshold(double injectionRAMinImpactThreshold) { + this.injectionRAMinImpactThreshold = injectionRAMinImpactThreshold; } public static RangeActionsOptimizationParameters load(PlatformConfig platformConfig) { @@ -201,21 +60,10 @@ public static RangeActionsOptimizationParameters load(PlatformConfig platformCon RangeActionsOptimizationParameters parameters = new RangeActionsOptimizationParameters(); platformConfig.getOptionalModuleConfig(RANGE_ACTIONS_OPTIMIZATION_SECTION) .ifPresent(config -> { - parameters.setMaxMipIterations(config.getIntProperty(MAX_MIP_ITERATIONS, DEFAULT_MAX_MIP_ITERATIONS)); - parameters.setPstPenaltyCost(config.getDoubleProperty(PST_PENALTY_COST, DEFAULT_PST_PENALTY_COST)); - parameters.setPstSensitivityThreshold(config.getDoubleProperty(PST_SENSITIVITY_THRESHOLD, DEFAULT_PST_SENSITIVITY_THRESHOLD)); - parameters.setPstModel(config.getEnumProperty(PST_MODEL, PstModel.class, DEFAULT_PST_MODEL)); - parameters.setHvdcPenaltyCost(config.getDoubleProperty(HVDC_PENALTY_COST, DEFAULT_HVDC_PENALTY_COST)); - parameters.setHvdcSensitivityThreshold(config.getDoubleProperty(HVDC_SENSITIVITY_THRESHOLD, DEFAULT_HVDC_SENSITIVITY_THRESHOLD)); - parameters.setInjectionRaPenaltyCost(config.getDoubleProperty(INJECTION_RA_PENALTY_COST, DEFAULT_INJECTION_RA_PENALTY_COST)); - parameters.setInjectionRaSensitivityThreshold(config.getDoubleProperty(INJECTION_RA_SENSITIVITY_THRESHOLD, DEFAULT_INJECTION_RA_SENSITIVITY_THRESHOLD)); - parameters.setRaRangeShrinking(config.getEnumProperty(RA_RANGE_SHRINKING, RaRangeShrinking.class, DEFAULT_RA_RANGE_SHRINKING)); + parameters.setPstRAMinImpactThreshold(config.getDoubleProperty(PST_RA_MIN_IMPACT_THRESHOLD, DEFAULT_PST_RA_MIN_IMPACT_THRESHOLD)); + parameters.setHvdcRAMinImpactThreshold(config.getDoubleProperty(HVDC_RA_MIN_IMPACT_THRESHOLD, DEFAULT_HVDC_RA_MIN_IMPACT_THRESHOLD)); + parameters.setInjectionRAMinImpactThreshold(config.getDoubleProperty(INJECTION_RA_MIN_IMPACT_THRESHOLD, DEFAULT_INJECTION_RA_MIN_IMPACT_THRESHOLD)); }); - parameters.setLinearOptimizationSolver(LinearOptimizationSolver.load(platformConfig)); return parameters; } - - public static RangeActionsOptimizationParameters buildFromRaoParameters(RaoParameters raoParameters) { - return raoParameters.getRangeActionsOptimizationParameters(); - } } diff --git a/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/extensions/OpenRaoSearchTreeParameters.java b/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/extensions/OpenRaoSearchTreeParameters.java new file mode 100644 index 0000000000..f57fd4e353 --- /dev/null +++ b/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/extensions/OpenRaoSearchTreeParameters.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2024, RTE (http://www.rte-france.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.openrao.raoapi.parameters.extensions; + +import com.powsybl.commons.extensions.AbstractExtension; +import com.powsybl.openrao.raoapi.parameters.*; + +import static com.powsybl.openrao.raoapi.RaoParametersCommons.*; + +public class OpenRaoSearchTreeParameters extends AbstractExtension { + private RangeActionsOptimizationParameters rangeActionsOptimizationParameters = new RangeActionsOptimizationParameters(); + + public void setRangeActionsOptimizationParameters(RangeActionsOptimizationParameters rangeActionsOptimizationParameters) { + this.rangeActionsOptimizationParameters = rangeActionsOptimizationParameters; + } + + public RangeActionsOptimizationParameters getRangeActionsOptimizationParameters() { + return rangeActionsOptimizationParameters; + } + + @Override + public String getName() { + return SEARCH_TREE_PARAMETERS; + } + +} diff --git a/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/extensions/OpenRaoSearchTreeParametersConfigLoader.java b/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/extensions/OpenRaoSearchTreeParametersConfigLoader.java new file mode 100644 index 0000000000..5ebdd400a6 --- /dev/null +++ b/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/extensions/OpenRaoSearchTreeParametersConfigLoader.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2024, RTE (http://www.rte-france.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.openrao.raoapi.parameters.extensions; + +import com.google.auto.service.AutoService; +import com.powsybl.commons.config.PlatformConfig; +import com.powsybl.openrao.raoapi.parameters.*; + +import java.util.Arrays; +import java.util.List; +import java.util.Objects; +import java.util.Optional; + +import static com.powsybl.openrao.raoapi.RaoParametersCommons.*; + + +/** + * @author Pauline JEAN-MARIE {@literal } + */ +@AutoService(RaoParameters.ConfigLoader.class) +public class OpenRaoSearchTreeParametersConfigLoader implements RaoParameters.ConfigLoader { + + @Override + public OpenRaoSearchTreeParameters load(PlatformConfig platformConfig) { + Objects.requireNonNull(platformConfig); + List searchTreeParams = Arrays.asList(ST_RANGE_ACTIONS_OPTIMIZATION_SECTION); + boolean anySearchTreeParams = searchTreeParams.stream().map(platformConfig::getOptionalModuleConfig).anyMatch(Optional::isPresent); + if (!anySearchTreeParams) { + return null; + } + OpenRaoSearchTreeParameters parameters = new OpenRaoSearchTreeParameters(); + parameters.setRangeActionsOptimizationParameters(RangeActionsOptimizationParameters.load(platformConfig)); + return parameters; + } + + @Override + public String getExtensionName() { + return SEARCH_TREE_PARAMETERS; + } + + @Override + public String getCategoryName() { + return "rao-parameters"; + } + + @Override + public Class getExtensionClass() { + return OpenRaoSearchTreeParameters.class; + } +} diff --git a/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/extensions/RangeActionsOptimizationParameters.java b/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/extensions/RangeActionsOptimizationParameters.java new file mode 100644 index 0000000000..cc7ef5a7d9 --- /dev/null +++ b/ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/extensions/RangeActionsOptimizationParameters.java @@ -0,0 +1,241 @@ +/* + * Copyright (c) 2023, RTE (http://www.rte-france.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/. + */ + +package com.powsybl.openrao.raoapi.parameters.extensions; + +import com.powsybl.commons.config.PlatformConfig; +import com.powsybl.openrao.commons.OpenRaoException; +import com.powsybl.openrao.raoapi.parameters.RaoParameters; + +import java.util.Objects; + +import static com.powsybl.openrao.raoapi.RaoParametersCommons.*; + +/** + * Range actions optimization parameters for RAO + * + * @author Godelaine de Montmorillon {@literal } + * + */ +public class RangeActionsOptimizationParameters { + + // Default values + private static final int DEFAULT_MAX_MIP_ITERATIONS = 10; + private static final double DEFAULT_PST_SENSITIVITY_THRESHOLD = 1e-6; + private static final PstModel DEFAULT_PST_MODEL = PstModel.CONTINUOUS; + private static final double DEFAULT_HVDC_SENSITIVITY_THRESHOLD = 1e-6; + private static final double DEFAULT_INJECTION_RA_SENSITIVITY_THRESHOLD = 1e-6; + private static final RaRangeShrinking DEFAULT_RA_RANGE_SHRINKING = RaRangeShrinking.DISABLED; + // Attributes + private int maxMipIterations = DEFAULT_MAX_MIP_ITERATIONS; + private double pstSensitivityThreshold = DEFAULT_PST_SENSITIVITY_THRESHOLD; + private PstModel pstModel = DEFAULT_PST_MODEL; + private double hvdcSensitivityThreshold = DEFAULT_HVDC_SENSITIVITY_THRESHOLD; + private double injectionRaSensitivityThreshold = DEFAULT_INJECTION_RA_SENSITIVITY_THRESHOLD; + private LinearOptimizationSolver linearOptimizationSolver = new LinearOptimizationSolver(); + private RaRangeShrinking raRangeShrinking = DEFAULT_RA_RANGE_SHRINKING; + + public enum PstModel { + CONTINUOUS, + APPROXIMATED_INTEGERS + } + + public enum RaRangeShrinking { + DISABLED, + ENABLED, + ENABLED_IN_FIRST_PRAO_AND_CRAO + } + + public static class LinearOptimizationSolver { + private static final Solver DEFAULT_SOLVER = Solver.CBC; + public static final double DEFAULT_RELATIVE_MIP_GAP = 0.0001; + public static final String DEFAULT_SOLVER_SPECIFIC_PARAMETERS = null; + private Solver solver = DEFAULT_SOLVER; + private double relativeMipGap = DEFAULT_RELATIVE_MIP_GAP; + private String solverSpecificParameters = DEFAULT_SOLVER_SPECIFIC_PARAMETERS; + + public Solver getSolver() { + return solver; + } + + public void setSolver(Solver solver) { + this.solver = solver; + } + + public double getRelativeMipGap() { + return relativeMipGap; + } + + public void setRelativeMipGap(double relativeMipGap) { + this.relativeMipGap = relativeMipGap; + } + + public String getSolverSpecificParameters() { + return solverSpecificParameters; + } + + public void setSolverSpecificParameters(String solverSpecificParameters) { + this.solverSpecificParameters = solverSpecificParameters; + } + + public static LinearOptimizationSolver load(PlatformConfig platformConfig) { + Objects.requireNonNull(platformConfig); + LinearOptimizationSolver parameters = new LinearOptimizationSolver(); + platformConfig.getOptionalModuleConfig(LINEAR_OPTIMIZATION_SOLVER_SECTION) + .ifPresent(config -> { + parameters.setSolver(config.getEnumProperty(SOLVER, Solver.class, DEFAULT_SOLVER)); + parameters.setRelativeMipGap(config.getDoubleProperty(RELATIVE_MIP_GAP, DEFAULT_RELATIVE_MIP_GAP)); + parameters.setSolverSpecificParameters(config.getStringProperty(SOLVER_SPECIFIC_PARAMETERS, DEFAULT_SOLVER_SPECIFIC_PARAMETERS)); + }); + return parameters; + } + } + + public enum Solver { + CBC, + SCIP, + XPRESS + } + + // Getters and setters + public int getMaxMipIterations() { + return maxMipIterations; + } + + public void setMaxMipIterations(int maxMipIterations) { + this.maxMipIterations = maxMipIterations; + } + + public double getPstSensitivityThreshold() { + return pstSensitivityThreshold; + } + + public void setPstSensitivityThreshold(double pstSensitivityThreshold) { + if (pstSensitivityThreshold < 1e-6) { + throw new OpenRaoException("pstSensitivityThreshold should be greater than 1e-6, to avoid numerical issues."); + } + this.pstSensitivityThreshold = pstSensitivityThreshold; + } + + public double getHvdcSensitivityThreshold() { + return hvdcSensitivityThreshold; + } + + public void setHvdcSensitivityThreshold(double hvdcSensitivityThreshold) { + if (hvdcSensitivityThreshold < 1e-6) { + throw new OpenRaoException("hvdcSensitivityThreshold should be greater than 1e-6, to avoid numerical issues."); + } + this.hvdcSensitivityThreshold = hvdcSensitivityThreshold; + } + + public double getInjectionRaSensitivityThreshold() { + return injectionRaSensitivityThreshold; + } + + public void setInjectionRaSensitivityThreshold(double injectionRaSensitivityThreshold) { + if (injectionRaSensitivityThreshold < 1e-6) { + throw new OpenRaoException("injectionRaSensitivityThreshold should be greater than 1e-6, to avoid numerical issues."); + } + this.injectionRaSensitivityThreshold = injectionRaSensitivityThreshold; + } + + public LinearOptimizationSolver getLinearOptimizationSolver() { + return linearOptimizationSolver; + } + + public void setPstModel(PstModel pstModel) { + this.pstModel = pstModel; + } + + public PstModel getPstModel() { + return pstModel; + } + + public void setLinearOptimizationSolver(LinearOptimizationSolver linearOptimizationSolver) { + this.linearOptimizationSolver = linearOptimizationSolver; + } + + public void setRaRangeShrinking(RaRangeShrinking raRangeShrinking) { + this.raRangeShrinking = raRangeShrinking; + } + + public RaRangeShrinking getRaRangeShrinking() { + return raRangeShrinking; + } + + public static RangeActionsOptimizationParameters load(PlatformConfig platformConfig) { + Objects.requireNonNull(platformConfig); + RangeActionsOptimizationParameters parameters = new RangeActionsOptimizationParameters(); + platformConfig.getOptionalModuleConfig(ST_RANGE_ACTIONS_OPTIMIZATION_SECTION) + .ifPresent(config -> { + parameters.setMaxMipIterations(config.getIntProperty(MAX_MIP_ITERATIONS, DEFAULT_MAX_MIP_ITERATIONS)); + parameters.setPstSensitivityThreshold(config.getDoubleProperty(PST_SENSITIVITY_THRESHOLD, DEFAULT_PST_SENSITIVITY_THRESHOLD)); + parameters.setPstModel(config.getEnumProperty(PST_MODEL, PstModel.class, DEFAULT_PST_MODEL)); + parameters.setHvdcSensitivityThreshold(config.getDoubleProperty(HVDC_SENSITIVITY_THRESHOLD, DEFAULT_HVDC_SENSITIVITY_THRESHOLD)); + parameters.setInjectionRaSensitivityThreshold(config.getDoubleProperty(INJECTION_RA_SENSITIVITY_THRESHOLD, DEFAULT_INJECTION_RA_SENSITIVITY_THRESHOLD)); + parameters.setRaRangeShrinking(config.getEnumProperty(RA_RANGE_SHRINKING, RaRangeShrinking.class, DEFAULT_RA_RANGE_SHRINKING)); + }); + parameters.setLinearOptimizationSolver(LinearOptimizationSolver.load(platformConfig)); + return parameters; + } + + public static PstModel getPstModel(RaoParameters raoParameters) { + if (raoParameters.hasExtension(OpenRaoSearchTreeParameters.class)) { + return raoParameters.getExtension(OpenRaoSearchTreeParameters.class).getRangeActionsOptimizationParameters().getPstModel(); + } + return DEFAULT_PST_MODEL; + } + + public static RaRangeShrinking getRaRangeShrinking(RaoParameters parameters) { + if (parameters.hasExtension(OpenRaoSearchTreeParameters.class)) { + return parameters.getExtension(OpenRaoSearchTreeParameters.class).getRangeActionsOptimizationParameters().getRaRangeShrinking(); + } + return DEFAULT_RA_RANGE_SHRINKING; + } + + public static LinearOptimizationSolver getLinearOptimizationSolver(RaoParameters parameters) { + if (parameters.hasExtension(OpenRaoSearchTreeParameters.class)) { + return parameters.getExtension(OpenRaoSearchTreeParameters.class).getRangeActionsOptimizationParameters().getLinearOptimizationSolver(); + } + return new LinearOptimizationSolver(); + } + + public static int getMaxMipIterations(RaoParameters parameters) { + if (parameters.hasExtension(OpenRaoSearchTreeParameters.class)) { + return parameters.getExtension(OpenRaoSearchTreeParameters.class).getRangeActionsOptimizationParameters().getMaxMipIterations(); + } + return DEFAULT_MAX_MIP_ITERATIONS; + } + + public static PstModel getPstModel(RangeActionsOptimizationParameters rangeActionsOptimizationParameters) { + if (!Objects.isNull(rangeActionsOptimizationParameters)) { + return rangeActionsOptimizationParameters.getPstModel(); + } + return DEFAULT_PST_MODEL; + } + + public static double getPstSensitivityThreshold(RangeActionsOptimizationParameters rangeActionsOptimizationParameters) { + if (!Objects.isNull(rangeActionsOptimizationParameters)) { + return rangeActionsOptimizationParameters.getPstSensitivityThreshold(); + } + return DEFAULT_PST_SENSITIVITY_THRESHOLD; + } + + public static double getHvdcSensitivityThreshold(RangeActionsOptimizationParameters rangeActionsOptimizationParameters) { + if (!Objects.isNull(rangeActionsOptimizationParameters)) { + return rangeActionsOptimizationParameters.getHvdcSensitivityThreshold(); + } + return DEFAULT_HVDC_SENSITIVITY_THRESHOLD; + } + + public static double getInjectionRaSensitivityThreshold(RangeActionsOptimizationParameters rangeActionsOptimizationParameters) { + if (!Objects.isNull(rangeActionsOptimizationParameters)) { + return rangeActionsOptimizationParameters.getInjectionRaSensitivityThreshold(); + } + return DEFAULT_INJECTION_RA_SENSITIVITY_THRESHOLD; + } +} diff --git a/ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/json/JsonRaoParametersTest.java b/ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/json/JsonRaoParametersTest.java index 2d40ddcf93..3fb4c11c3f 100644 --- a/ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/json/JsonRaoParametersTest.java +++ b/ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/json/JsonRaoParametersTest.java @@ -8,13 +8,12 @@ import com.powsybl.openrao.commons.OpenRaoException; import com.powsybl.openrao.raoapi.parameters.ObjectiveFunctionParameters; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; import com.powsybl.openrao.raoapi.parameters.RaoParameters; import com.powsybl.openrao.raoapi.parameters.SecondPreventiveRaoParameters; -import com.powsybl.openrao.raoapi.parameters.extensions.LoopFlowParametersExtension; -import com.powsybl.openrao.raoapi.parameters.extensions.MnecParametersExtension; -import com.powsybl.openrao.raoapi.parameters.extensions.PtdfApproximation; -import com.powsybl.openrao.raoapi.parameters.extensions.RelativeMarginsParametersExtension; +import com.powsybl.openrao.raoapi.parameters.extensions.*; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.Solver; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.PstModel; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.RaRangeShrinking; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.databind.DeserializationContext; @@ -51,23 +50,25 @@ void roundTripDefault() throws IOException { @Test void roundTrip() throws IOException { RaoParameters parameters = new RaoParameters(); + parameters.addExtension(OpenRaoSearchTreeParameters.class, new OpenRaoSearchTreeParameters()); + OpenRaoSearchTreeParameters searchTreeParameters = parameters.getExtension(OpenRaoSearchTreeParameters.class); // Objective Function parameters parameters.getObjectiveFunctionParameters().setType(ObjectiveFunctionParameters.ObjectiveFunctionType.MAX_MIN_MARGIN); parameters.getObjectiveFunctionParameters().setCurativeMinObjImprovement(983); parameters.getObjectiveFunctionParameters().setEnforceCurativeSecurity(true); // RangeActionsOptimization parameters - parameters.getRangeActionsOptimizationParameters().setMaxMipIterations(30); - parameters.getRangeActionsOptimizationParameters().setPstPenaltyCost(10); - parameters.getRangeActionsOptimizationParameters().setPstSensitivityThreshold(0.2); - parameters.getRangeActionsOptimizationParameters().setHvdcPenaltyCost(1); - parameters.getRangeActionsOptimizationParameters().setHvdcSensitivityThreshold(0.3); - parameters.getRangeActionsOptimizationParameters().setInjectionRaPenaltyCost(1.2); - parameters.getRangeActionsOptimizationParameters().setInjectionRaSensitivityThreshold(0.7); - parameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().setSolverSpecificParameters("TREEMEMORYLIMIT 20"); - parameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().setSolver(RangeActionsOptimizationParameters.Solver.SCIP); - parameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().setRelativeMipGap(1e-5); - parameters.getRangeActionsOptimizationParameters().setPstModel(RangeActionsOptimizationParameters.PstModel.APPROXIMATED_INTEGERS); - parameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED); + searchTreeParameters.getRangeActionsOptimizationParameters().setMaxMipIterations(30); + parameters.getRangeActionsOptimizationParameters().setPstRAMinImpactThreshold(10); + searchTreeParameters.getRangeActionsOptimizationParameters().setPstSensitivityThreshold(0.2); + parameters.getRangeActionsOptimizationParameters().setHvdcRAMinImpactThreshold(1); + searchTreeParameters.getRangeActionsOptimizationParameters().setHvdcSensitivityThreshold(0.3); + parameters.getRangeActionsOptimizationParameters().setInjectionRAMinImpactThreshold(1.2); + searchTreeParameters.getRangeActionsOptimizationParameters().setInjectionRaSensitivityThreshold(0.7); + searchTreeParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().setSolverSpecificParameters("TREEMEMORYLIMIT 20"); + searchTreeParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().setSolver(Solver.SCIP); + searchTreeParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().setRelativeMipGap(1e-5); + searchTreeParameters.getRangeActionsOptimizationParameters().setPstModel(PstModel.APPROXIMATED_INTEGERS); + searchTreeParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RaRangeShrinking.ENABLED); // TopologicalActions optimization parameters parameters.getTopoOptimizationParameters().setMaxPreventiveSearchTreeDepth(10); parameters.getTopoOptimizationParameters().setMaxAutoSearchTreeDepth(3); @@ -117,9 +118,9 @@ void roundTrip() throws IOException { @Test void update() { RaoParameters parameters = JsonRaoParameters.read(getClass().getResourceAsStream("/RaoParameters_default_v2.json")); - assertEquals(1, parameters.getExtensions().size()); - JsonRaoParameters.update(parameters, getClass().getResourceAsStream("/RaoParameters_update_v2.json")); assertEquals(2, parameters.getExtensions().size()); + JsonRaoParameters.update(parameters, getClass().getResourceAsStream("/RaoParameters_update_v2.json")); + assertEquals(3, parameters.getExtensions().size()); assertEquals(ObjectiveFunctionParameters.ObjectiveFunctionType.MAX_MIN_MARGIN, parameters.getObjectiveFunctionParameters().getType()); assertEquals(5, parameters.getTopoOptimizationParameters().getMaxPreventiveSearchTreeDepth(), DOUBLE_TOLERANCE); assertEquals(2, parameters.getTopoOptimizationParameters().getMaxAutoSearchTreeDepth(), DOUBLE_TOLERANCE); diff --git a/ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/parameters/RaoParametersConfigTest.java b/ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/parameters/RaoParametersConfigTest.java index 19a8101a16..033097a424 100644 --- a/ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/parameters/RaoParametersConfigTest.java +++ b/ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/parameters/RaoParametersConfigTest.java @@ -56,33 +56,34 @@ void checkObjectiveFunctionConfig() { @Test void checkRangeActionsOptimizationConfig() { MapModuleConfig rangeActionsOptimizationModuleConfig = platformCfg.createModuleConfig("rao-range-actions-optimization"); - rangeActionsOptimizationModuleConfig.setStringProperty("max-mip-iterations", Objects.toString(4)); - rangeActionsOptimizationModuleConfig.setStringProperty("pst-penalty-cost", Objects.toString(44)); - rangeActionsOptimizationModuleConfig.setStringProperty("pst-sensitivity-threshold", Objects.toString(7)); - rangeActionsOptimizationModuleConfig.setStringProperty("pst-model", "APPROXIMATED_INTEGERS"); - rangeActionsOptimizationModuleConfig.setStringProperty("hvdc-penalty-cost", Objects.toString(33)); - rangeActionsOptimizationModuleConfig.setStringProperty("hvdc-sensitivity-threshold", Objects.toString(8)); - rangeActionsOptimizationModuleConfig.setStringProperty("injection-ra-penalty-cost", Objects.toString(22)); - rangeActionsOptimizationModuleConfig.setStringProperty("injection-ra-sensitivity-threshold", Objects.toString(9)); - MapModuleConfig linearOptimizationSolverModuleConfig = platformCfg.createModuleConfig("rao-linear-optimization-solver"); + rangeActionsOptimizationModuleConfig.setStringProperty("pst-ra-min-impact-threshold", Objects.toString(44)); + rangeActionsOptimizationModuleConfig.setStringProperty("hvdc-ra-min-impact-threshold", Objects.toString(33)); + rangeActionsOptimizationModuleConfig.setStringProperty("injection-ra-min-impact-threshold", Objects.toString(22)); + MapModuleConfig rangeActionsOptimizationModuleConfigExt = platformCfg.createModuleConfig("search-tree-range-actions-optimization"); + rangeActionsOptimizationModuleConfigExt.setStringProperty("max-mip-iterations", Objects.toString(4)); + rangeActionsOptimizationModuleConfigExt.setStringProperty("pst-sensitivity-threshold", Objects.toString(7)); + rangeActionsOptimizationModuleConfigExt.setStringProperty("pst-model", "APPROXIMATED_INTEGERS"); + rangeActionsOptimizationModuleConfigExt.setStringProperty("hvdc-sensitivity-threshold", Objects.toString(8)); + rangeActionsOptimizationModuleConfigExt.setStringProperty("injection-ra-sensitivity-threshold", Objects.toString(9)); + MapModuleConfig linearOptimizationSolverModuleConfig = platformCfg.createModuleConfig("search-tree-linear-optimization-solver"); linearOptimizationSolverModuleConfig.setStringProperty("solver", "XPRESS"); linearOptimizationSolverModuleConfig.setStringProperty("relative-mip-gap", Objects.toString(22)); linearOptimizationSolverModuleConfig.setStringProperty("solver-specific-parameters", "blabla"); - RaoParameters parameters = new RaoParameters(); - RaoParameters.load(parameters, platformCfg); + RaoParameters parameters = RaoParameters.load(platformCfg); RangeActionsOptimizationParameters params = parameters.getRangeActionsOptimizationParameters(); - assertEquals(4, params.getMaxMipIterations(), DOUBLE_TOLERANCE); - assertEquals(44, params.getPstPenaltyCost(), DOUBLE_TOLERANCE); - assertEquals(7, params.getPstSensitivityThreshold(), DOUBLE_TOLERANCE); - assertEquals(RangeActionsOptimizationParameters.PstModel.APPROXIMATED_INTEGERS, params.getPstModel()); - assertEquals(RangeActionsOptimizationParameters.RaRangeShrinking.DISABLED, params.getRaRangeShrinking()); - assertEquals(33, params.getHvdcPenaltyCost(), DOUBLE_TOLERANCE); - assertEquals(8, params.getHvdcSensitivityThreshold(), DOUBLE_TOLERANCE); - assertEquals(22, params.getInjectionRaPenaltyCost(), DOUBLE_TOLERANCE); - assertEquals(9, params.getInjectionRaSensitivityThreshold(), DOUBLE_TOLERANCE); - assertEquals(RangeActionsOptimizationParameters.Solver.XPRESS, params.getLinearOptimizationSolver().getSolver()); - assertEquals(22, params.getLinearOptimizationSolver().getRelativeMipGap(), DOUBLE_TOLERANCE); - assertEquals("blabla", params.getLinearOptimizationSolver().getSolverSpecificParameters()); + com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters paramsExt = parameters.getExtension(OpenRaoSearchTreeParameters.class).getRangeActionsOptimizationParameters(); + assertEquals(4, paramsExt.getMaxMipIterations(), DOUBLE_TOLERANCE); + assertEquals(44, params.getPstRAMinImpactThreshold(), DOUBLE_TOLERANCE); + assertEquals(7, paramsExt.getPstSensitivityThreshold(), DOUBLE_TOLERANCE); + assertEquals(com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.PstModel.APPROXIMATED_INTEGERS, paramsExt.getPstModel()); + assertEquals(com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.RaRangeShrinking.DISABLED, paramsExt.getRaRangeShrinking()); + assertEquals(33, params.getHvdcRAMinImpactThreshold(), DOUBLE_TOLERANCE); + assertEquals(8, paramsExt.getHvdcSensitivityThreshold(), DOUBLE_TOLERANCE); + assertEquals(22, params.getInjectionRAMinImpactThreshold(), DOUBLE_TOLERANCE); + assertEquals(9, paramsExt.getInjectionRaSensitivityThreshold(), DOUBLE_TOLERANCE); + assertEquals(com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.Solver.XPRESS, paramsExt.getLinearOptimizationSolver().getSolver()); + assertEquals(22, paramsExt.getLinearOptimizationSolver().getRelativeMipGap(), DOUBLE_TOLERANCE); + assertEquals("blabla", paramsExt.getLinearOptimizationSolver().getSolverSpecificParameters()); } @Test @@ -214,13 +215,12 @@ void checkMultipleConfigs() { MapModuleConfig objectiveFunctionModuleConfig = platformCfg.createModuleConfig("rao-objective-function"); objectiveFunctionModuleConfig.setStringProperty("type", "MAX_MIN_RELATIVE_MARGIN"); objectiveFunctionModuleConfig.setStringProperty("curative-min-obj-improvement", Objects.toString(123.0)); - MapModuleConfig rangeActionsOptimizationModuleConfig = platformCfg.createModuleConfig("rao-range-actions-optimization"); - rangeActionsOptimizationModuleConfig.setStringProperty("max-mip-iterations", Objects.toString(32)); - RaoParameters parameters = new RaoParameters(); - RaoParameters.load(parameters, platformCfg); + MapModuleConfig rangeActionsOptimizationExtModuleConfig = platformCfg.createModuleConfig("search-tree-range-actions-optimization"); + rangeActionsOptimizationExtModuleConfig.setStringProperty("max-mip-iterations", Objects.toString(32)); + RaoParameters parameters = RaoParameters.load(platformCfg); assertEquals(ObjectiveFunctionParameters.ObjectiveFunctionType.MAX_MIN_RELATIVE_MARGIN, parameters.getObjectiveFunctionParameters().getType()); assertEquals(123, parameters.getObjectiveFunctionParameters().getCurativeMinObjImprovement(), 1e-6); - assertEquals(32, parameters.getRangeActionsOptimizationParameters().getMaxMipIterations(), 1e-6); + assertEquals(32, parameters.getExtension(OpenRaoSearchTreeParameters.class).getRangeActionsOptimizationParameters().getMaxMipIterations(), 1e-6); assertTrue(Objects.isNull(parameters.getExtension(LoopFlowParametersExtension.class))); assertTrue(Objects.isNull(parameters.getExtension(MnecParametersExtension.class))); assertTrue(Objects.isNull(parameters.getExtension(RelativeMarginsParametersExtension.class))); diff --git a/ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/parameters/RaoParametersConsistencyTest.java b/ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/parameters/RaoParametersConsistencyTest.java index 863dec5233..67b9b79695 100644 --- a/ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/parameters/RaoParametersConsistencyTest.java +++ b/ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/parameters/RaoParametersConsistencyTest.java @@ -8,8 +8,10 @@ import com.powsybl.openrao.commons.EICode; import com.powsybl.openrao.commons.OpenRaoException; +import com.powsybl.openrao.raoapi.parameters.extensions.OpenRaoSearchTreeParameters; import com.powsybl.openrao.raoapi.parameters.extensions.RelativeMarginsParametersExtension; import com.powsybl.iidm.network.Country; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.util.*; @@ -20,6 +22,13 @@ */ class RaoParametersConsistencyTest { private final RaoParameters parameters = new RaoParameters(); + private OpenRaoSearchTreeParameters stParameters; + + @BeforeEach + public void generalSetUp() { + parameters.addExtension(OpenRaoSearchTreeParameters.class, new OpenRaoSearchTreeParameters()); + stParameters = parameters.getExtension(OpenRaoSearchTreeParameters.class); + } @Test void testSetBoundariesFromCountryCodes() { @@ -103,15 +112,13 @@ void testNegativeSensitivityFailureOverCost() { @Test void testFailsOnLowSensitivityThreshold() { - RangeActionsOptimizationParameters rangeActionsOptimizationParameters = parameters.getRangeActionsOptimizationParameters(); - - Exception e = assertThrows(OpenRaoException.class, () -> rangeActionsOptimizationParameters.setPstSensitivityThreshold(0.)); + Exception e = assertThrows(OpenRaoException.class, () -> stParameters.getRangeActionsOptimizationParameters().setPstSensitivityThreshold(0.)); assertEquals("pstSensitivityThreshold should be greater than 1e-6, to avoid numerical issues.", e.getMessage()); - e = assertThrows(OpenRaoException.class, () -> rangeActionsOptimizationParameters.setHvdcSensitivityThreshold(1e-7)); + e = assertThrows(OpenRaoException.class, () -> stParameters.getRangeActionsOptimizationParameters().setHvdcSensitivityThreshold(1e-7)); assertEquals("hvdcSensitivityThreshold should be greater than 1e-6, to avoid numerical issues.", e.getMessage()); - e = assertThrows(OpenRaoException.class, () -> rangeActionsOptimizationParameters.setInjectionRaSensitivityThreshold(0.)); + e = assertThrows(OpenRaoException.class, () -> stParameters.getRangeActionsOptimizationParameters().setInjectionRaSensitivityThreshold(0.)); assertEquals("injectionRaSensitivityThreshold should be greater than 1e-6, to avoid numerical issues.", e.getMessage()); } } diff --git a/ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/parameters/RaoParametersYamlConfigTest.java b/ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/parameters/RaoParametersYamlConfigTest.java index 2cd746a6b4..9532032c30 100644 --- a/ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/parameters/RaoParametersYamlConfigTest.java +++ b/ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/parameters/RaoParametersYamlConfigTest.java @@ -7,10 +7,10 @@ package com.powsybl.openrao.raoapi.parameters; import com.powsybl.openrao.raoapi.json.JsonRaoParameters; -import com.powsybl.openrao.raoapi.parameters.extensions.LoopFlowParametersExtension; -import com.powsybl.openrao.raoapi.parameters.extensions.MnecParametersExtension; -import com.powsybl.openrao.raoapi.parameters.extensions.PtdfApproximation; -import com.powsybl.openrao.raoapi.parameters.extensions.RelativeMarginsParametersExtension; +import com.powsybl.openrao.raoapi.parameters.extensions.*; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.PstModel; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.RaRangeShrinking; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.Solver; import com.powsybl.commons.config.*; import com.powsybl.commons.test.AbstractSerDeTest; import com.powsybl.iidm.network.Country; @@ -41,6 +41,7 @@ public RaoParameters loadRaoParameters(String configFile) { @Test void testConfigWithExtensions() throws IOException { RaoParameters parameters = loadRaoParameters("config_withExtensions"); + OpenRaoSearchTreeParameters searchTreeParameters = parameters.getExtension(OpenRaoSearchTreeParameters.class); ObjectiveFunctionParameters objectiveFunctionParameters = parameters.getObjectiveFunctionParameters(); assertEquals(ObjectiveFunctionParameters.ObjectiveFunctionType.MAX_MIN_MARGIN, objectiveFunctionParameters.getType()); @@ -48,18 +49,18 @@ void testConfigWithExtensions() throws IOException { assertFalse(objectiveFunctionParameters.getEnforceCurativeSecurity()); RangeActionsOptimizationParameters rangeActionsOptimizationParameters = parameters.getRangeActionsOptimizationParameters(); - assertEquals(2, rangeActionsOptimizationParameters.getMaxMipIterations(), DOUBLE_TOLERANCE); - assertEquals(0.02, rangeActionsOptimizationParameters.getPstPenaltyCost(), DOUBLE_TOLERANCE); - assertEquals(0.2, rangeActionsOptimizationParameters.getPstSensitivityThreshold(), DOUBLE_TOLERANCE); - assertEquals(RangeActionsOptimizationParameters.PstModel.APPROXIMATED_INTEGERS, rangeActionsOptimizationParameters.getPstModel()); - assertEquals(RangeActionsOptimizationParameters.RaRangeShrinking.DISABLED, rangeActionsOptimizationParameters.getRaRangeShrinking()); - assertEquals(0.002, rangeActionsOptimizationParameters.getHvdcPenaltyCost(), DOUBLE_TOLERANCE); - assertEquals(0.2, rangeActionsOptimizationParameters.getHvdcSensitivityThreshold(), DOUBLE_TOLERANCE); - assertEquals(0.003, rangeActionsOptimizationParameters.getInjectionRaPenaltyCost(), DOUBLE_TOLERANCE); - assertEquals(0.3, rangeActionsOptimizationParameters.getInjectionRaSensitivityThreshold(), DOUBLE_TOLERANCE); - assertEquals(RangeActionsOptimizationParameters.Solver.XPRESS, rangeActionsOptimizationParameters.getLinearOptimizationSolver().getSolver()); - assertEquals(0.004, rangeActionsOptimizationParameters.getLinearOptimizationSolver().getRelativeMipGap(), DOUBLE_TOLERANCE); - assertEquals("BLABLABLA", rangeActionsOptimizationParameters.getLinearOptimizationSolver().getSolverSpecificParameters()); + assertEquals(2, searchTreeParameters.getRangeActionsOptimizationParameters().getMaxMipIterations(), DOUBLE_TOLERANCE); + assertEquals(0.02, rangeActionsOptimizationParameters.getPstRAMinImpactThreshold(), DOUBLE_TOLERANCE); + assertEquals(0.2, searchTreeParameters.getRangeActionsOptimizationParameters().getPstSensitivityThreshold(), DOUBLE_TOLERANCE); + assertEquals(PstModel.APPROXIMATED_INTEGERS, searchTreeParameters.getRangeActionsOptimizationParameters().getPstModel()); + assertEquals(RaRangeShrinking.DISABLED, searchTreeParameters.getRangeActionsOptimizationParameters().getRaRangeShrinking()); + assertEquals(0.002, rangeActionsOptimizationParameters.getHvdcRAMinImpactThreshold(), DOUBLE_TOLERANCE); + assertEquals(0.2, searchTreeParameters.getRangeActionsOptimizationParameters().getHvdcSensitivityThreshold(), DOUBLE_TOLERANCE); + assertEquals(0.003, rangeActionsOptimizationParameters.getInjectionRAMinImpactThreshold(), DOUBLE_TOLERANCE); + assertEquals(0.3, searchTreeParameters.getRangeActionsOptimizationParameters().getInjectionRaSensitivityThreshold(), DOUBLE_TOLERANCE); + assertEquals(Solver.XPRESS, searchTreeParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().getSolver()); + assertEquals(0.004, searchTreeParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().getRelativeMipGap(), DOUBLE_TOLERANCE); + assertEquals("BLABLABLA", searchTreeParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().getSolverSpecificParameters()); TopoOptimizationParameters topoOptimizationParameters = parameters.getTopoOptimizationParameters(); assertEquals(3, topoOptimizationParameters.getMaxPreventiveSearchTreeDepth(), DOUBLE_TOLERANCE); @@ -91,7 +92,7 @@ void testConfigWithExtensions() throws IOException { assertEquals(2, loadFlowAndSensitivityParameters.getSensitivityFailureOvercost(), DOUBLE_TOLERANCE); // EXTENSIONS - assertEquals(3, parameters.getExtensions().size()); + assertEquals(4, parameters.getExtensions().size()); LoopFlowParametersExtension loopFlowParameters = parameters.getExtension(LoopFlowParametersExtension.class); assertNotNull(loopFlowParameters); @@ -129,18 +130,9 @@ void testConfigWithoutExtensions() throws IOException { assertFalse(objectiveFunctionParameters.getEnforceCurativeSecurity()); RangeActionsOptimizationParameters rangeActionsOptimizationParameters = parameters.getRangeActionsOptimizationParameters(); - assertEquals(2, rangeActionsOptimizationParameters.getMaxMipIterations(), DOUBLE_TOLERANCE); - assertEquals(0.02, rangeActionsOptimizationParameters.getPstPenaltyCost(), DOUBLE_TOLERANCE); - assertEquals(0.2, rangeActionsOptimizationParameters.getPstSensitivityThreshold(), DOUBLE_TOLERANCE); - assertEquals(RangeActionsOptimizationParameters.PstModel.APPROXIMATED_INTEGERS, rangeActionsOptimizationParameters.getPstModel()); - assertEquals(RangeActionsOptimizationParameters.RaRangeShrinking.DISABLED, rangeActionsOptimizationParameters.getRaRangeShrinking()); - assertEquals(0.002, rangeActionsOptimizationParameters.getHvdcPenaltyCost(), DOUBLE_TOLERANCE); - assertEquals(0.2, rangeActionsOptimizationParameters.getHvdcSensitivityThreshold(), DOUBLE_TOLERANCE); - assertEquals(0.003, rangeActionsOptimizationParameters.getInjectionRaPenaltyCost(), DOUBLE_TOLERANCE); - assertEquals(0.3, rangeActionsOptimizationParameters.getInjectionRaSensitivityThreshold(), DOUBLE_TOLERANCE); - assertEquals(RangeActionsOptimizationParameters.Solver.XPRESS, rangeActionsOptimizationParameters.getLinearOptimizationSolver().getSolver()); - assertEquals(0.004, rangeActionsOptimizationParameters.getLinearOptimizationSolver().getRelativeMipGap(), DOUBLE_TOLERANCE); - assertEquals("BLABLABLA", rangeActionsOptimizationParameters.getLinearOptimizationSolver().getSolverSpecificParameters()); + assertEquals(0.02, rangeActionsOptimizationParameters.getPstRAMinImpactThreshold(), DOUBLE_TOLERANCE); + assertEquals(0.002, rangeActionsOptimizationParameters.getHvdcRAMinImpactThreshold(), DOUBLE_TOLERANCE); + assertEquals(0.003, rangeActionsOptimizationParameters.getInjectionRAMinImpactThreshold(), DOUBLE_TOLERANCE); TopoOptimizationParameters topoOptimizationParameters = parameters.getTopoOptimizationParameters(); assertEquals(3, topoOptimizationParameters.getMaxPreventiveSearchTreeDepth(), DOUBLE_TOLERANCE); @@ -190,6 +182,7 @@ void testConfigWithoutExtensions() throws IOException { @Test void testConfigWithPartialExtensions() throws IOException { RaoParameters parameters = loadRaoParameters("config_withPartialExtensions"); + OpenRaoSearchTreeParameters searchTreeParameters = parameters.getExtension(OpenRaoSearchTreeParameters.class); ObjectiveFunctionParameters objectiveFunctionParameters = parameters.getObjectiveFunctionParameters(); assertEquals(ObjectiveFunctionParameters.ObjectiveFunctionType.MAX_MIN_MARGIN, objectiveFunctionParameters.getType()); @@ -197,18 +190,18 @@ void testConfigWithPartialExtensions() throws IOException { assertFalse(objectiveFunctionParameters.getEnforceCurativeSecurity()); RangeActionsOptimizationParameters rangeActionsOptimizationParameters = parameters.getRangeActionsOptimizationParameters(); - assertEquals(10, rangeActionsOptimizationParameters.getMaxMipIterations(), DOUBLE_TOLERANCE); - assertEquals(0.02, rangeActionsOptimizationParameters.getPstPenaltyCost(), DOUBLE_TOLERANCE); - assertEquals(0.2, rangeActionsOptimizationParameters.getPstSensitivityThreshold(), DOUBLE_TOLERANCE); - assertEquals(RangeActionsOptimizationParameters.PstModel.APPROXIMATED_INTEGERS, rangeActionsOptimizationParameters.getPstModel()); - assertEquals(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED, rangeActionsOptimizationParameters.getRaRangeShrinking()); - assertEquals(0.002, rangeActionsOptimizationParameters.getHvdcPenaltyCost(), DOUBLE_TOLERANCE); - assertEquals(0.2, rangeActionsOptimizationParameters.getHvdcSensitivityThreshold(), DOUBLE_TOLERANCE); - assertEquals(0.003, rangeActionsOptimizationParameters.getInjectionRaPenaltyCost(), DOUBLE_TOLERANCE); - assertEquals(0.3, rangeActionsOptimizationParameters.getInjectionRaSensitivityThreshold(), DOUBLE_TOLERANCE); - assertEquals(RangeActionsOptimizationParameters.Solver.CBC, rangeActionsOptimizationParameters.getLinearOptimizationSolver().getSolver()); - assertEquals(0.004, rangeActionsOptimizationParameters.getLinearOptimizationSolver().getRelativeMipGap(), DOUBLE_TOLERANCE); - assertEquals("BLABLABLA", rangeActionsOptimizationParameters.getLinearOptimizationSolver().getSolverSpecificParameters()); + assertEquals(10, searchTreeParameters.getRangeActionsOptimizationParameters().getMaxMipIterations(), DOUBLE_TOLERANCE); + assertEquals(0.02, rangeActionsOptimizationParameters.getPstRAMinImpactThreshold(), DOUBLE_TOLERANCE); + assertEquals(0.2, searchTreeParameters.getRangeActionsOptimizationParameters().getPstSensitivityThreshold(), DOUBLE_TOLERANCE); + assertEquals(PstModel.APPROXIMATED_INTEGERS, searchTreeParameters.getRangeActionsOptimizationParameters().getPstModel()); + assertEquals(RaRangeShrinking.ENABLED, searchTreeParameters.getRangeActionsOptimizationParameters().getRaRangeShrinking()); + assertEquals(0.002, rangeActionsOptimizationParameters.getHvdcRAMinImpactThreshold(), DOUBLE_TOLERANCE); + assertEquals(0.2, searchTreeParameters.getRangeActionsOptimizationParameters().getHvdcSensitivityThreshold(), DOUBLE_TOLERANCE); + assertEquals(0.003, rangeActionsOptimizationParameters.getInjectionRAMinImpactThreshold(), DOUBLE_TOLERANCE); + assertEquals(0.3, searchTreeParameters.getRangeActionsOptimizationParameters().getInjectionRaSensitivityThreshold(), DOUBLE_TOLERANCE); + assertEquals(Solver.CBC, searchTreeParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().getSolver()); + assertEquals(0.004, searchTreeParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().getRelativeMipGap(), DOUBLE_TOLERANCE); + assertEquals("BLABLABLA", searchTreeParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().getSolverSpecificParameters()); TopoOptimizationParameters topoOptimizationParameters = parameters.getTopoOptimizationParameters(); assertEquals(3, topoOptimizationParameters.getMaxPreventiveSearchTreeDepth(), DOUBLE_TOLERANCE); @@ -240,7 +233,7 @@ void testConfigWithPartialExtensions() throws IOException { assertEquals(2, loadFlowAndSensitivityParameters.getSensitivityFailureOvercost(), DOUBLE_TOLERANCE); // EXTENSIONS - assertEquals(2, parameters.getExtensions().size()); + assertEquals(3, parameters.getExtensions().size()); LoopFlowParametersExtension loopFlowParameters = parameters.getExtension(LoopFlowParametersExtension.class); assertNotNull(loopFlowParameters); diff --git a/ra-optimisation/rao-api/src/test/resources/RaoParametersWithExtension_v2.json b/ra-optimisation/rao-api/src/test/resources/RaoParametersWithExtension_v2.json index a0f71d9fae..444d5d5b54 100644 --- a/ra-optimisation/rao-api/src/test/resources/RaoParametersWithExtension_v2.json +++ b/ra-optimisation/rao-api/src/test/resources/RaoParametersWithExtension_v2.json @@ -66,23 +66,6 @@ "curative-leaves-in-parallel" : 1 }, "extensions" : { - "dummy-extension" : { - - }, - "open-rao-search-tree-parameters" : { - "range-actions-optimization" : { - "max-mip-iterations" : 10, - "pst-sensitivity-threshold" : 1.0E-6, - "pst-model" : "CONTINUOUS", - "hvdc-sensitivity-threshold" : 1.0E-6, - "injection-ra-sensitivity-threshold" : 1.0E-6, - "ra-range-shrinking" : "DISABLED", - "linear-optimization-solver" : { - "solver" : "CBC", - "relative-mip-gap" : 1.0E-4, - "solver-specific-parameters" : null - } - } - } + "dummy-extension" : { } } } \ No newline at end of file diff --git a/ra-optimisation/rao-api/src/test/resources/RaoParameters_config_withOLFParams.json b/ra-optimisation/rao-api/src/test/resources/RaoParameters_config_withOLFParams.json index 8cb786f955..bbe37eaaa2 100644 --- a/ra-optimisation/rao-api/src/test/resources/RaoParameters_config_withOLFParams.json +++ b/ra-optimisation/rao-api/src/test/resources/RaoParameters_config_withOLFParams.json @@ -141,22 +141,5 @@ "preventive-leaves-in-parallel" : 1, "auto-leaves-in-parallel" : 1, "curative-leaves-in-parallel" : 1 - }, - "extensions" : { - "open-rao-search-tree-parameters" : { - "range-actions-optimization" : { - "max-mip-iterations" : 10, - "pst-sensitivity-threshold" : 1.0E-6, - "pst-model" : "CONTINUOUS", - "hvdc-sensitivity-threshold" : 1.0E-6, - "injection-ra-sensitivity-threshold" : 1.0E-6, - "ra-range-shrinking" : "DISABLED", - "linear-optimization-solver" : { - "solver" : "CBC", - "relative-mip-gap" : 1.0E-4, - "solver-specific-parameters" : null - } - } - } } } \ No newline at end of file diff --git a/ra-optimisation/rao-api/src/test/resources/RaoParameters_config_withoutExtensions.json b/ra-optimisation/rao-api/src/test/resources/RaoParameters_config_withoutExtensions.json index b10168b4e3..1e61a71a18 100644 --- a/ra-optimisation/rao-api/src/test/resources/RaoParameters_config_withoutExtensions.json +++ b/ra-optimisation/rao-api/src/test/resources/RaoParameters_config_withoutExtensions.json @@ -141,22 +141,5 @@ "preventive-leaves-in-parallel" : 5, "auto-leaves-in-parallel" : 3, "curative-leaves-in-parallel" : 6 - }, - "extensions" : { - "open-rao-search-tree-parameters" : { - "range-actions-optimization" : { - "max-mip-iterations" : 2, - "pst-sensitivity-threshold" : 0.2, - "pst-model" : "APPROXIMATED_INTEGERS", - "hvdc-sensitivity-threshold" : 0.2, - "injection-ra-sensitivity-threshold" : 0.3, - "ra-range-shrinking" : "DISABLED", - "linear-optimization-solver" : { - "solver" : "XPRESS", - "relative-mip-gap" : 0.004, - "solver-specific-parameters" : "BLABLABLA" - } - } - } } } \ No newline at end of file diff --git a/ra-optimisation/rao-api/src/test/resources/RaoParameters_v2.json b/ra-optimisation/rao-api/src/test/resources/RaoParameters_v2.json index 0d02470bad..e195179a03 100644 --- a/ra-optimisation/rao-api/src/test/resources/RaoParameters_v2.json +++ b/ra-optimisation/rao-api/src/test/resources/RaoParameters_v2.json @@ -64,22 +64,5 @@ "preventive-leaves-in-parallel" : 1, "auto-leaves-in-parallel" : 1, "curative-leaves-in-parallel" : 1 - }, - "extensions" : { - "open-rao-search-tree-parameters" : { - "range-actions-optimization" : { - "max-mip-iterations" : 10, - "pst-sensitivity-threshold" : 1.0E-6, - "pst-model" : "CONTINUOUS", - "hvdc-sensitivity-threshold" : 1.0E-6, - "injection-ra-sensitivity-threshold" : 1.0E-6, - "ra-range-shrinking" : "DISABLED", - "linear-optimization-solver" : { - "solver" : "CBC", - "relative-mip-gap" : 1.0E-4, - "solver-specific-parameters" : null - } - } - } } } \ No newline at end of file diff --git a/ra-optimisation/rao-api/src/test/resources/config_withExtensions.yml b/ra-optimisation/rao-api/src/test/resources/config_withExtensions.yml index a9c06c5d70..d2416fba94 100644 --- a/ra-optimisation/rao-api/src/test/resources/config_withExtensions.yml +++ b/ra-optimisation/rao-api/src/test/resources/config_withExtensions.yml @@ -7,12 +7,6 @@ rao-range-actions-optimization: hvdc-ra-min-impact-threshold: 0.002 injection-ra-min-impact-threshold: 0.003 - -rao-linear-optimization-solver: - solver: XPRESS - relative-mip-gap: 0.004 - solver-specific-parameters: BLABLABLA - rao-topological-actions-optimization: max-preventive-search-tree-depth: 3 max-auto-search-tree-depth: 2 @@ -64,4 +58,9 @@ search-tree-range-actions-optimization: pst-sensitivity-threshold: 0.2 pst-model: APPROXIMATED_INTEGERS hvdc-sensitivity-threshold: 0.2 - injection-ra-sensitivity-threshold: 0.3 \ No newline at end of file + injection-ra-sensitivity-threshold: 0.3 + +search-tree-linear-optimization-solver: + solver: XPRESS + relative-mip-gap: 0.004 + solver-specific-parameters: BLABLABLA \ No newline at end of file diff --git a/ra-optimisation/rao-api/src/test/resources/config_withPartialExtensions.yml b/ra-optimisation/rao-api/src/test/resources/config_withPartialExtensions.yml index a6fb34d944..3a03f060b6 100644 --- a/ra-optimisation/rao-api/src/test/resources/config_withPartialExtensions.yml +++ b/ra-optimisation/rao-api/src/test/resources/config_withPartialExtensions.yml @@ -7,10 +7,6 @@ rao-range-actions-optimization: hvdc-ra-min-impact-threshold: 0.002 injection-ra-min-impact-threshold: 0.003 -rao-linear-optimization-solver: - relative-mip-gap: 0.004 - solver-specific-parameters: BLABLABLA - rao-topological-actions-optimization: max-preventive-search-tree-depth: 3 max-auto-search-tree-depth: 2 @@ -49,4 +45,8 @@ search-tree-range-actions-optimization: pst-model: APPROXIMATED_INTEGERS ra-range-shrinking: ENABLED hvdc-sensitivity-threshold: 0.2 - injection-ra-sensitivity-threshold: 0.3 \ No newline at end of file + injection-ra-sensitivity-threshold: 0.3 + +search-tree-linear-optimization-solver: + relative-mip-gap: 0.004 + solver-specific-parameters: BLABLABLA \ No newline at end of file diff --git a/ra-optimisation/rao-api/src/test/resources/config_withoutExtensions.yml b/ra-optimisation/rao-api/src/test/resources/config_withoutExtensions.yml index 765f5a5b57..3d70c4725f 100644 --- a/ra-optimisation/rao-api/src/test/resources/config_withoutExtensions.yml +++ b/ra-optimisation/rao-api/src/test/resources/config_withoutExtensions.yml @@ -8,11 +8,6 @@ rao-range-actions-optimization: hvdc-ra-min-impact-threshold: 0.002 injection-ra-min-impact-threshold: 0.003 -rao-linear-optimization-solver: - solver: XPRESS - relative-mip-gap: 0.004 - solver-specific-parameters: BLABLABLA - rao-topological-actions-optimization: max-preventive-search-tree-depth: 3 max-auto-search-tree-depth: 2 @@ -40,12 +35,4 @@ rao-multi-threading: contingency-scenarios-in-parallel: 4 preventive-leaves-in-parallel: 5 auto-leaves-in-parallel: 3 - curative-leaves-in-parallel: 6 - -search-tree-range-actions-optimization: - max-mip-iterations: 2 - pst-sensitivity-threshold: 0.2 - pst-model: APPROXIMATED_INTEGERS - ra-range-shrinking: DISABLED - hvdc-sensitivity-threshold: 0.2 - injection-ra-sensitivity-threshold: 0.3 \ No newline at end of file + curative-leaves-in-parallel: 6 \ No newline at end of file diff --git a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/commons/RaoUtil.java b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/commons/RaoUtil.java index 185558e598..3e7c6343e4 100644 --- a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/commons/RaoUtil.java +++ b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/commons/RaoUtil.java @@ -19,7 +19,7 @@ import com.powsybl.openrao.data.cracapi.usagerule.*; import com.powsybl.openrao.data.refprog.referenceprogram.ReferenceProgramBuilder; import com.powsybl.openrao.raoapi.RaoInput; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.PstModel; import com.powsybl.openrao.raoapi.parameters.RaoParameters; import com.powsybl.openrao.raoapi.parameters.extensions.LoopFlowParametersExtension; import com.powsybl.openrao.raoapi.parameters.extensions.RelativeMarginsParametersExtension; @@ -33,6 +33,7 @@ import java.util.Set; import java.util.stream.Collectors; +import static com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.getPstModel; import static java.lang.String.format; /** @@ -76,7 +77,7 @@ public static void checkParameters(RaoParameters raoParameters, RaoInput raoInpu throw new OpenRaoException(msg); } - if (!RangeActionsOptimizationParameters.PstModel.APPROXIMATED_INTEGERS.equals(raoParameters.getRangeActionsOptimizationParameters().getPstModel()) + if (!PstModel.APPROXIMATED_INTEGERS.equals(getPstModel(raoParameters)) && raoInput.getCrac().getRaUsageLimitsPerInstant().values().stream().anyMatch(raUsageLimits -> !raUsageLimits.getMaxElementaryActionsPerTso().isEmpty())) { String msg = "The PSTs must be approximated as integers to use the limitations of elementary actions as a constraint in the RAO."; OpenRaoLoggerProvider.BUSINESS_LOGS.error(msg); diff --git a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/commons/parameters/TreeParameters.java b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/commons/parameters/TreeParameters.java index e9755308a8..6653db812a 100644 --- a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/commons/parameters/TreeParameters.java +++ b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/commons/parameters/TreeParameters.java @@ -7,9 +7,11 @@ package com.powsybl.openrao.searchtreerao.commons.parameters; import com.powsybl.openrao.raoapi.parameters.ObjectiveFunctionParameters; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters; import com.powsybl.openrao.raoapi.parameters.RaoParameters; +import static com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.getRaRangeShrinking; + /** * This class contains internal Open RAO parameters used in the SearchTree algorithm. * These parameters are dynamically generated by the SearchTreeRaoProvider depending on the context and on @@ -26,7 +28,7 @@ public enum StopCriterion { } public static TreeParameters buildForPreventivePerimeter(RaoParameters parameters) { - RangeActionsOptimizationParameters.RaRangeShrinking raRangeShrinking = parameters.getRangeActionsOptimizationParameters().getRaRangeShrinking(); + RangeActionsOptimizationParameters.RaRangeShrinking raRangeShrinking = getRaRangeShrinking(parameters); boolean shouldShrinkRaRange = raRangeShrinking.equals(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED_IN_FIRST_PRAO_AND_CRAO) || raRangeShrinking.equals(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED); if (parameters.getObjectiveFunctionParameters().getType() == ObjectiveFunctionParameters.ObjectiveFunctionType.SECURE_FLOW) { @@ -59,7 +61,7 @@ public static TreeParameters buildForCurativePerimeter(RaoParameters parameters, targetObjectiveValue = Math.min(targetObjectiveValue, 0); } } - RangeActionsOptimizationParameters.RaRangeShrinking raRangeShrinking = parameters.getRangeActionsOptimizationParameters().getRaRangeShrinking(); + RangeActionsOptimizationParameters.RaRangeShrinking raRangeShrinking = getRaRangeShrinking(parameters); boolean shouldShrinkRaRange = raRangeShrinking.equals(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED_IN_FIRST_PRAO_AND_CRAO) || raRangeShrinking.equals(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED); return new TreeParameters(stopCriterion, @@ -70,7 +72,7 @@ public static TreeParameters buildForCurativePerimeter(RaoParameters parameters, } public static TreeParameters buildForSecondPreventivePerimeter(RaoParameters parameters) { - boolean raRangeShrinking = parameters.getRangeActionsOptimizationParameters().getRaRangeShrinking().equals(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED); + boolean raRangeShrinking = getRaRangeShrinking(parameters).equals(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED); if (parameters.getObjectiveFunctionParameters().getType().equals(ObjectiveFunctionParameters.ObjectiveFunctionType.SECURE_FLOW)) { return new TreeParameters(StopCriterion.AT_TARGET_OBJECTIVE_VALUE, 0.0, // secure diff --git a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/IteratingLinearOptimizer.java b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/IteratingLinearOptimizer.java index 3f6cae07c5..59c7f167ff 100644 --- a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/IteratingLinearOptimizer.java +++ b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/IteratingLinearOptimizer.java @@ -9,7 +9,7 @@ import com.powsybl.openrao.data.cracapi.rangeaction.PstRangeAction; import com.powsybl.openrao.data.raoresultapi.ComputationStatus; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.PstModel; import com.powsybl.openrao.searchtreerao.commons.SensitivityComputer; import com.powsybl.openrao.searchtreerao.commons.objectivefunctionevaluator.ObjectiveFunction; import com.powsybl.openrao.searchtreerao.commons.optimizationperimeters.GlobalOptimizationPerimeter; @@ -28,6 +28,7 @@ import java.util.Locale; import static com.powsybl.openrao.commons.logs.OpenRaoLoggerProvider.*; +import static com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.getPstModel; /** * @author Joris Mancini {@literal } @@ -126,7 +127,7 @@ private static SensitivityComputer runSensitivityAnalysis(SensitivityComputer se private static RangeActionActivationResult resolveIfApproximatedPstTaps(IteratingLinearOptimizationResultImpl bestResult, LinearProblem linearProblem, int iteration, RangeActionActivationResult currentRangeActionActivationResult, IteratingLinearOptimizerInput input, IteratingLinearOptimizerParameters parameters) { LinearProblemStatus solveStatus; RangeActionActivationResult rangeActionActivationResult = currentRangeActionActivationResult; - if (parameters.getRangeActionParameters().getPstModel().equals(RangeActionsOptimizationParameters.PstModel.APPROXIMATED_INTEGERS)) { + if (getPstModel(parameters.getRangeActionParametersExtension()).equals(PstModel.APPROXIMATED_INTEGERS)) { // if the PST approximation is APPROXIMATED_INTEGERS, we re-solve the optimization problem // but first, we update it, with an adjustment of the PSTs angleToTap conversion factors, to @@ -240,7 +241,7 @@ private static RangeActionActivationResult roundResult(RangeActionActivationResu } private static RangeActionActivationResultImpl roundPsts(RangeActionActivationResult linearProblemResult, IteratingLinearOptimizationResultImpl previousResult, IteratingLinearOptimizerInput input, IteratingLinearOptimizerParameters parameters) { - if (parameters.getRangeActionParameters().getPstModel().equals(RangeActionsOptimizationParameters.PstModel.CONTINUOUS)) { + if (getPstModel(parameters.getRangeActionParametersExtension()).equals(PstModel.CONTINUOUS)) { return BestTapFinder.round( linearProblemResult, input.getNetwork(), diff --git a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/CoreProblemFiller.java b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/CoreProblemFiller.java index 9781309c97..2b97cde507 100644 --- a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/CoreProblemFiller.java +++ b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/CoreProblemFiller.java @@ -18,6 +18,7 @@ import com.powsybl.openrao.data.cracapi.range.TapRange; import com.powsybl.openrao.data.cracapi.rangeaction.*; import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.PstModel; import com.powsybl.openrao.searchtreerao.commons.RaoUtil; import com.powsybl.openrao.searchtreerao.commons.optimizationperimeters.OptimizationPerimeter; import com.powsybl.openrao.searchtreerao.linearoptimisation.algorithms.linearproblem.OpenRaoMPConstraint; @@ -32,6 +33,8 @@ import java.util.*; +import static com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.*; + /** * @author Pengbo Wang {@literal } * @author Baptiste Seguinot {@literal } @@ -44,24 +47,28 @@ public class CoreProblemFiller implements ProblemFiller { private final Set flowCnecs; private final RangeActionSetpointResult prePerimeterRangeActionSetpoints; private final RangeActionsOptimizationParameters rangeActionParameters; + private final com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters rangeActionParametersExtension; + private final Unit unit; private int iteration = 0; private static final double RANGE_SHRINK_RATE = 0.667; private final boolean raRangeShrinking; - private final RangeActionsOptimizationParameters.PstModel pstModel; + private final PstModel pstModel; public CoreProblemFiller(OptimizationPerimeter optimizationContext, RangeActionSetpointResult prePerimeterRangeActionSetpoints, RangeActionsOptimizationParameters rangeActionParameters, + com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters rangeActionParametersExtension, Unit unit, boolean raRangeShrinking, - RangeActionsOptimizationParameters.PstModel pstModel) { + PstModel pstModel) { this.optimizationContext = optimizationContext; this.flowCnecs = new TreeSet<>(Comparator.comparing(Identifiable::getId)); this.flowCnecs.addAll(optimizationContext.getFlowCnecs()); this.prePerimeterRangeActionSetpoints = prePerimeterRangeActionSetpoints; this.rangeActionParameters = rangeActionParameters; + this.rangeActionParametersExtension = rangeActionParametersExtension; this.unit = unit; this.raRangeShrinking = raRangeShrinking; this.pstModel = pstModel; @@ -183,11 +190,11 @@ private void addImpactOfRangeActionOnCnec(LinearProblem linearProblem, Sensitivi private boolean isRangeActionSensitivityAboveThreshold(RangeAction rangeAction, double sensitivity) { if (rangeAction instanceof PstRangeAction) { - return sensitivity >= rangeActionParameters.getPstSensitivityThreshold(); + return sensitivity >= getPstSensitivityThreshold(rangeActionParametersExtension); } else if (rangeAction instanceof HvdcRangeAction) { - return sensitivity >= rangeActionParameters.getHvdcSensitivityThreshold(); + return sensitivity >= getHvdcSensitivityThreshold(rangeActionParametersExtension); } else if (rangeAction instanceof InjectionRangeAction) { - return sensitivity >= rangeActionParameters.getInjectionRaSensitivityThreshold(); + return sensitivity >= getInjectionRaSensitivityThreshold(rangeActionParametersExtension); } else { throw new OpenRaoException("Type of RangeAction not yet handled by the LinearRao."); } @@ -289,7 +296,7 @@ private void buildConstraintsForRangeActionAndState(LinearProblem linearProblem, double maxRelativeSetpoint = minAndMaxAbsoluteAndRelativeSetpoints.get(3); // relative range - if (pstModel.equals(RangeActionsOptimizationParameters.PstModel.CONTINUOUS) || !(rangeAction instanceof PstRangeAction)) { + if (pstModel.equals(PstModel.CONTINUOUS) || !(rangeAction instanceof PstRangeAction)) { OpenRaoMPConstraint relSetpointConstraint = linearProblem.addRangeActionRelativeSetpointConstraint(minRelativeSetpoint, maxRelativeSetpoint, rangeAction, state, LinearProblem.RaRangeShrinking.FALSE); relSetpointConstraint.setCoefficient(setPointVariable, 1); relSetpointConstraint.setCoefficient(previousSetpointVariable, -1); @@ -408,11 +415,11 @@ private void fillObjectiveWithRangeActionPenaltyCost(LinearProblem linearProblem // If the range action has been filtered out, then absoluteVariationVariable is null if (absoluteVariationVariable != null && ra instanceof PstRangeAction) { - linearProblem.getObjective().setCoefficient(absoluteVariationVariable, rangeActionParameters.getPstPenaltyCost()); + linearProblem.getObjective().setCoefficient(absoluteVariationVariable, rangeActionParameters.getPstRAMinImpactThreshold()); } else if (absoluteVariationVariable != null && ra instanceof HvdcRangeAction) { - linearProblem.getObjective().setCoefficient(absoluteVariationVariable, rangeActionParameters.getHvdcPenaltyCost()); + linearProblem.getObjective().setCoefficient(absoluteVariationVariable, rangeActionParameters.getHvdcRAMinImpactThreshold()); } else if (absoluteVariationVariable != null && ra instanceof InjectionRangeAction) { - linearProblem.getObjective().setCoefficient(absoluteVariationVariable, rangeActionParameters.getInjectionRaPenaltyCost()); + linearProblem.getObjective().setCoefficient(absoluteVariationVariable, rangeActionParameters.getInjectionRAMinImpactThreshold()); } } )); diff --git a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/linearproblem/LinearProblem.java b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/linearproblem/LinearProblem.java index 67c731a3ff..e4bc0b5772 100644 --- a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/linearproblem/LinearProblem.java +++ b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/linearproblem/LinearProblem.java @@ -12,7 +12,7 @@ import com.powsybl.iidm.network.TwoSides; import com.powsybl.openrao.data.cracapi.rangeaction.PstRangeAction; import com.powsybl.openrao.data.cracapi.rangeaction.RangeAction; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters; import com.powsybl.openrao.searchtreerao.linearoptimisation.algorithms.fillers.ProblemFiller; import com.powsybl.openrao.searchtreerao.result.api.FlowResult; import com.powsybl.openrao.searchtreerao.result.api.LinearProblemStatus; diff --git a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/linearproblem/LinearProblemBuilder.java b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/linearproblem/LinearProblemBuilder.java index 7fc5c8a7fc..1d16af7e96 100644 --- a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/linearproblem/LinearProblemBuilder.java +++ b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/linearproblem/LinearProblemBuilder.java @@ -9,7 +9,7 @@ import com.powsybl.openrao.data.cracapi.State; import com.powsybl.openrao.data.cracapi.rangeaction.PstRangeAction; import com.powsybl.openrao.data.cracapi.rangeaction.RangeAction; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters; import com.powsybl.openrao.searchtreerao.commons.optimizationperimeters.CurativeOptimizationPerimeter; import com.powsybl.openrao.searchtreerao.linearoptimisation.algorithms.fillers.*; import com.powsybl.openrao.searchtreerao.linearoptimisation.inputs.IteratingLinearOptimizerInput; @@ -19,6 +19,8 @@ import java.util.*; import java.util.stream.Collectors; +import static com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.getPstModel; + /** * @author Baptiste Seguinot {@literal } */ @@ -68,7 +70,7 @@ public LinearProblem buildFromInputsAndParameters(IteratingLinearOptimizerInput } // MIP optimization vs. CONTINUOUS optimization - if (parameters.getRangeActionParameters().getPstModel().equals(RangeActionsOptimizationParameters.PstModel.APPROXIMATED_INTEGERS)) { + if (getPstModel(parameters.getRangeActionParametersExtension()).equals(RangeActionsOptimizationParameters.PstModel.APPROXIMATED_INTEGERS)) { Map> pstRangeActions = copyOnlyPstRangeActions(inputs.getOptimizationPerimeter().getRangeActionsPerState()); Map>> otherRa = copyWithoutPstRangeActions(inputs.getOptimizationPerimeter().getRangeActionsPerState()); this.withProblemFiller(buildIntegerPstTapFiller(pstRangeActions)); @@ -97,7 +99,7 @@ public LinearProblemBuilder withProblemFiller(ProblemFiller problemFiller) { return this; } - public LinearProblemBuilder withSolver(RangeActionsOptimizationParameters.Solver solver) { + public LinearProblemBuilder withSolver(com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.Solver solver) { this.solver = solver; return this; } @@ -121,10 +123,11 @@ private ProblemFiller buildCoreProblemFiller() { return new CoreProblemFiller( inputs.getOptimizationPerimeter(), inputs.getPrePerimeterSetpoints(), - parameters.getRangeActionParameters(), + parameters.getRangeActionParameters(), + parameters.getRangeActionParametersExtension(), parameters.getObjectiveFunctionUnit(), parameters.getRaRangeShrinking(), - parameters.getRangeActionParameters().getPstModel() + getPstModel(parameters.getRangeActionParametersExtension()) ); } @@ -193,7 +196,7 @@ private ProblemFiller buildRaUsageLimitsFiller() { inputs.getOptimizationPerimeter().getRangeActionsPerState(), inputs.getPrePerimeterSetpoints(), parameters.getRaLimitationParameters(), - parameters.getRangeActionParameters().getPstModel() == RangeActionsOptimizationParameters.PstModel.APPROXIMATED_INTEGERS, + getPstModel(parameters.getRangeActionParametersExtension()) == RangeActionsOptimizationParameters.PstModel.APPROXIMATED_INTEGERS, inputs.getNetwork()); } diff --git a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/linearproblem/OpenRaoMPSolver.java b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/linearproblem/OpenRaoMPSolver.java index b879396ffa..230963404b 100644 --- a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/linearproblem/OpenRaoMPSolver.java +++ b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/linearproblem/OpenRaoMPSolver.java @@ -12,7 +12,7 @@ import com.google.ortools.linearsolver.MPSolverParameters; import com.powsybl.openrao.commons.OpenRaoException; import com.powsybl.openrao.commons.logs.OpenRaoLoggerProvider; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters; import com.powsybl.openrao.searchtreerao.result.api.LinearProblemStatus; import java.util.Map; diff --git a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/parameters/IteratingLinearOptimizerParameters.java b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/parameters/IteratingLinearOptimizerParameters.java index dfbdf8cf01..23f8f9645d 100644 --- a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/parameters/IteratingLinearOptimizerParameters.java +++ b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/parameters/IteratingLinearOptimizerParameters.java @@ -10,6 +10,7 @@ import com.powsybl.openrao.commons.OpenRaoException; import com.powsybl.openrao.commons.Unit; import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.LinearOptimizationSolver; import com.powsybl.openrao.raoapi.parameters.extensions.LoopFlowParametersExtension; import com.powsybl.openrao.raoapi.parameters.extensions.MnecParametersExtension; import com.powsybl.openrao.raoapi.parameters.extensions.RelativeMarginsParametersExtension; @@ -23,12 +24,13 @@ public final class IteratingLinearOptimizerParameters { private final Unit objectiveFunctionUnit; private final boolean relativePositiveMargins; private final RangeActionsOptimizationParameters rangeActionParameters; + private final com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters rangeActionParametersExtension; private final MnecParametersExtension mnecParameters; private final RelativeMarginsParametersExtension maxMinRelativeMarginParameters; private final LoopFlowParametersExtension loopFlowParameters; private final UnoptimizedCnecParameters unoptimizedCnecParameters; private final RangeActionLimitationParameters raLimitationParameters; - private final RangeActionsOptimizationParameters.LinearOptimizationSolver solverParameters; + private final LinearOptimizationSolver solverParameters; private final int maxNumberOfIterations; private final boolean raRangeShrinking; @@ -36,17 +38,19 @@ public final class IteratingLinearOptimizerParameters { private IteratingLinearOptimizerParameters(Unit objectiveFunctionUnit, boolean relativePositiveMargins, RangeActionsOptimizationParameters rangeActionParameters, + com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters rangeActionParametersExtension, MnecParametersExtension mnecParameters, RelativeMarginsParametersExtension maxMinRelativeMarginParameters, LoopFlowParametersExtension loopFlowParameters, UnoptimizedCnecParameters unoptimizedCnecParameters, RangeActionLimitationParameters raLimitationParameters, - RangeActionsOptimizationParameters.LinearOptimizationSolver solverParameters, + LinearOptimizationSolver solverParameters, int maxNumberOfIterations, boolean raRangeShrinking) { this.objectiveFunctionUnit = objectiveFunctionUnit; this.relativePositiveMargins = relativePositiveMargins; this.rangeActionParameters = rangeActionParameters; + this.rangeActionParametersExtension = rangeActionParametersExtension; this.mnecParameters = mnecParameters; this.maxMinRelativeMarginParameters = maxMinRelativeMarginParameters; this.loopFlowParameters = loopFlowParameters; @@ -77,6 +81,10 @@ public RangeActionsOptimizationParameters getRangeActionParameters() { return rangeActionParameters; } + public com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters getRangeActionParametersExtension() { + return rangeActionParametersExtension; + } + public MnecParametersExtension getMnecParameters() { return mnecParameters; } @@ -97,7 +105,7 @@ public RangeActionLimitationParameters getRaLimitationParameters() { return raLimitationParameters; } - public RangeActionsOptimizationParameters.LinearOptimizationSolver getSolverParameters() { + public LinearOptimizationSolver getSolverParameters() { return solverParameters; } @@ -118,12 +126,14 @@ public static class LinearOptimizerParametersBuilder { private Unit objectiveFunctionUnit; private boolean relativePositiveMargins; private RangeActionsOptimizationParameters rangeActionParameters; + private com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters rangeActionParametersExtension; + private MnecParametersExtension mnecParameters; private RelativeMarginsParametersExtension maxMinRelativeMarginParameters; private LoopFlowParametersExtension loopFlowParameters; private UnoptimizedCnecParameters unoptimizedCnecParameters; private RangeActionLimitationParameters raLimitationParameters; - private RangeActionsOptimizationParameters.LinearOptimizationSolver solverParameters; + private LinearOptimizationSolver solverParameters; private int maxNumberOfIterations; private boolean raRangeShrinking; @@ -142,6 +152,11 @@ public LinearOptimizerParametersBuilder withRangeActionParameters(RangeActionsOp return this; } + public LinearOptimizerParametersBuilder withRangeActionParametersExtension(com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters rangeActionParameters) { + this.rangeActionParametersExtension = rangeActionParameters; + return this; + } + public LinearOptimizerParametersBuilder withMnecParameters(MnecParametersExtension mnecParameters) { this.mnecParameters = mnecParameters; return this; @@ -167,7 +182,7 @@ public LinearOptimizerParametersBuilder withRaLimitationParameters(RangeActionLi return this; } - public LinearOptimizerParametersBuilder withSolverParameters(RangeActionsOptimizationParameters.LinearOptimizationSolver solverParameters) { + public LinearOptimizerParametersBuilder withSolverParameters(LinearOptimizationSolver solverParameters) { this.solverParameters = solverParameters; return this; } @@ -191,6 +206,7 @@ public IteratingLinearOptimizerParameters build() { objectiveFunctionUnit, relativePositiveMargins, rangeActionParameters, + rangeActionParametersExtension, mnecParameters, maxMinRelativeMarginParameters, loopFlowParameters, diff --git a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/searchtree/algorithms/Leaf.java b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/searchtree/algorithms/Leaf.java index e5676b5a2d..95bfba3b21 100644 --- a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/searchtree/algorithms/Leaf.java +++ b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/searchtree/algorithms/Leaf.java @@ -210,6 +210,7 @@ void optimize(SearchTreeInput searchTreeInput, SearchTreeParameters parameters) .withObjectiveFunctionUnit(parameters.getObjectiveFunctionUnit()) .withRelativePositiveMargins(parameters.relativePositiveMargins()) .withRangeActionParameters(parameters.getRangeActionParameters()) + .withRangeActionParametersExtension(parameters.getRangeActionParametersExtension()) .withMnecParameters(parameters.getMnecParameters()) .withMaxMinRelativeMarginParameters(parameters.getMaxMinRelativeMarginParameters()) .withLoopFlowParameters(parameters.getLoopFlowParameters()) diff --git a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/searchtree/parameters/SearchTreeParameters.java b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/searchtree/parameters/SearchTreeParameters.java index 388d1cecad..9ace3a5695 100644 --- a/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/searchtree/parameters/SearchTreeParameters.java +++ b/ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/searchtree/parameters/SearchTreeParameters.java @@ -14,6 +14,7 @@ import com.powsybl.openrao.data.cracapi.rangeaction.PstRangeAction; import com.powsybl.openrao.data.cracapi.rangeaction.RangeAction; import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.LinearOptimizationSolver; import com.powsybl.openrao.raoapi.parameters.RaoParameters; import com.powsybl.openrao.raoapi.parameters.extensions.LoopFlowParametersExtension; import com.powsybl.openrao.raoapi.parameters.extensions.MnecParametersExtension; @@ -28,6 +29,9 @@ import java.util.Map; import java.util.Set; +import static com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.getLinearOptimizationSolver; +import static com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.getMaxMipIterations; + /** * @author Baptiste Seguinot {@literal } */ @@ -43,11 +47,13 @@ public class SearchTreeParameters { // required for sub-module iterating linear optimizer private final RangeActionsOptimizationParameters rangeActionParameters; + private final com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters rangeActionParametersExtension; + private final MnecParametersExtension mnecParameters; private final RelativeMarginsParametersExtension maxMinRelativeMarginParameters; private final LoopFlowParametersExtension loopFlowParameters; private final UnoptimizedCnecParameters unoptimizedCnecParameters; - private final RangeActionsOptimizationParameters.LinearOptimizationSolver solverParameters; + private final LinearOptimizationSolver solverParameters; private final int maxNumberOfIterations; public SearchTreeParameters(Unit objectiveFunctionUnit, @@ -56,11 +62,12 @@ public SearchTreeParameters(Unit objectiveFunctionUnit, NetworkActionParameters networkActionParameters, Map raLimitationParameters, RangeActionsOptimizationParameters rangeActionParameters, + com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters rangeActionParametersExtension, MnecParametersExtension mnecParameters, RelativeMarginsParametersExtension maxMinRelativeMarginParameters, LoopFlowParametersExtension loopFlowParameters, UnoptimizedCnecParameters unoptimizedCnecParameters, - RangeActionsOptimizationParameters.LinearOptimizationSolver solverParameters, + LinearOptimizationSolver solverParameters, int maxNumberOfIterations) { this.objectiveFunctionUnit = objectiveFunctionUnit; this.relativePositiveMargins = relativePositiveMargins; @@ -68,6 +75,7 @@ public SearchTreeParameters(Unit objectiveFunctionUnit, this.networkActionParameters = networkActionParameters; this.raLimitationParameters = raLimitationParameters; this.rangeActionParameters = rangeActionParameters; + this.rangeActionParametersExtension = rangeActionParametersExtension; this.mnecParameters = mnecParameters; this.maxMinRelativeMarginParameters = maxMinRelativeMarginParameters; this.loopFlowParameters = loopFlowParameters; @@ -100,6 +108,10 @@ public RangeActionsOptimizationParameters getRangeActionParameters() { return rangeActionParameters; } + public com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters getRangeActionParametersExtension() { + return rangeActionParametersExtension; + } + public MnecParametersExtension getMnecParameters() { return mnecParameters; } @@ -116,7 +128,7 @@ public UnoptimizedCnecParameters getUnoptimizedCnecParameters() { return unoptimizedCnecParameters; } - public RangeActionsOptimizationParameters.LinearOptimizationSolver getSolverParameters() { + public LinearOptimizationSolver getSolverParameters() { return solverParameters; } @@ -249,11 +261,12 @@ public static class SearchTreeParametersBuilder { private NetworkActionParameters networkActionParameters; private Map raLimitationParameters; private RangeActionsOptimizationParameters rangeActionParameters; + private com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters rangeActionParametersExtension; private MnecParametersExtension mnecParameters; private RelativeMarginsParametersExtension maxMinRelativeMarginParameters; private LoopFlowParametersExtension loopFlowParameters; private UnoptimizedCnecParameters unoptimizedCnecParameters; - private RangeActionsOptimizationParameters.LinearOptimizationSolver solverParameters; + private LinearOptimizationSolver solverParameters; private int maxNumberOfIterations; public SearchTreeParametersBuilder withConstantParametersOverAllRao(RaoParameters raoParameters, Crac crac) { @@ -261,12 +274,12 @@ public SearchTreeParametersBuilder withConstantParametersOverAllRao(RaoParameter this.relativePositiveMargins = raoParameters.getObjectiveFunctionParameters().getType().relativePositiveMargins(); this.networkActionParameters = NetworkActionParameters.buildFromRaoParameters(raoParameters.getTopoOptimizationParameters(), crac); this.raLimitationParameters = new HashMap<>(crac.getRaUsageLimitsPerInstant()); - this.rangeActionParameters = RangeActionsOptimizationParameters.buildFromRaoParameters(raoParameters); + this.rangeActionParameters = raoParameters.getRangeActionsOptimizationParameters(); this.mnecParameters = raoParameters.getExtension(MnecParametersExtension.class); this.maxMinRelativeMarginParameters = raoParameters.getExtension(RelativeMarginsParametersExtension.class); this.loopFlowParameters = raoParameters.getExtension(LoopFlowParametersExtension.class); - this.solverParameters = raoParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver(); - this.maxNumberOfIterations = raoParameters.getRangeActionsOptimizationParameters().getMaxMipIterations(); + this.solverParameters = getLinearOptimizationSolver(raoParameters); + this.maxNumberOfIterations = getMaxMipIterations(raoParameters); return this; } @@ -320,7 +333,7 @@ public SearchTreeParametersBuilder withUnoptimizedCnecParameters(UnoptimizedCnec return this; } - public SearchTreeParametersBuilder withSolverParameters(RangeActionsOptimizationParameters.LinearOptimizationSolver solverParameters) { + public SearchTreeParametersBuilder withSolverParameters(LinearOptimizationSolver solverParameters) { this.solverParameters = solverParameters; return this; } @@ -337,6 +350,7 @@ public SearchTreeParameters build() { networkActionParameters, raLimitationParameters, rangeActionParameters, + rangeActionParametersExtension, mnecParameters, maxMinRelativeMarginParameters, loopFlowParameters, diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/commons/RaoUtilTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/commons/RaoUtilTest.java index f1714d3cb9..38e04ba3d7 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/commons/RaoUtilTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/commons/RaoUtilTest.java @@ -24,7 +24,8 @@ import com.powsybl.openrao.data.cracimpl.utils.NetworkImportsUtil; import com.powsybl.openrao.raoapi.RaoInput; import com.powsybl.openrao.raoapi.parameters.ObjectiveFunctionParameters; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.OpenRaoSearchTreeParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters; import com.powsybl.openrao.raoapi.parameters.RaoParameters; import com.powsybl.openrao.raoapi.parameters.extensions.RelativeMarginsParametersExtension; import com.powsybl.openrao.searchtreerao.result.api.FlowResult; @@ -348,7 +349,8 @@ private void assertIsOnFlowInCountryAvailable(RemedialAction ra, State optimi @Test void testElementaryActionsLimitWithNonDiscretePsts() { - raoParameters.getRangeActionsOptimizationParameters().setPstModel(RangeActionsOptimizationParameters.PstModel.CONTINUOUS); + raoParameters.addExtension(OpenRaoSearchTreeParameters.class, new OpenRaoSearchTreeParameters()); + raoParameters.getExtension(OpenRaoSearchTreeParameters.class).getRangeActionsOptimizationParameters().setPstModel(RangeActionsOptimizationParameters.PstModel.CONTINUOUS); raoInput.getCrac().newRaUsageLimits(PREVENTIVE_INSTANT_ID).withMaxElementaryActionPerTso(Map.of("TSO", 2)).add(); OpenRaoException exception = assertThrows(OpenRaoException.class, () -> RaoUtil.checkParameters(raoParameters, raoInput)); assertEquals("The PSTs must be approximated as integers to use the limitations of elementary actions as a constraint in the RAO.", exception.getMessage()); diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/commons/parameters/TreeParametersTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/commons/parameters/TreeParametersTest.java index 253dfab76d..1661ec051f 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/commons/parameters/TreeParametersTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/commons/parameters/TreeParametersTest.java @@ -7,8 +7,9 @@ package com.powsybl.openrao.searchtreerao.commons.parameters; import com.powsybl.openrao.raoapi.parameters.ObjectiveFunctionParameters; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters; import com.powsybl.openrao.raoapi.parameters.RaoParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.OpenRaoSearchTreeParameters; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -20,17 +21,20 @@ */ class TreeParametersTest { RaoParameters raoParameters; + OpenRaoSearchTreeParameters searchTreeParameters; private static final double DOUBLE_TOLERANCE = 1e-6; @BeforeEach public void setUp() { raoParameters = new RaoParameters(); + raoParameters.addExtension(OpenRaoSearchTreeParameters.class, new OpenRaoSearchTreeParameters()); + searchTreeParameters = raoParameters.getExtension(OpenRaoSearchTreeParameters.class); raoParameters.getTopoOptimizationParameters().setMaxPreventiveSearchTreeDepth(6); raoParameters.getTopoOptimizationParameters().setMaxAutoSearchTreeDepth(2); raoParameters.getTopoOptimizationParameters().setMaxCurativeSearchTreeDepth(6); raoParameters.getMultithreadingParameters().setPreventiveLeavesInParallel(4); raoParameters.getMultithreadingParameters().setCurativeLeavesInParallel(2); - raoParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.DISABLED); + searchTreeParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.DISABLED); } @Test @@ -50,7 +54,7 @@ void testPreventive() { raoParameters.getTopoOptimizationParameters().setMaxPreventiveSearchTreeDepth(15); raoParameters.getTopoOptimizationParameters().setMaxAutoSearchTreeDepth(5); raoParameters.getTopoOptimizationParameters().setMaxCurativeSearchTreeDepth(15); - raoParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED_IN_FIRST_PRAO_AND_CRAO); + searchTreeParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED_IN_FIRST_PRAO_AND_CRAO); treeParameters = TreeParameters.buildForPreventivePerimeter(raoParameters); assertEquals(TreeParameters.StopCriterion.AT_TARGET_OBJECTIVE_VALUE, treeParameters.stopCriterion()); @@ -59,7 +63,7 @@ void testPreventive() { assertEquals(15, treeParameters.maximumSearchDepth()); assertTrue(treeParameters.raRangeShrinking()); - raoParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED); + searchTreeParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED); treeParameters = TreeParameters.buildForPreventivePerimeter(raoParameters); assertTrue(treeParameters.raRangeShrinking()); } @@ -68,7 +72,7 @@ void testPreventive() { void testCurativeSecureStopCriterion() { raoParameters.getObjectiveFunctionParameters().setType(ObjectiveFunctionParameters.ObjectiveFunctionType.SECURE_FLOW); raoParameters.getMultithreadingParameters().setCurativeLeavesInParallel(16); - raoParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED_IN_FIRST_PRAO_AND_CRAO); + searchTreeParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED_IN_FIRST_PRAO_AND_CRAO); TreeParameters treeParameters = TreeParameters.buildForCurativePerimeter(raoParameters, 100.0); assertEquals(TreeParameters.StopCriterion.AT_TARGET_OBJECTIVE_VALUE, treeParameters.stopCriterion()); @@ -86,7 +90,7 @@ void testCurativePreventiveObjectiveStopCriterion() { raoParameters.getTopoOptimizationParameters().setMaxPreventiveSearchTreeDepth(0); raoParameters.getTopoOptimizationParameters().setMaxAutoSearchTreeDepth(0); raoParameters.getTopoOptimizationParameters().setMaxCurativeSearchTreeDepth(0); - raoParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED); + searchTreeParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED); TreeParameters treeParameters = TreeParameters.buildForCurativePerimeter(raoParameters, 100.0); assertEquals(TreeParameters.StopCriterion.AT_TARGET_OBJECTIVE_VALUE, treeParameters.stopCriterion()); @@ -129,7 +133,7 @@ void testSecondPreventive() { // test with min objective raoParameters.getObjectiveFunctionParameters().setType(ObjectiveFunctionParameters.ObjectiveFunctionType.MAX_MIN_MARGIN); raoParameters.getObjectiveFunctionParameters().setEnforceCurativeSecurity(false); - raoParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.DISABLED); + searchTreeParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.DISABLED); TreeParameters treeParameters = TreeParameters.buildForSecondPreventivePerimeter(raoParameters); assertEquals(TreeParameters.StopCriterion.MIN_OBJECTIVE, treeParameters.stopCriterion()); @@ -140,7 +144,7 @@ void testSecondPreventive() { // test with secure raoParameters.getObjectiveFunctionParameters().setType(ObjectiveFunctionParameters.ObjectiveFunctionType.SECURE_FLOW); raoParameters.getObjectiveFunctionParameters().setEnforceCurativeSecurity(false); - raoParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED_IN_FIRST_PRAO_AND_CRAO); + searchTreeParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED_IN_FIRST_PRAO_AND_CRAO); treeParameters = TreeParameters.buildForSecondPreventivePerimeter(raoParameters); assertEquals(TreeParameters.StopCriterion.AT_TARGET_OBJECTIVE_VALUE, treeParameters.stopCriterion()); @@ -152,7 +156,7 @@ void testSecondPreventive() { // other combinations raoParameters.getObjectiveFunctionParameters().setType(ObjectiveFunctionParameters.ObjectiveFunctionType.SECURE_FLOW); raoParameters.getObjectiveFunctionParameters().setEnforceCurativeSecurity(false); - raoParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED); + searchTreeParameters.getRangeActionsOptimizationParameters().setRaRangeShrinking(RangeActionsOptimizationParameters.RaRangeShrinking.ENABLED); treeParameters = TreeParameters.buildForSecondPreventivePerimeter(raoParameters); assertEquals(TreeParameters.StopCriterion.AT_TARGET_OBJECTIVE_VALUE, treeParameters.stopCriterion()); diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/IteratingLinearOptimizerTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/IteratingLinearOptimizerTest.java index a072970504..405ce22f15 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/IteratingLinearOptimizerTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/IteratingLinearOptimizerTest.java @@ -12,7 +12,7 @@ import com.powsybl.openrao.data.cracapi.rangeaction.RangeAction; import com.powsybl.openrao.data.cracimpl.utils.NetworkImportsUtil; import com.powsybl.openrao.data.raoresultapi.ComputationStatus; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters; import com.powsybl.openrao.searchtreerao.commons.SensitivityComputer; import com.powsybl.openrao.searchtreerao.commons.adapter.BranchResultAdapter; import com.powsybl.openrao.searchtreerao.commons.adapter.SensitivityResultAdapter; @@ -101,7 +101,6 @@ public void setUp() { when(parameters.getMaxNumberOfIterations()).thenReturn(5); RangeActionsOptimizationParameters rangeActionParameters = Mockito.mock(RangeActionsOptimizationParameters.class); when(rangeActionParameters.getPstModel()).thenReturn(RangeActionsOptimizationParameters.PstModel.CONTINUOUS); - when(parameters.getRangeActionParameters()).thenReturn(rangeActionParameters); when(parameters.getObjectiveFunctionUnit()).thenReturn(Unit.MEGAWATT); when(parameters.relativePositiveMargins()).thenReturn(false); when(parameters.getRaRangeShrinking()).thenReturn(false); diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/LinearProblemBuilderTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/LinearProblemBuilderTest.java index e9add73f88..d76ad89101 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/LinearProblemBuilderTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/LinearProblemBuilderTest.java @@ -9,7 +9,7 @@ import com.powsybl.openrao.commons.Unit; import com.powsybl.openrao.data.cracapi.State; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters; import com.powsybl.openrao.raoapi.parameters.extensions.LoopFlowParametersExtension; import com.powsybl.openrao.raoapi.parameters.extensions.MnecParametersExtension; import com.powsybl.openrao.raoapi.parameters.extensions.RelativeMarginsParametersExtension; @@ -40,7 +40,8 @@ class LinearProblemBuilderTest { private IteratingLinearOptimizerInput inputs; private IteratingLinearOptimizerParameters parameters; private RangeActionsOptimizationParameters.LinearOptimizationSolver solverParameters; - private RangeActionsOptimizationParameters rangeActionParameters; + private com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters rangeActionParameters; + private RangeActionsOptimizationParameters rangeActionParametersExtension; private OptimizationPerimeter optimizationPerimeter; @BeforeEach @@ -52,8 +53,10 @@ public void setup() { solverParameters = Mockito.mock(RangeActionsOptimizationParameters.LinearOptimizationSolver.class); when(solverParameters.getSolver()).thenReturn(RangeActionsOptimizationParameters.Solver.SCIP); when(parameters.getSolverParameters()).thenReturn(solverParameters); - rangeActionParameters = Mockito.mock(RangeActionsOptimizationParameters.class); + rangeActionParameters = Mockito.mock(com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters.class); when(parameters.getRangeActionParameters()).thenReturn(rangeActionParameters); + rangeActionParametersExtension = Mockito.mock(RangeActionsOptimizationParameters.class); + when(parameters.getRangeActionParametersExtension()).thenReturn(rangeActionParametersExtension); RelativeMarginsParametersExtension relativeMarginParameters = Mockito.mock(RelativeMarginsParametersExtension.class); when(parameters.getMaxMinRelativeMarginParameters()).thenReturn(relativeMarginParameters); MnecParametersExtension mnecParameters = Mockito.mock(MnecParametersExtension.class); @@ -68,7 +71,7 @@ public void setup() { @Test void testBuildMaxMarginContinuous() { - when(rangeActionParameters.getPstModel()).thenReturn(RangeActionsOptimizationParameters.PstModel.CONTINUOUS); + when(rangeActionParametersExtension.getPstModel()).thenReturn(RangeActionsOptimizationParameters.PstModel.CONTINUOUS); when(parameters.getObjectiveFunctionUnit()).thenReturn(Unit.MEGAWATT); when(parameters.relativePositiveMargins()).thenReturn(false); @@ -83,7 +86,7 @@ void testBuildMaxMarginContinuous() { @Test void testBuildMaxMarginDiscrete() { - when(rangeActionParameters.getPstModel()).thenReturn(RangeActionsOptimizationParameters.PstModel.APPROXIMATED_INTEGERS); + when(rangeActionParametersExtension.getPstModel()).thenReturn(RangeActionsOptimizationParameters.PstModel.APPROXIMATED_INTEGERS); when(parameters.getObjectiveFunctionUnit()).thenReturn(Unit.MEGAWATT); when(parameters.relativePositiveMargins()).thenReturn(false); @@ -100,7 +103,7 @@ void testBuildMaxMarginDiscrete() { @Test void testBuildMaxRelativeMarginContinuous() { - when(rangeActionParameters.getPstModel()).thenReturn(RangeActionsOptimizationParameters.PstModel.CONTINUOUS); + when(rangeActionParametersExtension.getPstModel()).thenReturn(RangeActionsOptimizationParameters.PstModel.CONTINUOUS); when(parameters.getObjectiveFunctionUnit()).thenReturn(Unit.MEGAWATT); when(parameters.relativePositiveMargins()).thenReturn(true); @@ -115,7 +118,7 @@ void testBuildMaxRelativeMarginContinuous() { @Test void testBuildMaxMarginContinuousMnecLoopflowUnoptimized() { - when(rangeActionParameters.getPstModel()).thenReturn(RangeActionsOptimizationParameters.PstModel.CONTINUOUS); + when(rangeActionParametersExtension.getPstModel()).thenReturn(RangeActionsOptimizationParameters.PstModel.CONTINUOUS); when(parameters.getObjectiveFunctionUnit()).thenReturn(Unit.MEGAWATT); when(parameters.relativePositiveMargins()).thenReturn(false); when(parameters.isRaoWithMnecLimitation()).thenReturn(true); @@ -136,7 +139,7 @@ void testBuildMaxMarginContinuousMnecLoopflowUnoptimized() { @Test void testBuildMaxMarginContinuousRaLimitation() { - when(rangeActionParameters.getPstModel()).thenReturn(RangeActionsOptimizationParameters.PstModel.CONTINUOUS); + when(rangeActionParametersExtension.getPstModel()).thenReturn(RangeActionsOptimizationParameters.PstModel.CONTINUOUS); when(parameters.getObjectiveFunctionUnit()).thenReturn(Unit.MEGAWATT); when(parameters.relativePositiveMargins()).thenReturn(false); RangeActionLimitationParameters raLimitationParameters = Mockito.mock(RangeActionLimitationParameters.class); diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/LinearProblemTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/LinearProblemTest.java index defd84f237..40683f2e64 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/LinearProblemTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/LinearProblemTest.java @@ -12,7 +12,7 @@ import com.powsybl.openrao.data.cracapi.cnec.FlowCnec; import com.powsybl.iidm.network.TwoSides; import com.powsybl.openrao.data.cracapi.rangeaction.PstRangeAction; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters; import com.powsybl.openrao.searchtreerao.linearoptimisation.algorithms.linearproblem.LinearProblem; import com.powsybl.openrao.searchtreerao.linearoptimisation.algorithms.linearproblem.LinearProblemBuilder; import org.junit.jupiter.api.BeforeEach; diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/ContinuousRangeActionGroupFillerTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/ContinuousRangeActionGroupFillerTest.java index 5b34860366..e67cb046a7 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/ContinuousRangeActionGroupFillerTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/ContinuousRangeActionGroupFillerTest.java @@ -10,8 +10,8 @@ import com.powsybl.openrao.data.cracapi.State; import com.powsybl.openrao.data.cracapi.rangeaction.PstRangeAction; import com.powsybl.openrao.data.cracapi.rangeaction.RangeAction; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; import com.powsybl.openrao.raoapi.parameters.RaoParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters; import com.powsybl.openrao.searchtreerao.commons.optimizationperimeters.OptimizationPerimeter; import com.powsybl.openrao.searchtreerao.linearoptimisation.algorithms.linearproblem.OpenRaoMPConstraint; import com.powsybl.openrao.searchtreerao.linearoptimisation.algorithms.linearproblem.OpenRaoMPVariable; @@ -56,12 +56,11 @@ void testFillAndUpdateMethods() throws IOException { rangeActions.put(state, Set.of(pstRa1, pstRa2)); Mockito.when(optimizationPerimeter.getRangeActionsPerState()).thenReturn(rangeActions); - RangeActionsOptimizationParameters rangeActionParameters = RangeActionsOptimizationParameters.buildFromRaoParameters(new RaoParameters()); - CoreProblemFiller coreProblemFiller = new CoreProblemFiller( optimizationPerimeter, initialRangeActionSetpointResult, - rangeActionParameters, + (new RaoParameters()).getRangeActionsOptimizationParameters(), + null, Unit.MEGAWATT, false, RangeActionsOptimizationParameters.PstModel.CONTINUOUS); diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/CoreProblemFillerTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/CoreProblemFillerTest.java index 9c723cadab..c5f04fc54e 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/CoreProblemFillerTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/CoreProblemFillerTest.java @@ -13,8 +13,9 @@ import com.powsybl.iidm.network.TwoSides; import com.powsybl.openrao.data.cracapi.rangeaction.RangeAction; import com.powsybl.openrao.data.raoresultapi.ComputationStatus; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; import com.powsybl.openrao.raoapi.parameters.RaoParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.OpenRaoSearchTreeParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters; import com.powsybl.openrao.searchtreerao.commons.optimizationperimeters.OptimizationPerimeter; import com.powsybl.openrao.searchtreerao.linearoptimisation.algorithms.linearproblem.LinearProblem; import com.powsybl.openrao.searchtreerao.linearoptimisation.algorithms.linearproblem.LinearProblemBuilder; @@ -75,7 +76,7 @@ private void initializeForPreventive(double pstSensitivityThreshold, double hvdc initialize(Set.of(cnec1), pstSensitivityThreshold, hvdcSensitivityThreshold, injectionSensitivityThreshold, crac.getPreventiveState(), false, RangeActionsOptimizationParameters.PstModel.CONTINUOUS); } - private void initializeForGlobal(RangeActionsOptimizationParameters.PstModel pstModel) { + private void initializeForGlobal(com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.PstModel pstModel) { initialize(Set.of(cnec1, cnec2), 1e-6, 1e-6, 1e-6, crac.getPreventiveState(), false, pstModel); } @@ -89,15 +90,17 @@ private void initialize(Set cnecs, double pstSensitivityThreshold, dou Mockito.when(optimizationPerimeter.getRangeActionsPerState()).thenReturn(rangeActions); RaoParameters raoParameters = new RaoParameters(); - raoParameters.getRangeActionsOptimizationParameters().setPstSensitivityThreshold(pstSensitivityThreshold); - raoParameters.getRangeActionsOptimizationParameters().setHvdcSensitivityThreshold(hvdcSensitivityThreshold); - raoParameters.getRangeActionsOptimizationParameters().setInjectionRaSensitivityThreshold(injectionSensitivityThreshold); - RangeActionsOptimizationParameters rangeActionParameters = RangeActionsOptimizationParameters.buildFromRaoParameters(raoParameters); + raoParameters.addExtension(OpenRaoSearchTreeParameters.class, new OpenRaoSearchTreeParameters()); + OpenRaoSearchTreeParameters searchTreeParameters = raoParameters.getExtension(OpenRaoSearchTreeParameters.class); + searchTreeParameters.getRangeActionsOptimizationParameters().setPstSensitivityThreshold(pstSensitivityThreshold); + searchTreeParameters.getRangeActionsOptimizationParameters().setHvdcSensitivityThreshold(hvdcSensitivityThreshold); + searchTreeParameters.getRangeActionsOptimizationParameters().setInjectionRaSensitivityThreshold(injectionSensitivityThreshold); coreProblemFiller = new CoreProblemFiller( optimizationPerimeter, initialRangeActionSetpointResult, - rangeActionParameters, + raoParameters.getRangeActionsOptimizationParameters(), + searchTreeParameters.getRangeActionsOptimizationParameters(), Unit.MEGAWATT, raRangeShrinking, pstModel); buildLinearProblem(); } diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/DiscretePstGroupFillerTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/DiscretePstGroupFillerTest.java index 2733f8935e..5ff8c6fc9d 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/DiscretePstGroupFillerTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/DiscretePstGroupFillerTest.java @@ -10,7 +10,8 @@ import com.powsybl.openrao.data.cracapi.State; import com.powsybl.openrao.data.cracapi.rangeaction.PstRangeAction; import com.powsybl.openrao.data.cracapi.rangeaction.RangeAction; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.PstModel; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.Solver; import com.powsybl.openrao.raoapi.parameters.RaoParameters; import com.powsybl.openrao.searchtreerao.commons.optimizationperimeters.OptimizationPerimeter; import com.powsybl.openrao.searchtreerao.linearoptimisation.algorithms.linearproblem.OpenRaoMPConstraint; @@ -58,14 +59,13 @@ void testFillAndUpdateMethods() throws IOException { rangeActions.put(state, Set.of(pstRa1, pstRa2)); Mockito.when(optimizationPerimeter.getRangeActionsPerState()).thenReturn(rangeActions); - RangeActionsOptimizationParameters rangeActionParameters = RangeActionsOptimizationParameters.buildFromRaoParameters(new RaoParameters()); - CoreProblemFiller coreProblemFiller = new CoreProblemFiller( optimizationPerimeter, initialRangeActionSetpointResult, - rangeActionParameters, + (new RaoParameters()).getRangeActionsOptimizationParameters(), + null, Unit.MEGAWATT, - false, RangeActionsOptimizationParameters.PstModel.APPROXIMATED_INTEGERS); + false, PstModel.APPROXIMATED_INTEGERS); Map> pstRangeActions = new HashMap<>(); pstRangeActions.put(state, Set.of(pstRa1, pstRa2)); @@ -82,7 +82,7 @@ void testFillAndUpdateMethods() throws IOException { .withProblemFiller(coreProblemFiller) .withProblemFiller(discretePstTapFiller) .withProblemFiller(discretePstGroupFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .withInitialRangeActionActivationResult(getInitialRangeActionActivationResult()) .build(); diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/DiscretePstTapFillerTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/DiscretePstTapFillerTest.java index a04d59981f..b79f528314 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/DiscretePstTapFillerTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/DiscretePstTapFillerTest.java @@ -11,7 +11,8 @@ import com.powsybl.openrao.data.cracapi.range.RangeType; import com.powsybl.openrao.data.cracapi.rangeaction.PstRangeAction; import com.powsybl.openrao.data.cracapi.rangeaction.RangeAction; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.PstModel; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.Solver; import com.powsybl.openrao.raoapi.parameters.RaoParameters; import com.powsybl.openrao.searchtreerao.commons.optimizationperimeters.OptimizationPerimeter; import com.powsybl.openrao.searchtreerao.linearoptimisation.algorithms.linearproblem.LinearProblem; @@ -79,14 +80,13 @@ void setUpAndFill() throws IOException { Mockito.when(optimizationPerimeter.getRangeActionsPerState()).thenReturn(rangeActions); Mockito.when(optimizationPerimeter.getMainOptimizationState()).thenReturn(preventiveState); - RangeActionsOptimizationParameters rangeActionParameters = RangeActionsOptimizationParameters.buildFromRaoParameters(new RaoParameters()); - CoreProblemFiller coreProblemFiller = new CoreProblemFiller( optimizationPerimeter, initialRangeActionSetpointResult, - rangeActionParameters, + (new RaoParameters()).getRangeActionsOptimizationParameters(), + null, Unit.MEGAWATT, - false, RangeActionsOptimizationParameters.PstModel.APPROXIMATED_INTEGERS); + false, PstModel.APPROXIMATED_INTEGERS); Map> pstRangeActions = new HashMap<>(); pstRangeActions.put(preventiveState, Set.of(pstRangeAction)); @@ -99,7 +99,7 @@ void setUpAndFill() throws IOException { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(discretePstTapFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .withInitialRangeActionActivationResult(getInitialRangeActionActivationResult()) .build(); diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/MaxLoopFlowFillerTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/MaxLoopFlowFillerTest.java index ad08691588..e36ae3137f 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/MaxLoopFlowFillerTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/MaxLoopFlowFillerTest.java @@ -14,8 +14,8 @@ import com.powsybl.iidm.network.TwoSides; import com.powsybl.openrao.data.cracapi.rangeaction.RangeAction; import com.powsybl.openrao.data.cracloopflowextension.LoopFlowThresholdAdder; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; import com.powsybl.openrao.raoapi.parameters.RaoParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters; import com.powsybl.openrao.raoapi.parameters.extensions.LoopFlowParametersExtension; import com.powsybl.openrao.raoapi.parameters.extensions.PtdfApproximation; import com.powsybl.openrao.searchtreerao.commons.optimizationperimeters.OptimizationPerimeter; @@ -73,11 +73,11 @@ public void setUp() throws IOException { rangeActions.put(state, Set.of(pstRangeAction)); Mockito.when(optimizationPerimeter.getRangeActionsPerState()).thenReturn(rangeActions); - RangeActionsOptimizationParameters rangeActionParameters = RangeActionsOptimizationParameters.buildFromRaoParameters(new RaoParameters()); coreProblemFiller = new CoreProblemFiller( optimizationPerimeter, initialRangeActionSetpointResult, - rangeActionParameters, + (new RaoParameters()).getRangeActionsOptimizationParameters(), + null, Unit.MEGAWATT, false, RangeActionsOptimizationParameters.PstModel.CONTINUOUS ); diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/MaxMinMarginFillerTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/MaxMinMarginFillerTest.java index c4fb72342b..7425195c7b 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/MaxMinMarginFillerTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/MaxMinMarginFillerTest.java @@ -11,7 +11,6 @@ import com.powsybl.openrao.data.cracapi.State; import com.powsybl.iidm.network.TwoSides; import com.powsybl.openrao.data.cracapi.rangeaction.RangeAction; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; import com.powsybl.openrao.raoapi.parameters.RaoParameters; import com.powsybl.openrao.searchtreerao.commons.optimizationperimeters.OptimizationPerimeter; import com.powsybl.openrao.searchtreerao.linearoptimisation.algorithms.linearproblem.OpenRaoMPConstraint; @@ -56,17 +55,17 @@ public void setUp() throws IOException { Mockito.when(optimizationPerimeter.getRangeActionsPerState()).thenReturn(rangeActions); RaoParameters raoParameters = new RaoParameters(); - raoParameters.getRangeActionsOptimizationParameters().setPstPenaltyCost(0.01); - raoParameters.getRangeActionsOptimizationParameters().setHvdcPenaltyCost(0.01); - raoParameters.getRangeActionsOptimizationParameters().setInjectionRaPenaltyCost(0.01); - RangeActionsOptimizationParameters rangeActionParameters = RangeActionsOptimizationParameters.buildFromRaoParameters(raoParameters); + raoParameters.getRangeActionsOptimizationParameters().setPstRAMinImpactThreshold(0.01); + raoParameters.getRangeActionsOptimizationParameters().setHvdcRAMinImpactThreshold(0.01); + raoParameters.getRangeActionsOptimizationParameters().setInjectionRAMinImpactThreshold(0.01); coreProblemFiller = new CoreProblemFiller( optimizationPerimeter, initialRangeActionSetpointResult, - rangeActionParameters, + raoParameters.getRangeActionsOptimizationParameters(), + null, Unit.MEGAWATT, - false, RangeActionsOptimizationParameters.PstModel.CONTINUOUS); + false, com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.PstModel.CONTINUOUS); } private void createMaxMinMarginFiller(Unit unit) { @@ -77,7 +76,7 @@ private void buildLinearProblem() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(maxMinMarginFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.Solver.SCIP) .withInitialRangeActionActivationResult(getInitialRangeActionActivationResult()) .build(); linearProblem.fill(flowResult, sensitivityResult); @@ -167,7 +166,7 @@ void fillWithMissingFlowVariables() { createMaxMinMarginFiller(Unit.MEGAWATT); linearProblem = new LinearProblemBuilder() .withProblemFiller(maxMinMarginFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.Solver.SCIP) .build(); // AbsoluteRangeActionVariables present, but no the FlowVariables @@ -182,7 +181,7 @@ void fillWithMissingRangeActionVariables() { createMaxMinMarginFiller(Unit.MEGAWATT); linearProblem = new LinearProblemBuilder() .withProblemFiller(maxMinMarginFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.Solver.SCIP) .build(); // FlowVariables present , but not the absoluteRangeActionVariables present, diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/MaxMinRelativeMarginFillerTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/MaxMinRelativeMarginFillerTest.java index 08663f5905..6766938808 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/MaxMinRelativeMarginFillerTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/MaxMinRelativeMarginFillerTest.java @@ -12,7 +12,7 @@ import com.powsybl.iidm.network.TwoSides; import com.powsybl.openrao.data.cracapi.rangeaction.RangeAction; import com.powsybl.openrao.raoapi.parameters.ObjectiveFunctionParameters; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters; import com.powsybl.openrao.raoapi.parameters.RaoParameters; import com.powsybl.openrao.raoapi.parameters.extensions.PtdfApproximation; import com.powsybl.openrao.raoapi.parameters.extensions.RelativeMarginsParametersExtension; @@ -68,19 +68,19 @@ public void setUp() throws IOException { Mockito.when(optimizationPerimeter.getRangeActionsPerState()).thenReturn(rangeActions); RaoParameters raoParameters = new RaoParameters(); - raoParameters.getRangeActionsOptimizationParameters().setPstPenaltyCost(0.01); - raoParameters.getRangeActionsOptimizationParameters().setHvdcPenaltyCost(0.01); - raoParameters.getRangeActionsOptimizationParameters().setInjectionRaPenaltyCost(0.01); + raoParameters.getRangeActionsOptimizationParameters().setPstRAMinImpactThreshold(0.01); + raoParameters.getRangeActionsOptimizationParameters().setHvdcRAMinImpactThreshold(0.01); + raoParameters.getRangeActionsOptimizationParameters().setInjectionRAMinImpactThreshold(0.01); raoParameters.addExtension(RelativeMarginsParametersExtension.class, new RelativeMarginsParametersExtension()); raoParameters.getExtension(RelativeMarginsParametersExtension.class).setPtdfSumLowerBound(0.01); raoParameters.getObjectiveFunctionParameters().setType(ObjectiveFunctionParameters.ObjectiveFunctionType.MAX_MIN_RELATIVE_MARGIN); - RangeActionsOptimizationParameters rangeActionParameters = RangeActionsOptimizationParameters.buildFromRaoParameters(raoParameters); parameters = raoParameters.getExtension(RelativeMarginsParametersExtension.class); coreProblemFiller = new CoreProblemFiller( optimizationPerimeter, initialRangeActionSetpointResult, - rangeActionParameters, + raoParameters.getRangeActionsOptimizationParameters(), + null, MEGAWATT, false, RangeActionsOptimizationParameters.PstModel.CONTINUOUS); } @@ -100,7 +100,7 @@ private void buildLinearProblem() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(maxMinRelativeMarginFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.Solver.SCIP) .withInitialRangeActionActivationResult(getInitialRangeActionActivationResult()) .build(); linearProblem.fill(flowResult, sensitivityResult); diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/MnecFillerTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/MnecFillerTest.java index 65b723189d..2c2174167f 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/MnecFillerTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/MnecFillerTest.java @@ -16,7 +16,8 @@ import com.powsybl.iidm.network.TwoSides; import com.powsybl.openrao.data.cracapi.rangeaction.RangeAction; import com.powsybl.openrao.data.raoresultapi.ComputationStatus; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.PstModel; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.Solver; import com.powsybl.openrao.raoapi.parameters.RaoParameters; import com.powsybl.openrao.raoapi.parameters.extensions.MnecParametersExtension; import com.powsybl.openrao.searchtreerao.commons.optimizationperimeters.OptimizationPerimeter; @@ -99,17 +100,17 @@ public void setUp() throws IOException { when(optimizationPerimeter.getRangeActionsPerState()).thenReturn(rangeActions); RaoParameters raoParameters = new RaoParameters(); - raoParameters.getRangeActionsOptimizationParameters().setPstPenaltyCost(0.01); - raoParameters.getRangeActionsOptimizationParameters().setHvdcPenaltyCost(0.01); - raoParameters.getRangeActionsOptimizationParameters().setInjectionRaPenaltyCost(0.01); - RangeActionsOptimizationParameters rangeActionParameters = RangeActionsOptimizationParameters.buildFromRaoParameters(raoParameters); + raoParameters.getRangeActionsOptimizationParameters().setPstRAMinImpactThreshold(0.01); + raoParameters.getRangeActionsOptimizationParameters().setHvdcRAMinImpactThreshold(0.01); + raoParameters.getRangeActionsOptimizationParameters().setInjectionRAMinImpactThreshold(0.01); coreProblemFiller = new CoreProblemFiller( optimizationPerimeter, initialRangeActionSetpointResult, - rangeActionParameters, + raoParameters.getRangeActionsOptimizationParameters(), + null, Unit.MEGAWATT, - false, RangeActionsOptimizationParameters.PstModel.CONTINUOUS); + false, PstModel.CONTINUOUS); } private void fillProblemWithFiller(Unit unit) { @@ -130,7 +131,7 @@ private void fillProblemWithFiller(Unit unit) { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(mnecFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .build(); linearProblem.fill(flowResult, sensitivityResult); } @@ -231,7 +232,7 @@ void testFilterCnecWithNoInitialFlow() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(mnecFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .build(); linearProblem.fill(flowResult, sensitivityResult); diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/RaUsageLimitsFillerTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/RaUsageLimitsFillerTest.java index 755f5d8f95..8bf2cb0950 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/RaUsageLimitsFillerTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/RaUsageLimitsFillerTest.java @@ -14,8 +14,9 @@ import com.powsybl.openrao.data.cracapi.rangeaction.InjectionRangeAction; import com.powsybl.openrao.data.cracapi.rangeaction.PstRangeAction; import com.powsybl.openrao.data.cracapi.rangeaction.RangeAction; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; import com.powsybl.openrao.raoapi.parameters.RaoParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.PstModel; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.Solver; import com.powsybl.openrao.searchtreerao.commons.optimizationperimeters.OptimizationPerimeter; import com.powsybl.openrao.searchtreerao.commons.parameters.RangeActionLimitationParameters; import com.powsybl.openrao.searchtreerao.linearoptimisation.algorithms.linearproblem.*; @@ -105,14 +106,13 @@ public void setup() throws IOException { rangeActionsPerState.put(state, rangeActions); Mockito.when(optimizationPerimeter.getRangeActionsPerState()).thenReturn(rangeActionsPerState); - RangeActionsOptimizationParameters rangeActionParameters = RangeActionsOptimizationParameters.buildFromRaoParameters(new RaoParameters()); - coreProblemFiller = new CoreProblemFiller( optimizationPerimeter, prePerimeterRangeActionSetpointResult, - rangeActionParameters, + (new RaoParameters()).getRangeActionsOptimizationParameters(), + null, Unit.MEGAWATT, - false, RangeActionsOptimizationParameters.PstModel.CONTINUOUS); + false, PstModel.CONTINUOUS); } @Test @@ -127,7 +127,7 @@ void testSkipFiller() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(raUsageLimitsFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .build(); linearProblem.fill(flowResult, sensitivityResult); @@ -150,7 +150,7 @@ void testVariationVariableAndConstraints() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(raUsageLimitsFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .build(); linearProblem.fill(flowResult, sensitivityResult); @@ -183,7 +183,7 @@ void testVariationVariableAndConstraintsApproxPsts() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(raUsageLimitsFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .build(); linearProblem.fill(flowResult, sensitivityResult); @@ -216,7 +216,7 @@ void testSkipConstraints1() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(raUsageLimitsFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .build(); linearProblem.fill(flowResult, sensitivityResult); @@ -249,7 +249,7 @@ void testSkipConstraints2() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(raUsageLimitsFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .build(); linearProblem.fill(flowResult, sensitivityResult); @@ -271,7 +271,7 @@ void testMaxRa() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(raUsageLimitsFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .build(); linearProblem.fill(flowResult, sensitivityResult); @@ -298,7 +298,7 @@ void testSkipLargeMaxRa1() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(raUsageLimitsFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .build(); linearProblem.fill(flowResult, sensitivityResult); @@ -321,7 +321,7 @@ void testSkipLargeMaxRa2() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(raUsageLimitsFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .build(); linearProblem.fill(flowResult, sensitivityResult); @@ -351,7 +351,7 @@ void testMaxTso() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(raUsageLimitsFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .build(); linearProblem.fill(flowResult, sensitivityResult); @@ -384,7 +384,7 @@ void testSkipLargeMaxTso1() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(raUsageLimitsFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .build(); linearProblem.fill(flowResult, sensitivityResult); @@ -406,7 +406,7 @@ void testSkipLargeMaxTso2() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(raUsageLimitsFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .build(); linearProblem.fill(flowResult, sensitivityResult); @@ -428,7 +428,7 @@ void testMaxTsoWithExclusion() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(raUsageLimitsFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .build(); linearProblem.fill(flowResult, sensitivityResult); @@ -456,7 +456,7 @@ void testMaxRaPerTso() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(raUsageLimitsFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .build(); linearProblem.fill(flowResult, sensitivityResult); @@ -497,7 +497,7 @@ void testMaxPstPerTso() { linearProblem = new LinearProblemBuilder() .withProblemFiller(coreProblemFiller) .withProblemFiller(raUsageLimitsFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .build(); linearProblem.fill(flowResult, sensitivityResult); @@ -554,7 +554,7 @@ void testMaxElementaryActionsPerTsoConstraint() { .withProblemFiller(coreProblemFiller) .withProblemFiller(discretePstTapFiller) .withProblemFiller(raUsageLimitsFiller) - .withSolver(RangeActionsOptimizationParameters.Solver.SCIP) + .withSolver(Solver.SCIP) .withInitialRangeActionActivationResult(prePerimeterRangeActionActivationResult) .build(); diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/UnoptimizedCnecFillerMarginDecreaseRuleTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/UnoptimizedCnecFillerMarginDecreaseRuleTest.java index e13a1dc988..8cc30d4ae5 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/UnoptimizedCnecFillerMarginDecreaseRuleTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/fillers/UnoptimizedCnecFillerMarginDecreaseRuleTest.java @@ -13,7 +13,7 @@ import com.powsybl.openrao.data.cracapi.cnec.FlowCnec; import com.powsybl.iidm.network.TwoSides; import com.powsybl.openrao.data.cracapi.rangeaction.RangeAction; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters; import com.powsybl.openrao.raoapi.parameters.RaoParameters; import com.powsybl.openrao.raoapi.parameters.extensions.RelativeMarginsParametersExtension; import com.powsybl.openrao.searchtreerao.commons.optimizationperimeters.OptimizationPerimeter; @@ -77,15 +77,15 @@ public void setUp() throws IOException { Mockito.when(optimizationPerimeter.getRangeActionsPerState()).thenReturn(rangeActions); RaoParameters raoParameters = new RaoParameters(); - raoParameters.getRangeActionsOptimizationParameters().setPstPenaltyCost(0.01); - raoParameters.getRangeActionsOptimizationParameters().setHvdcPenaltyCost(0.01); - raoParameters.getRangeActionsOptimizationParameters().setInjectionRaPenaltyCost(0.01); - RangeActionsOptimizationParameters rangeActionParameters = RangeActionsOptimizationParameters.buildFromRaoParameters(raoParameters); + raoParameters.getRangeActionsOptimizationParameters().setPstRAMinImpactThreshold(0.01); + raoParameters.getRangeActionsOptimizationParameters().setHvdcRAMinImpactThreshold(0.01); + raoParameters.getRangeActionsOptimizationParameters().setInjectionRAMinImpactThreshold(0.01); coreProblemFiller = new CoreProblemFiller( optimizationPerimeter, initialRangeActionSetpointResult, - rangeActionParameters, + raoParameters.getRangeActionsOptimizationParameters(), + null, MEGAWATT, false, RangeActionsOptimizationParameters.PstModel.CONTINUOUS); } diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/linearproblem/OpenRaoMPSolverTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/linearproblem/OpenRaoMPSolverTest.java index b2dc02b827..631a3dec11 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/linearproblem/OpenRaoMPSolverTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/linearproblem/OpenRaoMPSolverTest.java @@ -10,7 +10,7 @@ import com.google.ortools.linearsolver.MPSolver; import com.google.ortools.linearsolver.MPVariable; import com.powsybl.openrao.commons.OpenRaoException; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters; import com.powsybl.openrao.searchtreerao.result.api.LinearProblemStatus; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; diff --git a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/searchtree/parameters/SearchTreeParametersTest.java b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/searchtree/parameters/SearchTreeParametersTest.java index 2ff6a241c1..b53367eed2 100644 --- a/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/searchtree/parameters/SearchTreeParametersTest.java +++ b/ra-optimisation/search-tree-rao/src/test/java/com/powsybl/openrao/searchtreerao/searchtree/parameters/SearchTreeParametersTest.java @@ -14,9 +14,11 @@ import com.powsybl.openrao.data.cracapi.rangeaction.RangeAction; import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; import com.powsybl.openrao.raoapi.parameters.RaoParameters; +import com.powsybl.openrao.raoapi.parameters.extensions.OpenRaoSearchTreeParameters; import com.powsybl.openrao.raoapi.parameters.extensions.LoopFlowParametersExtension; import com.powsybl.openrao.raoapi.parameters.extensions.MnecParametersExtension; import com.powsybl.openrao.raoapi.parameters.extensions.RelativeMarginsParametersExtension; +import com.powsybl.openrao.raoapi.parameters.extensions.RangeActionsOptimizationParameters.LinearOptimizationSolver; import com.powsybl.openrao.searchtreerao.commons.parameters.*; import com.powsybl.openrao.searchtreerao.result.api.OptimizationResult; import com.powsybl.openrao.searchtreerao.result.api.PrePerimeterResult; @@ -49,6 +51,8 @@ public void setup() { @Test void testWithConstantParametersOverAllRao() { RaoParameters raoParameters = new RaoParameters(); + raoParameters.addExtension(OpenRaoSearchTreeParameters.class, new OpenRaoSearchTreeParameters()); + OpenRaoSearchTreeParameters raoParametersExtension = raoParameters.getExtension(OpenRaoSearchTreeParameters.class); Crac crac = Mockito.mock(Crac.class); builder.withConstantParametersOverAllRao(raoParameters, crac); SearchTreeParameters searchTreeParameters = builder.build(); @@ -58,12 +62,12 @@ void testWithConstantParametersOverAllRao() { assertEquals(raoParameters.getObjectiveFunctionParameters().getType().relativePositiveMargins(), searchTreeParameters.relativePositiveMargins()); assertEquals(NetworkActionParameters.buildFromRaoParameters(raoParameters.getTopoOptimizationParameters(), crac), searchTreeParameters.getNetworkActionParameters()); assertEquals(crac.getRaUsageLimitsPerInstant(), searchTreeParameters.getRaLimitationParameters()); - assertEquals(RangeActionsOptimizationParameters.buildFromRaoParameters(raoParameters), searchTreeParameters.getRangeActionParameters()); + assertEquals(raoParameters.getRangeActionsOptimizationParameters(), searchTreeParameters.getRangeActionParameters()); assertEquals(raoParameters.getExtension(MnecParametersExtension.class), searchTreeParameters.getMnecParameters()); assertEquals(raoParameters.getExtension(RelativeMarginsParametersExtension.class), searchTreeParameters.getMaxMinRelativeMarginParameters()); assertEquals(raoParameters.getExtension(LoopFlowParametersExtension.class), searchTreeParameters.getLoopFlowParameters()); - assertEquals(raoParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver(), searchTreeParameters.getSolverParameters()); - assertEquals(raoParameters.getRangeActionsOptimizationParameters().getMaxMipIterations(), searchTreeParameters.getMaxNumberOfIterations()); + assertEquals(raoParametersExtension.getRangeActionsOptimizationParameters().getLinearOptimizationSolver(), searchTreeParameters.getSolverParameters()); + assertEquals(raoParametersExtension.getRangeActionsOptimizationParameters().getMaxMipIterations(), searchTreeParameters.getMaxNumberOfIterations()); } @Test @@ -78,7 +82,7 @@ void testIndividualSetters() { RelativeMarginsParametersExtension maxMinRelativeMarginParameters = Mockito.mock(RelativeMarginsParametersExtension.class); LoopFlowParametersExtension loopFlowParameters = Mockito.mock(LoopFlowParametersExtension.class); UnoptimizedCnecParameters unoptimizedCnecParameters = Mockito.mock(UnoptimizedCnecParameters.class); - RangeActionsOptimizationParameters.LinearOptimizationSolver solverParameters = Mockito.mock(RangeActionsOptimizationParameters.LinearOptimizationSolver.class); + LinearOptimizationSolver solverParameters = Mockito.mock(LinearOptimizationSolver.class); int maxNumberOfIterations = 3; SearchTreeParameters searchTreeParameters = builder diff --git a/tests/src/test/java/com/powsybl/openrao/tests/steps/CommonTestData.java b/tests/src/test/java/com/powsybl/openrao/tests/steps/CommonTestData.java index 9930792bb2..eb366e37bb 100644 --- a/tests/src/test/java/com/powsybl/openrao/tests/steps/CommonTestData.java +++ b/tests/src/test/java/com/powsybl/openrao/tests/steps/CommonTestData.java @@ -21,7 +21,6 @@ import com.powsybl.openrao.monitoring.anglemonitoring.AngleMonitoringResult; import com.powsybl.openrao.monitoring.anglemonitoring.RaoResultWithAngleMonitoring; import com.powsybl.openrao.raoapi.json.JsonRaoParameters; -import com.powsybl.openrao.raoapi.parameters.RangeActionsOptimizationParameters; import com.powsybl.openrao.raoapi.parameters.RaoParameters; import com.powsybl.openrao.tests.utils.CoreCcPreprocessor; import com.powsybl.openrao.tests.utils.Helpers; @@ -44,8 +43,6 @@ public final class CommonTestData { private static String dataPrefix = "src/test/resources/files/"; - private static String overrideLinearSolver = null; - private static String networkPath; private static Boolean coreCcNetworkPreprocessing = false; private static Network network; @@ -110,14 +107,6 @@ public static String getResourcesPath() { return dataPrefix; } - public static void setLinearSolver(String solver) { - overrideLinearSolver = solver; - } - - public static void resetLinearSolver() { - overrideLinearSolver = null; - } - @Before // Reset data to null before every scenario public static void reset() { @@ -298,9 +287,6 @@ public static void loadData(String timestamp) throws IOException { } else { raoParameters = buildDefaultConfig(); } - if (overrideLinearSolver != null) { - raoParameters.getRangeActionsOptimizationParameters().getLinearOptimizationSolver().setSolver(RangeActionsOptimizationParameters.Solver.valueOf(overrideLinearSolver.toUpperCase())); - } // GLSK // for now, only work with UCTE GLSK files, not CIME GLSK file