WIP - Prohibit ac/mw, loopflow computation in A and relative margin optimisation in A

ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/ObjectiveFunctionParameters.java

@@ -22,7 +22,7 @@
 public class ObjectiveFunctionParameters {
     // Default values
     private static final ObjectiveFunctionType DEFAULT_OBJECTIVE_FUNCTION = ObjectiveFunctionType.SECURE_FLOW;
-    private static final Unit DEFAULT_UNIT = Unit.MEGAWATT;
+    private static final Unit DEFAULT_UNIT = Unit.AMPERE;
     private static final boolean DEFAULT_ENFORCE_CURATIVE_SECURITY = false;
     // Attributes
     private ObjectiveFunctionType type = DEFAULT_OBJECTIVE_FUNCTION;

ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/RaoParameters.java

@@ -14,10 +14,7 @@
 import com.powsybl.commons.extensions.Extension;
 import com.powsybl.commons.extensions.ExtensionConfigLoader;
 import com.powsybl.commons.extensions.ExtensionProviders;
-import com.powsybl.openrao.raoapi.parameters.extensions.OpenRaoSearchTreeParameters;
-import com.powsybl.openrao.raoapi.parameters.extensions.SearchTreeRaoLoopFlowParameters;
-import com.powsybl.openrao.raoapi.parameters.extensions.SearchTreeRaoMnecParameters;
-import com.powsybl.openrao.raoapi.parameters.extensions.SearchTreeRaoRelativeMarginsParameters;
+import com.powsybl.openrao.raoapi.parameters.extensions.*;
 
 import java.util.Objects;
 import java.util.Optional;

ra-optimisation/rao-api/src/main/java/com/powsybl/openrao/raoapi/parameters/extensions/LoadFlowAndSensitivityParameters.java

@@ -9,6 +9,7 @@
 
 import com.powsybl.commons.config.PlatformConfig;
 import com.powsybl.loadflow.LoadFlowParameters;
+import com.powsybl.openrao.commons.Unit;
 import com.powsybl.openrao.raoapi.parameters.RaoParameters;
 import com.powsybl.sensitivity.SensitivityAnalysisParameters;
 
@@ -111,6 +112,15 @@ public static SensitivityAnalysisParameters getSensitivityWithLoadFlowParameters
         return cleanLoadFlowParameters(new SensitivityAnalysisParameters());
     }
 
+    // In AC, the objective function is in Ampere and in DC in MW
+    public static Unit getObjectiveFunctionUnit(RaoParameters raoParameters) {
+        if (getSensitivityWithLoadFlowParameters(raoParameters).getLoadFlowParameters().isDc()) {
+            return Unit.MEGAWATT;
+        } else {
+            return Unit.AMPERE;
+        }
+    }
+
     private static SensitivityAnalysisParameters cleanLoadFlowParameters(SensitivityAnalysisParameters sensitivityAnalysisParameters) {
         LoadFlowParameters loadFlowParameters = sensitivityAnalysisParameters.getLoadFlowParameters();
         // we have to clean load flow parameters.

ra-optimisation/rao-api/src/test/java/com/powsybl/openrao/raoapi/parameters/RaoParametersYamlConfigTest.java

@@ -161,7 +161,7 @@ void testConfigWithPartialExtensions() throws IOException {
 
         ObjectiveFunctionParameters objectiveFunctionParameters = parameters.getObjectiveFunctionParameters();
         assertEquals(ObjectiveFunctionParameters.ObjectiveFunctionType.MAX_MIN_MARGIN, objectiveFunctionParameters.getType());
-        assertEquals(Unit.MEGAWATT, objectiveFunctionParameters.getUnit());
+        assertEquals(Unit.AMPERE, objectiveFunctionParameters.getUnit());
         assertEquals(3, searchTreeParameters.getObjectiveFunctionParameters().getCurativeMinObjImprovement(), DOUBLE_TOLERANCE);
         assertFalse(objectiveFunctionParameters.getEnforceCurativeSecurity());
 

ra-optimisation/rao-api/src/test/resources/RaoParametersWithExtension_v2.json

@@ -2,7 +2,7 @@
   "version" : "3.2.1",
   "objective-function" : {
     "type" : "SECURE_FLOW",
-    "unit" : "MW",
+    "unit" : "A",
     "enforce-curative-security" : false
   },
   "range-actions-optimization" : {

ra-optimisation/rao-api/src/test/resources/RaoParameters_config_withOLFParams.json

@@ -2,7 +2,7 @@
   "version" : "3.2.1",
   "objective-function" : {
     "type" : "SECURE_FLOW",
-    "unit" : "MW",
+    "unit" : "A",
     "enforce-curative-security" : false
   },
   "range-actions-optimization" : {

ra-optimisation/rao-api/src/test/resources/RaoParameters_config_withPartialExtensions.json

@@ -2,7 +2,7 @@
   "version" : "3.2.1",
   "objective-function" : {
     "type" : "MAX_MIN_MARGIN",
-    "unit" : "MW",
+    "unit" : "A",
     "enforce-curative-security" : false
   },
   "range-actions-optimization" : {

ra-optimisation/rao-api/src/test/resources/RaoParameters_v2.json

@@ -2,7 +2,7 @@
   "version" : "3.2.1",
   "objective-function" : {
     "type" : "SECURE_FLOW",
-    "unit" : "MW",
+    "unit" : "A",
     "enforce-curative-security" : false
   },
   "range-actions-optimization" : {

ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/castor/algorithm/AutomatonSimulator.java

@@ -53,7 +53,6 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 
-import static com.powsybl.openrao.commons.Unit.MEGAWATT;
 import static com.powsybl.openrao.commons.logs.OpenRaoLoggerProvider.BUSINESS_LOGS;
 import static com.powsybl.openrao.commons.logs.OpenRaoLoggerProvider.BUSINESS_WARNS;
 import static com.powsybl.openrao.commons.logs.OpenRaoLoggerProvider.TECHNICAL_LOGS;
@@ -582,11 +581,10 @@ RangeAutomatonSimulationResult shiftRangeActionsUntilFlowCnecsSecure(List<RangeA
             }
 
             // Aligned range actions have the same set-point :
-            double currentSetpoint = alignedRangeActions.getFirst().getCurrentSetpoint(network);
-            double conversionToMegawatt = RaoUtil.getFlowUnitMultiplier(toBeShiftedCnec, side, flowUnit, MEGAWATT);
-            double cnecFlow = conversionToMegawatt * automatonRangeActionOptimizationSensitivityAnalysisOutput.getFlow(toBeShiftedCnec, side, flowUnit);
-            double cnecMargin = conversionToMegawatt * automatonRangeActionOptimizationSensitivityAnalysisOutput.getMargin(toBeShiftedCnec, side, flowUnit);
-            double optimalSetpoint = computeOptimalSetpoint(currentSetpoint, cnecFlow, cnecMargin, sensitivityValue, alignedRangeActions.getFirst(), minSetpoint, maxSetpoint);
+            double currentSetpoint = alignedRangeActions.get(0).getCurrentSetpoint(network);
+            double cnecFlow = automatonRangeActionOptimizationSensitivityAnalysisOutput.getFlow(toBeShiftedCnec, side, flowUnit);
+            double cnecMargin = automatonRangeActionOptimizationSensitivityAnalysisOutput.getMargin(toBeShiftedCnec, side, flowUnit);
+            double optimalSetpoint = computeOptimalSetpoint(currentSetpoint, cnecFlow, cnecMargin, sensitivityValue, alignedRangeActions.get(0), minSetpoint, maxSetpoint);
 
             // On first iteration, define direction
             if (iteration == 0) {
@@ -632,7 +630,7 @@ private double computeTotalSensitivityValue(List<RangeAction<?>> alignedRangeAct
         // Under-estimate range action sensitivity if convergence to margin = 0 is slow (ie if multiple passes
         // through this loop have been needed to secure the same CNEC)
         for (RangeAction<?> rangeAction : alignedRangeActions) {
-            sensitivityValue += sensitivityUnderestimator * automatonRangeActionOptimizationSensitivityAnalysisOutput.getSensitivityValue(toBeShiftedCnec, side, rangeAction, MEGAWATT);
+            sensitivityValue += sensitivityUnderestimator * automatonRangeActionOptimizationSensitivityAnalysisOutput.getSensitivityValue(toBeShiftedCnec, side, rangeAction, flowUnit);
         }
         return sensitivityValue;
     }

ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/commons/RaoUtil.java

@@ -36,8 +36,8 @@
 import java.util.*;
 import java.util.stream.Collectors;
 
-import static com.powsybl.openrao.raoapi.parameters.extensions.LoadFlowAndSensitivityParameters.getLoadFlowProvider;
-import static com.powsybl.openrao.raoapi.parameters.extensions.LoadFlowAndSensitivityParameters.getSensitivityWithLoadFlowParameters;
+import static com.powsybl.openrao.commons.logs.OpenRaoLoggerProvider.BUSINESS_LOGS;
+import static com.powsybl.openrao.raoapi.parameters.extensions.LoadFlowAndSensitivityParameters.*;
 import static com.powsybl.openrao.raoapi.parameters.extensions.SearchTreeRaoRangeActionsOptimizationParameters.getPstModel;
 import static com.powsybl.openrao.searchtreerao.commons.HvdcUtils.addNetworkActionAssociatedWithHvdcRangeAction;
 import static com.powsybl.openrao.searchtreerao.commons.HvdcUtils.updateHvdcRangeActionInitialSetpoint;
@@ -73,6 +73,21 @@ public static void checkParameters(RaoParameters raoParameters, RaoInput raoInpu
             throw new OpenRaoException(msg);
         }
     }
+        if (raoParameters.getObjectiveFunctionParameters().getUnit().equals(Unit.MEGAWATT)
+            && !getSensitivityWithLoadFlowParameters(raoParameters).getLoadFlowParameters().isDc()) {
+            String msg = "Objective function unit MEGAWATT cannot be calculated with a AC default sensitivity engine";
+            BUSINESS_LOGS.error(msg);
+            throw new OpenRaoException(msg);
+        }
+
+        if (raoParameters.getObjectiveFunctionParameters().getType().relativePositiveMargins()) {
+            if (raoInput.getGlskProvider() == null) {
+                throw new OpenRaoException(format("Objective function %s requires glsks", raoParameters.getObjectiveFunctionParameters().getType()));
+            }
+            if (raoParameters.getRelativeMarginsParameters().map(relativeMarginsParameters -> relativeMarginsParameters.getPtdfBoundaries().isEmpty()).orElse(true)) {
+                throw new OpenRaoException(format("Objective function %s requires a config with a non empty boundary set", raoParameters.getObjectiveFunctionParameters().getType()));
+            }
+        }
 
     private static void checkLoopFlowParameters(RaoParameters raoParameters, RaoInput raoInput) {
         if ((raoParameters.getLoopFlowParameters().isPresent()
@@ -111,6 +126,20 @@ && getSensitivityWithLoadFlowParameters(raoParameters).getLoadFlowParameters().i
                 raoParameters.hasExtension(OpenRaoSearchTreeParameters.class) && raoParameters.getExtension(OpenRaoSearchTreeParameters.class).getMinMarginsParameters().isEmpty())) {
             throw new OpenRaoException(format("Objective function type %s requires a config with costly min margin parameters", raoParameters.getObjectiveFunctionParameters().getType()));
         }
+
+        if (raoParameters.getObjectiveFunctionParameters().getType().relativePositiveMargins()
+            && getObjectiveFunctionUnit(raoParameters).equals(Unit.AMPERE)) {
+            String msg = "The objective function unit must be MEGAWATT to use relative positive margins";
+            OpenRaoLoggerProvider.BUSINESS_LOGS.error(msg);
+            throw new OpenRaoException(msg);
+        }
+
+        if (raoParameters.getLoopFlowParameters().isPresent()
+            && getObjectiveFunctionUnit(raoParameters).equals(Unit.AMPERE)) {
+            String msg = "The objective function unit must be MEGAWATT to use loopflow computation";
+            OpenRaoLoggerProvider.BUSINESS_LOGS.error(msg);
+            throw new OpenRaoException(msg);
+        }
     }
 
     public static void checkCnecsThresholdsUnit(RaoParameters raoParameters, RaoInput raoInput) {

ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/commons/ToolProvider.java

@@ -32,8 +32,7 @@
 import java.util.*;
 import java.util.stream.Collectors;
 
-import static com.powsybl.openrao.raoapi.parameters.extensions.LoadFlowAndSensitivityParameters.getSensitivityProvider;
-import static com.powsybl.openrao.raoapi.parameters.extensions.LoadFlowAndSensitivityParameters.getSensitivityWithLoadFlowParameters;
+import static com.powsybl.openrao.raoapi.parameters.extensions.LoadFlowAndSensitivityParameters.*;
 
 /**
  * @author Joris Mancini {@literal <joris.mancini at rte-france.com>}
@@ -92,27 +91,30 @@ public SystematicSensitivityInterface getSystematicSensitivityInterface(Set<Flow
                                                                             boolean computeLoopFlows,
                                                                             AppliedRemedialActions appliedRemedialActions,
                                                                             Instant outageInstant) {
+        Unit objectiveFunctionUnit = getObjectiveFunctionUnit(raoParameters);
 
         SystematicSensitivityInterface.SystematicSensitivityInterfaceBuilder builder = SystematicSensitivityInterface.builder()
             .withSensitivityProviderName(getSensitivityProvider(raoParameters))
             .withParameters(getSensitivityWithLoadFlowParameters(raoParameters))
-            .withRangeActionSensitivities(rangeActions, cnecs, Collections.singleton(Unit.MEGAWATT))
             .withAppliedRemedialActions(appliedRemedialActions)
+            .withRangeActionSensitivities(rangeActions, cnecs, Collections.singleton(objectiveFunctionUnit))
             .withOutageInstant(outageInstant);
 
-        if (!getSensitivityWithLoadFlowParameters(raoParameters).getLoadFlowParameters().isDc()) {
-            builder.withLoadflow(cnecs, Collections.singleton(Unit.AMPERE));
+        if (getSensitivityWithLoadFlowParameters(raoParameters).getLoadFlowParameters().isDc()) {
+            builder.withLoadflow(cnecs, Collections.singleton(objectiveFunctionUnit));
+        } else {
+            builder.withLoadflow(cnecs, Set.of(Unit.AMPERE, Unit.MEGAWATT));
         }
 
         if (computePtdfs && computeLoopFlows) {
             Set<String> eic = getEicForObjectiveFunction();
             eic.addAll(getEicForLoopFlows());
-            builder.withPtdfSensitivities(getGlskForEic(eic), cnecs, Collections.singleton(Unit.MEGAWATT));
+            builder.withPtdfSensitivities(getGlskForEic(eic), cnecs, Collections.singleton(objectiveFunctionUnit));
         } else if (computeLoopFlows) {
             Set<FlowCnec> loopflowCnecs = getLoopFlowCnecs(cnecs);
-            builder.withPtdfSensitivities(getGlskForEic(getEicForLoopFlows()), loopflowCnecs, Collections.singleton(Unit.MEGAWATT));
+            builder.withPtdfSensitivities(getGlskForEic(getEicForLoopFlows()), loopflowCnecs, Collections.singleton(objectiveFunctionUnit));
         } else if (computePtdfs) {
-            builder.withPtdfSensitivities(getGlskForEic(getEicForObjectiveFunction()), cnecs, Collections.singleton(Unit.MEGAWATT));
+            builder.withPtdfSensitivities(getGlskForEic(getEicForObjectiveFunction()), cnecs, Collections.singleton(objectiveFunctionUnit));
         }
 
         return builder.build();

ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/commons/objectivefunction/ObjectiveFunctionCreator.java

@@ -81,7 +81,8 @@ protected List<CostEvaluator> getVirtualCostEvaluators(MarginEvaluator marginEva
                     loopFlowCnecs,
                     initialFlowResult,
                     loopFlowParametersOptional.get().getAcceptableIncrease(),
-                    loopFlowParametersExtensionOptional.get().getViolationCost()
+                    loopFlowParametersExtensionOptional.get().getViolationCost(),
+                    raoParameters.getObjectiveFunctionParameters().getUnit()
                 ));
             }
         }

ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/commons/objectivefunctionevaluator/LoopFlowViolationCostEvaluator.java

@@ -32,14 +32,18 @@ public class LoopFlowViolationCostEvaluator implements CostEvaluator {
     private final FlowResult initialLoopFlowResult;
     private final double loopFlowViolationCost;
     private final double loopFlowAcceptableAugmentation;
+    private final Unit unit;
 
     public LoopFlowViolationCostEvaluator(Set<FlowCnec> loopflowCnecs,
                                           FlowResult initialLoopFlowResult,
-                                          double loopFlowAcceptableAugmentation, double loopFlowViolationCost) {
+                                          double loopFlowAcceptableAugmentation,
+                                          double loopFlowViolationCost,
+                                          Unit unit) {
         this.loopflowCnecs = loopflowCnecs;
         this.initialLoopFlowResult = initialLoopFlowResult;
         this.loopFlowViolationCost = loopFlowViolationCost;
         this.loopFlowAcceptableAugmentation = loopFlowAcceptableAugmentation;
+        this.unit = unit;
     }
 
     @Override
@@ -67,13 +71,13 @@ public CostEvaluatorResult evaluate(FlowResult flowResult, RemedialActionActivat
 
     double getLoopFlowExcess(FlowResult flowResult, FlowCnec cnec) {
         return cnec.getMonitoredSides()
-            .stream().map(side -> Math.max(0, Math.abs(flowResult.getLoopFlow(cnec, side, Unit.MEGAWATT)) - getLoopFlowUpperBound(cnec, side)))
+            .stream().map(side -> Math.max(0, Math.abs(flowResult.getLoopFlow(cnec, side, unit)) - getLoopFlowUpperBound(cnec, side)))
             .max(Double::compareTo).orElse(0.0);
     }
 
     private double getLoopFlowUpperBound(FlowCnec cnec, TwoSides side) {
-        double loopFlowThreshold = cnec.getExtension(LoopFlowThreshold.class).getThresholdWithReliabilityMargin(Unit.MEGAWATT);
-        double initialLoopFlow = initialLoopFlowResult.getLoopFlow(cnec, side, Unit.MEGAWATT);
+        double loopFlowThreshold = cnec.getExtension(LoopFlowThreshold.class).getThresholdWithReliabilityMargin(unit);
+        double initialLoopFlow = initialLoopFlowResult.getLoopFlow(cnec, side, unit);
         return Math.max(0.0, Math.max(loopFlowThreshold, Math.abs(initialLoopFlow) + loopFlowAcceptableAugmentation));
     }
 }

ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/BestTapFinder.java

@@ -14,7 +14,6 @@
 import com.powsybl.openrao.data.crac.api.rangeaction.PstRangeAction;
 import com.powsybl.openrao.data.crac.api.rangeaction.RangeAction;
 import com.powsybl.iidm.network.TwoSides;
-import com.powsybl.openrao.searchtreerao.commons.RaoUtil;
 import com.powsybl.openrao.searchtreerao.commons.optimizationperimeters.OptimizationPerimeter;
 import com.powsybl.openrao.searchtreerao.result.api.*;
 import com.powsybl.openrao.searchtreerao.result.impl.RangeActionActivationResultImpl;
@@ -26,8 +25,6 @@
 import java.util.*;
 import java.util.stream.Collectors;
 
-import static com.powsybl.openrao.commons.Unit.MEGAWATT;
-
 /**
  * @author Joris Mancini {@literal <joris.mancini at rte-france.com>}
  */
@@ -231,15 +228,15 @@ static Pair<Double, Double> computeMinMargins(Network network,
         double minMargin2 = Double.MAX_VALUE;
         for (FlowCnec flowCnec : linearOptimizationResult.getMostLimitingElements(10)) {
             for (TwoSides side : flowCnec.getMonitoredSides()) {
-                double sensitivity = linearOptimizationResult.getSensitivityValue(flowCnec, side, pstRangeAction, MEGAWATT);
+                double sensitivity = linearOptimizationResult.getSensitivityValue(flowCnec, side, pstRangeAction, unit);
                 double currentSetPoint = pstRangeAction.getCurrentSetpoint(network);
-                double referenceFlow = linearOptimizationResult.getFlow(flowCnec, side, unit) * RaoUtil.getFlowUnitMultiplier(flowCnec, side, unit, MEGAWATT);
+                double referenceFlow = linearOptimizationResult.getFlow(flowCnec, side, unit);
 
                 double flow1 = sensitivity * (angle1 - currentSetPoint) + referenceFlow;
                 double flow2 = sensitivity * (angle2 - currentSetPoint) + referenceFlow;
 
-                minMargin1 = Math.min(minMargin1, flowCnec.computeMargin(flow1, side, MEGAWATT));
-                minMargin2 = Math.min(minMargin2, flowCnec.computeMargin(flow2, side, MEGAWATT));
+                minMargin1 = Math.min(minMargin1, flowCnec.computeMargin(flow1, side, unit));
+                minMargin2 = Math.min(minMargin2, flowCnec.computeMargin(flow2, side, unit));
             }
         }
         return Pair.of(minMargin1, minMargin2);

ra-optimisation/search-tree-rao/src/main/java/com/powsybl/openrao/searchtreerao/linearoptimisation/algorithms/ProblemFillerHelper.java

@@ -122,6 +122,7 @@ public static List<ProblemFiller> getProblemFillers(IteratingLinearOptimizerInpu
                 input.initialFlowResult(),
                 parameters.getLoopFlowParameters(),
                 parameters.getLoopFlowParametersExtension(),
+                parameters.getObjectiveFunctionUnit(),
                 timestamp
             );
             problemFillers.add(maxLoopFlowFiller);
@@ -135,6 +136,7 @@ public static List<ProblemFiller> getProblemFillers(IteratingLinearOptimizerInpu
                 input.optimizationPerimeter().getFlowCnecs(),
                 input.prePerimeterFlowResult(),
                 parameters.getUnoptimizedCnecParameters(),
+                parameters.getObjectiveFunctionUnit(),
                 timestamp
             );
             problemFillers.add(unoptimizedCnecFiller);