Add condition support and some tests for Load Action with conditions.

Signed-off-by: Bertrand Rix <bertrand.rix@artelys.com>
powsybl · Jul 21, 2023 · 8314622 · 8314622
1 parent baf4119
commit 8314622
Show file tree

Hide file tree

Showing 11 changed files with 311 additions and 39 deletions.
diff --git a/cpp/src/bindings.cpp b/cpp/src/bindings.cpp
@@ -467,8 +467,18 @@ PYBIND11_MODULE(_pypowsybl, m) {
     m.def("add_switch_action", &pypowsybl::addSwitchAction, "Add a switch action",
           py::arg("analysis_context"), py::arg("action_id"), py::arg("switch_id"), py::arg("open"));
 
+    m.def("add_phase_tap_changer_position_action", &pypowsybl::addPhaseTapChangerPositionAction, "Add a switch action",
+           py::arg("analysis_context"), py::arg("action_id"), py::arg("transformer_id"), py::arg("is_relative"), py::arg("tapPosition"));
+
+    m.def("add_ratio_tap_changer_position_action", &pypowsybl::addRatioTapChangerPositionAction, "Add a switch action",
+           py::arg("analysis_context"), py::arg("action_id"), py::arg("transformer_id"), py::arg("is_relative"), py::arg("tapPosition"));
+
+    m.def("add_shunt_compensator_position_action", &pypowsybl::addShuntCompensatorPositionAction, "Add a switch action",
+              py::arg("analysis_context"), py::arg("action_id"), py::arg("shunt_id"), py::arg("section_count"));
+
     m.def("add_operator_strategy", &pypowsybl::addOperatorStrategy, "Add an operator strategy",
-          py::arg("analysis_context"), py::arg("operator_strategy_id"), py::arg("contingency_id"), py::arg("action_ids"));
+          py::arg("analysis_context"), py::arg("operator_strategy_id"), py::arg("contingency_id"), py::arg("action_ids"),
+          py::arg("condition_type"), py::arg("subject_ids"), py::arg("violation_types"));
 
     py::enum_<pypowsybl::LimitType>(m, "LimitType")
             .value("CURRENT", pypowsybl::LimitType::CURRENT)
@@ -480,6 +490,22 @@ PYBIND11_MODULE(_pypowsybl, m) {
             .value("ONE", pypowsybl::Side::ONE)
             .value("TWO", pypowsybl::Side::TWO);
 
+    py::enum_<violation_type>(m, "ViolationType")
+            .value("ACTIVE_POWER", violation_type::ACTIVE_POWER)
+            .value("APPARENT_POWER", violation_type::APPARENT_POWER)
+            .value("CURRENT", violation_type::CURRENT)
+            .value("LOW_VOLTAGE", violation_type::LOW_VOLTAGE)
+            .value("HIGH_VOLTAGE", violation_type::HIGH_VOLTAGE)
+            .value("LOW_SHORT_CIRCUIT_CURRENT", violation_type::LOW_SHORT_CIRCUIT_CURRENT)
+            .value("HIGH_SHORT_CIRCUIT_CURRENT", violation_type::HIGH_SHORT_CIRCUIT_CURRENT)
+            .value("OTHER", violation_type::OTHER);
+
+    py::enum_<condition_type>(m, "ConditionType")
+            .value("TRUE_CONDITION", condition_type::TRUE_CONDITION)
+            .value("ALL_VIOLATION_CONDITION", condition_type::ALL_VIOLATION_CONDITION)
+            .value("ANY_VIOLATION_CONDITION", condition_type::ANY_VIOLATION_CONDITION)
+            .value("AT_LEAST_ONE_VIOLATION_CONDITION", condition_type::AT_LEAST_ONE_VIOLATION_CONDITION);
+
     py::class_<network_metadata, std::shared_ptr<network_metadata>>(m, "NetworkMetadata")
             .def_property_readonly("id", [](const network_metadata& att) {
                 return att.id;

diff --git a/cpp/src/pypowsybl-api.h b/cpp/src/pypowsybl-api.h
@@ -165,6 +165,24 @@ typedef enum {
     TWTS3W,
 } validation_type;
 
+typedef enum {
+    ACTIVE_POWER = 0,
+    APPARENT_POWER,
+    CURRENT,
+    LOW_VOLTAGE,
+    HIGH_VOLTAGE,
+    LOW_SHORT_CIRCUIT_CURRENT,
+    HIGH_SHORT_CIRCUIT_CURRENT,
+    OTHER,
+} violation_type;
+
+typedef enum {
+    TRUE_CONDITION = 0,
+    ALL_VIOLATION_CONDITION,
+    ANY_VIOLATION_CONDITION,
+    AT_LEAST_ONE_VIOLATION_CONDITION,
+} condition_type;
+
 typedef enum {
     EQUIPMENT = 0,
     STEADY_STATE_HYPOTHESIS,

diff --git a/cpp/src/pypowsybl.cpp b/cpp/src/pypowsybl.cpp
@@ -808,12 +808,38 @@ void addGeneratorActivePowerAction(const JavaHandle& analysisContext, const std:
 }
 
 void addSwitchAction(const JavaHandle& analysisContext, const std::string& actionId, const std::string& switchId, bool open) {
-    callJava(::addSwitchAction, analysisContext, (char*) actionId.data(), (char*)  switchId.data(), open);
+    callJava(::addSwitchAction, analysisContext, (char*) actionId.data(), (char*) switchId.data(), open);
 }
 
-void addOperatorStrategy(const JavaHandle& analysisContext, std::string operatorStrategyId, std::string contingencyId, const std::vector<std::string>& actionsIds) {
-    ToCharPtrPtr actions(actionsIds);
-    callJava(::addOperatorStrategy, analysisContext, (char*) operatorStrategyId.data(), (char*) contingencyId.data(), actions.get(), actionsIds.size());
+void addPhaseTapChangerPositionAction(const JavaHandle& analysisContext, const std::string& actionId, const std::string& transformerId,
+                                      bool isRelative, int tapPosition) {
+    callJava(::addPhaseTapChangerPositionAction, analysisContext, (char*) actionId.data(), (char*) transformerId.data(), isRelative, tapPosition);
+}
+
+void addRatioTapChangerPositionAction(const JavaHandle& analysisContext, const std::string& actionId, const std::string& transformerId,
+                                      bool isRelative, int tapPosition) {
+    callJava(::addRatioTapChangerPositionAction, analysisContext, (char*) actionId.data(), (char*) transformerId.data(), isRelative, tapPosition);
+}
+
+void addShuntCompensatorPositionAction(const JavaHandle& analysisContext, const std::string& actionId, const std::string& shuntId,
+                                       int sectionCount) {
+    callJava(::addShuntCompensatorPositionAction, analysisContext, (char*) actionId.data(), (char*) shuntId.data(), sectionCount);
+}
+
+void addOperatorStrategy(const JavaHandle& analysisContext, std::string operatorStrategyId, std::string contingencyId, const std::vector<std::string>& actionsIds,
+                         condition_type conditionType, const std::vector<std::string>& subjectIds, const std::vector<violation_type>& violationTypesFilters) {
+    ToCharPtrPtr actionsPtr(actionsIds);
+    ToCharPtrPtr subjectIdsPtr(subjectIds);
+    std::vector<int> violationTypes;
+    std::cout << "violationTypesFilters size" << violationTypesFilters.size() << std::endl;
+    for(int i = 0; i < violationTypesFilters.size(); ++i) {
+        violationTypes.push_back(violationTypesFilters[i]);
+    }
+    ToIntPtr violationTypesPtr(violationTypes);
+    std::cout << "Building operator strategy " << (int) conditionType << std::endl;
+    callJava(::addOperatorStrategy, analysisContext, (char*) operatorStrategyId.data(), (char*) contingencyId.data(), actionsPtr.get(), actionsIds.size(),
+        conditionType, subjectIdsPtr.get(), subjectIds.size(), violationTypesPtr.get(), violationTypesFilters.size());
+    std::cout << "Building operator strategy / "<< std::endl;
 }
 
 ::zone* createZone(const std::string& id, const std::vector<std::string>& injectionsIds, const std::vector<double>& injectionsShiftKeys) {

diff --git a/cpp/src/pypowsybl.h b/cpp/src/pypowsybl.h
@@ -393,7 +393,14 @@ void addGeneratorActivePowerAction(const JavaHandle& analysisContext, const std:
 
 void addSwitchAction(const JavaHandle& analysisContext, const std::string& actionId, const std::string& switchId, bool open);
 
-void addOperatorStrategy(const JavaHandle& analysisContext, std::string operatorStrategyId, std::string contingencyId, const std::vector<std::string>& actionsIds);
+void addPhaseTapChangerPositionAction(const JavaHandle& analysisContext, const std::string& actionId, const std::string& transformerId, bool isRelative, int tapPosition);
+
+void addRatioTapChangerPositionAction(const JavaHandle& analysisContext, const std::string& actionId, const std::string& transformerId, bool isRelative, int tapPosition);
+
+void addShuntCompensatorPositionAction(const JavaHandle& analysisContext, const std::string& actionId, const std::string& shuntId, int sectionCount);
+
+void addOperatorStrategy(const JavaHandle& analysisContext, std::string operatorStrategyId, std::string contingencyId, const std::vector<std::string>& actionsIds,
+                         condition_type conditionType, const std::vector<std::string>& subjectIds, const std::vector<violation_type>& violationTypesFilters);
 
 void setZones(const JavaHandle& sensitivityAnalysisContext, const std::vector<::zone*>& zones);
 

diff --git a/java/src/main/java/com/powsybl/python/commons/CTypeUtil.java b/java/src/main/java/com/powsybl/python/commons/CTypeUtil.java
@@ -17,9 +17,8 @@
 import org.graalvm.word.WordFactory;
 
 import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
+import java.util.function.IntFunction;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
@@ -89,6 +88,18 @@ public static List<Integer> toIntegerList(CIntPointer intPointer, int length) {
         return ints;
     }
 
+    /**
+     * Convert an int list to a set of enum using the specified converter
+     */
+    public static <T> Set<T> toEnumSet(CIntPointer intPointer, int length, IntFunction<T> converter) {
+        Set<T> enumSet = new HashSet<>();
+        for (int i = 0; i < length; i++) {
+            T value = converter.apply(intPointer.read(i));
+            enumSet.add(value);
+        }
+        return enumSet;
+    }
+
     public static Map<String, String> toStringMap(CCharPointerPointer keysPointer, int keysCount,
                                                   CCharPointerPointer valuesPointer, int valuesCount) {
         List<String> keys = toStringList(keysPointer, keysCount);

diff --git a/java/src/main/java/com/powsybl/python/commons/PyPowsyblApiHeader.java b/java/src/main/java/com/powsybl/python/commons/PyPowsyblApiHeader.java
@@ -13,10 +13,7 @@
 import org.graalvm.nativeimage.c.constant.CEnumLookup;
 import org.graalvm.nativeimage.c.constant.CEnumValue;
 import org.graalvm.nativeimage.c.struct.*;
-import org.graalvm.nativeimage.c.type.CCharPointer;
-import org.graalvm.nativeimage.c.type.CCharPointerPointer;
-import org.graalvm.nativeimage.c.type.CDoublePointer;
-import org.graalvm.nativeimage.c.type.VoidPointer;
+import org.graalvm.nativeimage.c.type.*;
 import org.graalvm.word.PointerBase;
 
 /**
@@ -621,6 +618,23 @@ public enum NetworkModificationType {
         public static native NetworkModificationType fromCValue(int value);
     }
 
+    @CEnum("violation_type")
+    public enum LimitViolationType {
+        ACTIVE_POWER,
+        APPARENT_POWER,
+        CURRENT,
+        LOW_VOLTAGE,
+        HIGH_VOLTAGE,
+        LOW_SHORT_CIRCUIT_CURRENT,
+        HIGH_SHORT_CIRCUIT_CURRENT,
+        OTHER;
+        @CEnumValue
+        public native int getCValue();
+
+        @CEnumLookup
+        public static native LimitViolationType fromCValue(int value);
+    }
+
     @CEnum("remove_modification_type")
     public enum RemoveModificationType {
         REMOVE_FEEDER,
@@ -987,4 +1001,17 @@ public enum BranchSide {
         @CEnumLookup
         public static native BranchSide fromCValue(int value);
     }
+
+    @CEnum("condition_type")
+    public enum ConditionType {
+        TRUE_CONDITION,
+        ALL_VIOLATION_CONDITION,
+        ANY_VIOLATION_CONDITION,
+        AT_LEAST_ONE_VIOLATION_CONDITION;
+        @CEnumValue
+        public native int getCValue();
+
+        @CEnumLookup
+        public static native ConditionType fromCValue(int value);
+    }
 }
diff --git a/java/src/main/java/com/powsybl/python/commons/Util.java b/java/src/main/java/com/powsybl/python/commons/Util.java
@@ -16,6 +16,7 @@
 import com.powsybl.iidm.network.ValidationLevel;
 import com.powsybl.python.commons.PyPowsyblApiHeader.ArrayPointer;
 import com.powsybl.python.dataframe.CDataframeHandler;
+import com.powsybl.security.LimitViolationType;
 import org.graalvm.nativeimage.UnmanagedMemory;
 import org.graalvm.nativeimage.c.struct.SizeOf;
 import org.graalvm.nativeimage.c.type.CCharPointerPointer;
@@ -401,4 +402,27 @@ public static Optional<CompressionFormat> detectCompressionFormat(ByteBuffer buf
             return Optional.empty();
         }
     }
+
+    public static LimitViolationType convert(PyPowsyblApiHeader.LimitViolationType violationType) {
+        switch (violationType) {
+            case ACTIVE_POWER:
+                return LimitViolationType.ACTIVE_POWER;
+            case APPARENT_POWER:
+                return LimitViolationType.APPARENT_POWER;
+            case CURRENT:
+                return LimitViolationType.CURRENT;
+            case LOW_VOLTAGE:
+                return LimitViolationType.LOW_VOLTAGE;
+            case HIGH_VOLTAGE:
+                return LimitViolationType.HIGH_VOLTAGE;
+            case LOW_SHORT_CIRCUIT_CURRENT:
+                return LimitViolationType.LOW_SHORT_CIRCUIT_CURRENT;
+            case HIGH_SHORT_CIRCUIT_CURRENT:
+                return LimitViolationType.HIGH_SHORT_CIRCUIT_CURRENT;
+            case OTHER:
+                return LimitViolationType.OTHER;
+            default:
+                throw new PowsyblException("Unknown limit violation type: " + violationType);
+        }
+    }
 }