Rao result from file for monitoring and glsk purpose

cpp/powsybl-cpp/powsybl-cpp.cpp

@@ -2085,19 +2085,27 @@ JavaHandle getCrac(const JavaHandle& raoContext) {
     return pypowsybl::PowsyblCaller::get()->callJava<JavaHandle>(::getCrac, raoContext);
 }
 
-JavaHandle runRaoWithParameters(const JavaHandle& networkHandle, const JavaHandle& raoHandle, const RaoParameters& parameters, const std::string& raoProvider) {
+void setLoopFlowGlsk(const JavaHandle& raoContext, const JavaHandle& glsk) {
+    pypowsybl::PowsyblCaller::get()->callJava(::setLoopFlowGlsk, raoContext, glsk);
+}
+
+void setMonitoringGlsk(const JavaHandle& raoContext, const JavaHandle& glsk) {
+    pypowsybl::PowsyblCaller::get()->callJava(::setMonitoringGlsk, raoContext, glsk);
+}
+
+JavaHandle runRaoWithParameters(const JavaHandle& networkHandle, const JavaHandle& cracHandle, const JavaHandle& raoHandle, const RaoParameters& parameters, const std::string& raoProvider) {
     auto c_parameters = parameters.to_c_struct();
-    return pypowsybl::PowsyblCaller::get()->callJava<JavaHandle>(::runRao, networkHandle, raoHandle, c_parameters.get(), (char*) raoProvider.data());
+    return pypowsybl::PowsyblCaller::get()->callJava<JavaHandle>(::runRao, networkHandle, cracHandle, raoHandle, c_parameters.get(), (char*) raoProvider.data());
 }
 
-JavaHandle runVoltageMonitoring(const JavaHandle& networkHandle, const JavaHandle& resultHandle, const JavaHandle& contextHandle, const LoadFlowParameters& parameters, const std::string& provider) {
+JavaHandle runVoltageMonitoring(const JavaHandle& networkHandle, const JavaHandle& resultHandle, const JavaHandle& cracHandle, const JavaHandle& contextHandle, const LoadFlowParameters& parameters, const std::string& provider) {
     auto c_loadflow_parameters = parameters.to_c_struct();
-    return pypowsybl::PowsyblCaller::get()->callJava<JavaHandle>(::runVoltageMonitoring, networkHandle, resultHandle, contextHandle, c_loadflow_parameters.get(), (char *) provider.data());
+    return pypowsybl::PowsyblCaller::get()->callJava<JavaHandle>(::runVoltageMonitoring, networkHandle, resultHandle, cracHandle, contextHandle, c_loadflow_parameters.get(), (char *) provider.data());
 }
 
-JavaHandle runAngleMonitoring(const JavaHandle& networkHandle, const JavaHandle& resultHandle, const JavaHandle& contextHandle, const LoadFlowParameters& parameters, const std::string& provider) {
+JavaHandle runAngleMonitoring(const JavaHandle& networkHandle, const JavaHandle& resultHandle, const JavaHandle& cracHandle, const JavaHandle& contextHandle, const LoadFlowParameters& parameters, const std::string& provider) {
     auto c_loadflow_parameters = parameters.to_c_struct();
-    return pypowsybl::PowsyblCaller::get()->callJava<JavaHandle>(::runAngleMonitoring, networkHandle, resultHandle, contextHandle, c_loadflow_parameters.get(), (char *) provider.data());
+    return pypowsybl::PowsyblCaller::get()->callJava<JavaHandle>(::runAngleMonitoring, networkHandle, resultHandle, cracHandle, contextHandle, c_loadflow_parameters.get(), (char *) provider.data());
 }
 
 

cpp/powsybl-cpp/powsybl-cpp.h

@@ -1029,10 +1029,13 @@ SeriesArray* getCostResults(const JavaHandle& cracHandle, const JavaHandle& resu
 std::vector<std::string> getVirtualCostNames(const JavaHandle& resultHandle);
 SeriesArray* getVirtualCostsResults(const JavaHandle& cracHandle, const JavaHandle& resultHandle, const std::string& virtualCostName);
 
+void setLoopFlowGlsk(const JavaHandle& raoContext, const JavaHandle& glsk);
+void setMonitoringGlsk(const JavaHandle& raoContext, const JavaHandle& glsk);
+
 JavaHandle createDefaultRaoParameters();
-JavaHandle runRaoWithParameters(const JavaHandle& networkHandle, const JavaHandle& raoHandle, const RaoParameters& parameters, const std::string& raoProvider);
-JavaHandle runVoltageMonitoring(const JavaHandle& networkHandle, const JavaHandle& resultHandle, const JavaHandle& contextHandle, const LoadFlowParameters& parameters, const std::string& provider);
-JavaHandle runAngleMonitoring(const JavaHandle& networkHandle, const JavaHandle& resultHandle, const JavaHandle& contextHandle, const LoadFlowParameters& parameters, const std::string& provider);
+JavaHandle runRaoWithParameters(const JavaHandle& networkHandle, const JavaHandle& cracHandle, const JavaHandle& raoHandle, const RaoParameters& parameters, const std::string& raoProvider);
+JavaHandle runVoltageMonitoring(const JavaHandle& networkHandle, const JavaHandle& resultHandle, const JavaHandle& cracHandle, const JavaHandle& contextHandle, const LoadFlowParameters& parameters, const std::string& provider);
+JavaHandle runAngleMonitoring(const JavaHandle& networkHandle, const JavaHandle& resultHandle, const JavaHandle& cracHandle, const JavaHandle& contextHandle, const LoadFlowParameters& parameters, const std::string& provider);
 
 JavaHandle createGrid2opBackend(const JavaHandle& networkHandle, bool considerOpenBranchReactiveFlow, bool checkIsolatedAndDisconnectedInjections, int busesPerVoltageLevel, bool connectAllElementsToFirstBus);
 void freeGrid2opBackend(const JavaHandle& backendHandle);

cpp/pypowsybl-cpp/bindings.cpp

@@ -26,8 +26,9 @@ pypowsybl::JavaHandle loadNetworkFromBinaryBuffersPython(std::vector<py::buffer>
 
 py::bytes saveNetworkToBinaryBufferPython(const pypowsybl::JavaHandle& network, const std::string& format, const std::map<std::string, std::string>& parameters, pypowsybl::JavaHandle* reportNode);
 
-void setCracSource(const pypowsybl::JavaHandle& networkHandle, const pypowsybl::JavaHandle& raoHandle, const py::buffer& crac);
-void setGlskSource(const pypowsybl::JavaHandle& networkHandle, const pypowsybl::JavaHandle& raoHandle, const py::buffer& glsk);
+pypowsybl::JavaHandle loadCracSource(const pypowsybl::JavaHandle& networkHandle, const py::buffer& crac);
+pypowsybl::JavaHandle loadGlskSource(const py::buffer& glsk);
+pypowsybl::JavaHandle loadResultSource(const pypowsybl::JavaHandle& cracHandle, const py::buffer& result);
 pypowsybl::RaoParameters* loadRaoParametersFromBuffer(const py::buffer& parameters);
 
 py::bytes saveRaoParametersToBinaryBuffer(const pypowsybl::RaoParameters& rao_parameters);
@@ -1272,12 +1273,15 @@ PYBIND11_MODULE(_pypowsybl, m) {
 
     m.def("create_rao", &pypowsybl::createRao, "Create rao context");
     m.def("run_rao", &pypowsybl::runRaoWithParameters, py::call_guard<py::gil_scoped_release>(), "Run a rao from buffered inputs",
-        py::arg("network"), py::arg("rao_context"), py::arg("parameters"), py::arg("rao_provider"));
-    m.def("set_crac_source", ::setCracSource, py::call_guard<py::gil_scoped_release>(), "Set crac source",
-            py::arg("network"), py::arg("rao_context"), py::arg("crac_source"));
-    m.def("set_glsk_source", ::setGlskSource, py::call_guard<py::gil_scoped_release>(), "Set glsk source",
-            py::arg("network"), py::arg("rao_context"), py::arg("glsk_source"));
+        py::arg("network"), py::arg("crac"), py::arg("rao_context"), py::arg("parameters"), py::arg("rao_provider"));
+    m.def("load_crac_source", ::loadCracSource, py::call_guard<py::gil_scoped_release>(), "Set crac source",
+            py::arg("network"), py::arg("crac_source"));
+    m.def("load_glsk_source", ::loadGlskSource, py::call_guard<py::gil_scoped_release>(), "Set glsk source", py::arg("glsk_source"));
     m.def("get_crac", &pypowsybl::getCrac, "Get crac associated to the rao context", py::arg("rao_context"));
+    m.def("set_loopflow_glsk", &pypowsybl::setLoopFlowGlsk, "Set the glsk used for loop flow in rao run", py::arg("rao_context"), py::arg("glsk"));
+    m.def("set_monitoring_glsk", &pypowsybl::setMonitoringGlsk, "Set the glsk used for the rao angle monitoring", py::arg("rao_context"), py::arg("glsk"));
+    m.def("load_result_source", ::loadResultSource, py::call_guard<py::gil_scoped_release>(), "Load result source",
+            py::arg("crac"), py::arg("result_source"));
     m.def("create_default_rao_parameters", &pypowsybl::createDefaultRaoParameters, "Create a default rao parameter");
     m.def("load_rao_parameters", ::loadRaoParametersFromBuffer, "Load rao parameters from a buffer", py::arg("parameters_buffer"));
     m.def("serialize_rao_parameters", ::saveRaoParametersToBinaryBuffer, "Serialize rao parameters to a buffer", py::arg("rao_parameters"));
@@ -1293,8 +1297,8 @@ PYBIND11_MODULE(_pypowsybl, m) {
     m.def("get_cost_results", &pypowsybl::getCostResults, "Get rao cost results", py::arg("crac"), py::arg("rao_result"));
     m.def("get_virtual_cost_names", &pypowsybl::getVirtualCostNames, "Get virtual cost names", py::arg("rao_result"));
     m.def("get_virtual_cost_results", &pypowsybl::getVirtualCostsResults, "Get rao virtual cost results", py::arg("crac"), py::arg("rao_result"), py::arg("virtual_cost_name"));
-    m.def("run_voltage_monitoring", &pypowsybl::runVoltageMonitoring, py::call_guard<py::gil_scoped_release>(), "Run voltage monitoring", py::arg("network"), py::arg("result_handle"), py::arg("context_handle"), py::arg("load_flow_parameters"), py::arg("provider"));
-    m.def("run_angle_monitoring", &pypowsybl::runAngleMonitoring, py::call_guard<py::gil_scoped_release>(), "Run angle monitoring", py::arg("network"), py::arg("result_handle"), py::arg("context_handle"), py::arg("load_flow_parameters"), py::arg("provider"));
+    m.def("run_voltage_monitoring", &pypowsybl::runVoltageMonitoring, py::call_guard<py::gil_scoped_release>(), "Run voltage monitoring", py::arg("network"), py::arg("result_handle"), py::arg("crac_handle"), py::arg("context_handle"), py::arg("load_flow_parameters"), py::arg("provider"));
+    m.def("run_angle_monitoring", &pypowsybl::runAngleMonitoring, py::call_guard<py::gil_scoped_release>(), "Run angle monitoring", py::arg("network"), py::arg("result_handle"), py::arg("crac_handle"), py::arg("context_handle"), py::arg("load_flow_parameters"), py::arg("provider"));
 
     py::enum_<Grid2opStringValueType>(m, "Grid2opStringValueType")
             .value("VOLTAGE_LEVEL_NAME", Grid2opStringValueType::VOLTAGE_LEVEL_NAME)
@@ -1461,17 +1465,20 @@ py::bytes saveNetworkToBinaryBufferPython(const pypowsybl::JavaHandle& network,
     return bytes;
 }
 
-void setCracSource(const pypowsybl::JavaHandle& networkHandle, const pypowsybl::JavaHandle& raoHandle, const py::buffer& crac) {
+pypowsybl::JavaHandle loadCracSource(const pypowsybl::JavaHandle& networkHandle, const py::buffer& crac) {
     py::buffer_info cracInfo = crac.request();
-    pypowsybl::PowsyblCaller::get()->callJava<>(::setCracBufferedSource,
-     networkHandle, raoHandle, static_cast<char*>(cracInfo.ptr), cracInfo.size);
+    return pypowsybl::PowsyblCaller::get()->callJava<pypowsybl::JavaHandle>(::loadCracBufferedSource, networkHandle, static_cast<char*>(cracInfo.ptr), cracInfo.size);
 }
 
-void setGlskSource(const pypowsybl::JavaHandle& networkHandle, const pypowsybl::JavaHandle& raoHandle, const py::buffer& glsk) {
+pypowsybl::JavaHandle loadGlskSource(const py::buffer& glsk) {
     py::buffer_info glskInfo = glsk.request();
-    pypowsybl::PowsyblCaller::get()->callJava<>(::setGlskBufferedSource,
-     networkHandle, raoHandle,
-     static_cast<char*>(glskInfo.ptr), glskInfo.size);
+    return pypowsybl::PowsyblCaller::get()->callJava<pypowsybl::JavaHandle>(::loadGlskBufferedSource, static_cast<char*>(glskInfo.ptr), glskInfo.size);
+}
+
+pypowsybl::JavaHandle loadResultSource(const pypowsybl::JavaHandle& cracHandle, const py::buffer& result) {
+    py::buffer_info resultInfo = result.request();
+    return pypowsybl::PowsyblCaller::get()->callJava<pypowsybl::JavaHandle>(::loadResultFromBufferedSource,
+     cracHandle, static_cast<char*>(resultInfo.ptr), resultInfo.size);
 }
 
 py::bytes saveRaoResultsToBinaryBuffer(const pypowsybl::JavaHandle& raoResult, const pypowsybl::JavaHandle& crac) {

data/rao/rao_result_for_monitoring.json

@@ -0,0 +1,133 @@
+{
+  "type" : "RAO_RESULT",
+  "version" : "1.8",
+  "info" : "Generated by Open RAO https://powsybl.readthedocs.io/projects/openrao",
+  "computationStatus" : "default",
+  "executionDetails" : "The RAO only went through first preventive",
+  "costResults" : {
+    "initial" : {
+      "functionalCost" : -5.00,
+      "virtualCost" : {
+        "sensitivity-failure-cost" : 0.00
+      }
+    },
+    "preventive" : {
+      "functionalCost" : -5.00,
+      "virtualCost" : {
+        "sensitivity-failure-cost" : 0.00
+      }
+    },
+    "outage" : {
+      "functionalCost" : -5.00,
+      "virtualCost" : {
+        "sensitivity-failure-cost" : 0.00
+      }
+    },
+    "auto" : {
+      "functionalCost" : -5.00,
+      "virtualCost" : {
+        "sensitivity-failure-cost" : 0.00
+      }
+    },
+    "curative" : {
+      "functionalCost" : -5.00,
+      "virtualCost" : {
+        "sensitivity-failure-cost" : 0.00
+      }
+    }
+  },
+  "computationStatusMap" : [ ],
+  "flowCnecResults" : [ {
+    "flowCnecId" : "cnec1 - curative",
+    "initial" : {
+      "ampere" : {
+        "margin" : 7.60,
+        "side2" : {
+          "flow" : 0.00
+        }
+      },
+      "megawatt" : {
+        "margin" : 5.00,
+        "side2" : {
+          "flow" : 0.00
+        }
+      }
+    },
+    "preventive" : {
+      "ampere" : {
+        "margin" : 7.60,
+        "side2" : {
+          "flow" : 0.00
+        }
+      },
+      "megawatt" : {
+        "margin" : 5.00,
+        "side2" : {
+          "flow" : 0.00
+        }
+      }
+    },
+    "auto" : {
+      "ampere" : {
+        "margin" : 7.60,
+        "side2" : {
+          "flow" : 0.00
+        }
+      },
+      "megawatt" : {
+        "margin" : 5.00,
+        "side2" : {
+          "flow" : 0.00
+        }
+      }
+    },
+    "curative" : {
+      "ampere" : {
+        "margin" : 7.60,
+        "side2" : {
+          "flow" : 0.00
+        }
+      },
+      "megawatt" : {
+        "margin" : 5.00,
+        "side2" : {
+          "flow" : 0.00
+        }
+      }
+    }
+  }, {
+    "flowCnecId" : "cnec1 - preventive",
+    "initial" : {
+      "ampere" : {
+        "margin" : 68.25,
+        "side2" : {
+          "flow" : 83.68
+        }
+      },
+      "megawatt" : {
+        "margin" : 49.99,
+        "side2" : {
+          "flow" : 50.01
+        }
+      }
+    },
+    "preventive" : {
+      "ampere" : {
+        "margin" : 68.25,
+        "side2" : {
+          "flow" : 83.68
+        }
+      },
+      "megawatt" : {
+        "margin" : 49.99,
+        "side2" : {
+          "flow" : 50.01
+        }
+      }
+    }
+  } ],
+  "angleCnecResults" : [ ],
+  "voltageCnecResults" : [ ],
+  "networkActionResults" : [ ],
+  "rangeActionResults" : [ ]
+}

docs/user_guide/rao.rst

@@ -25,24 +25,27 @@ Here is a code example of how to configure and run the RAO:
 
     >>> import pypowsybl as pp
     >>> from pypowsybl.rao import Parameters as RaoParameters
+    >>> from pypowsybl.rao import Crac
+    >>> from pypowsybl.rao import Glsk as RaoGlsk
+    >>> from pypowsybl.rao import RaoResult
     >>>
     >>> network =  pp.network.load(str(DATA_DIR.joinpath("rao/rao_network.uct")))
-    >>> parameters = RaoParameters()
-    >>> parameters.load_from_file_source(str(DATA_DIR.joinpath("rao/rao_parameters.json")))
+    >>> parameters = RaoParameters.from_file_source(str(DATA_DIR.joinpath("rao/rao_parameters.json")))
     >>> rao_runner = pp.rao.create_rao()
-    >>> rao_runner.set_crac_file_source(network, str(DATA_DIR.joinpath("rao/rao_crac.json")))
-    >>> rao_runner.set_glsk_file_source(network, str(DATA_DIR.joinpath("rao/rao_glsk.xml")))
-    >>> rao_result = rao_runner.run(network, parameters)
+    >>> crac = Crac.from_file_source(network, str(DATA_DIR.joinpath("rao/rao_crac.json")))
+    >>> glsk = RaoGlsk.from_file_source(str(DATA_DIR.joinpath("rao/rao_glsk.xml")))
+    >>> rao_result = rao_runner.run(crac=crac, network=network, parameters=parameters, loop_flow_glsk=glsk)
     >>> rao_result.status()
     <RaoComputationStatus.DEFAULT: 0>
 
 Monitoring API
 --------------
 
-Rao monitoring can run through the following API using an already produced rao result :
+Rao monitoring can run through the following API using a rao result already produced by a run, or loaded from file :
 
-    >>> result_with_voltage_monitoring = rao_runner.run_voltage_monitoring(network, rao_result)
-    >>> result_with_angle_monitoring = rao_runner.run_angle_monitoring(network, rao_result)
+    >>> result_with_voltage_monitoring = rao_runner.run_voltage_monitoring(crac, network, rao_result)
+    >>> monitoring_glsk = RaoGlsk.from_file_source(str(DATA_DIR.joinpath("rao/GlskB45test.xml")))
+    >>> result_with_angle_monitoring = rao_runner.run_angle_monitoring(crac, network, rao_result, monitoring_glsk=monitoring_glsk)
 
 The returned rao result object are the original result enhanced with voltage or angle monitoring data.
 
@@ -152,11 +155,12 @@ Cost for a given virtual cost name is returned as a pandas dataframe with cost v
     >>> sensi_cost.loc['curative', 'sensitivity-failure-cost']
     np.float64(0.0)
 
-The 'RaoResult' object can also be serialized to json:
+The 'RaoResult' object can also be serialized to json and loaded from file:
 
 .. doctest::
 
     >>> rao_result.serialize(str(DATA_DIR.joinpath("rao/results.json")))
+    >>> loaded_result = RaoResult.from_file_source(crac, str(DATA_DIR.joinpath("rao/results.json")))
 
 Rao logs filter
 ---------------
@@ -169,17 +173,16 @@ open rao, a RaoLogFilter is available :
     >>> import pypowsybl as pp
     >>> import logging
     >>> import sys
-    >>> from pypowsybl.rao import (Parameters as RaoParameters, RaoLogFilter)
+    >>> from pypowsybl.rao import (Parameters as RaoParameters, RaoLogFilter, Crac, Glsk as RaoGlsk)
     >>>
     >>> network =  pp.network.load(str(DATA_DIR.joinpath("rao/rao_network.uct")))
-    >>> parameters = RaoParameters()
-    >>> parameters.load_from_file_source(str(DATA_DIR.joinpath("rao/rao_parameters.json")))
+    >>> parameters = RaoParameters.from_file_source(str(DATA_DIR.joinpath("rao/rao_parameters.json")))
     >>> rao_runner = pp.rao.create_rao()
-    >>> rao_runner.set_crac_file_source(network, str(DATA_DIR.joinpath("rao/rao_crac.json")))
-    >>> rao_runner.set_glsk_file_source(network, str(DATA_DIR.joinpath("rao/rao_glsk.xml")))
+    >>> crac = Crac.from_file_source(network, str(DATA_DIR.joinpath("rao/rao_crac.json")))
+    >>> glsk = RaoGlsk.from_file_source(str(DATA_DIR.joinpath("rao/rao_glsk.xml")))
     >>>
     >>> logging.basicConfig(stream=sys.stdout) # Setup logging
     >>> logger = logging.getLogger('powsybl')
     >>> logger.setLevel(logging.ERROR)
     >>> logger.addFilter(RaoLogFilter())
-    >>> rao_result = rao_runner.run(network, parameters)
+    >>> rao_result = rao_runner.run(crac, network, parameters, loop_flow_glsk=glsk)