TCOPFLOW Python Bindings First Pass

interfaces/python/CMakeLists.txt

@@ -18,8 +18,10 @@ if(EXAGO_ENABLE_IPOPT OR EXAGO_ENABLE_HIOP)
 endif()
 
 if(EXAGO_ENABLE_IPOPT)
-  list(APPEND EXAGO_PY_SRCS exago_python_scopflow.cpp exago_python_sopflow.cpp)
-  list(APPEND EXAGO_PY_LIBS ExaGO::SOPFLOW ExaGO::SCOPFLOW)
+  list(APPEND EXAGO_PY_SRCS exago_python_scopflow.cpp exago_python_sopflow.cpp
+       exago_python_tcopflow.cpp
+  )
+  list(APPEND EXAGO_PY_LIBS ExaGO::SOPFLOW ExaGO::SCOPFLOW ExaGO::TCOPFLOW)
 endif()
 
 # New true python bindings

interfaces/python/exago_python.cpp

@@ -64,5 +64,9 @@ PYBIND11_MODULE(exago, m) {
 
   extern void init_exago_sopflow(pybind11::module & m);
   init_exago_sopflow(m);
+
+  extern void init_exago_tcopflow(pybind11::module & m);
+  init_exago_tcopflow(m);
+
 #endif
 }

interfaces/python/exago_python_tcopflow.cpp

@@ -0,0 +1,87 @@
+#include "exago_python_tcopflow.hpp"
+
+// -------------------------------------------------------------
+// class TCOPFLOW_wrapper
+//
+// Wrap to make sure allocation and destruction is handled correctly
+// -------------------------------------------------------------
+class TCOPFLOW_wrapper {
+public:
+  TCOPFLOW tcopf;
+  TCOPFLOW_wrapper(void) {
+    PetscErrorCode ierr;
+    MPI_Comm communicator;
+    ierr = ExaGOGetSelfCommunicator(&communicator);
+    ExaGOCheckError(ierr);
+    ierr = TCOPFLOWCreate(communicator, &tcopf);
+    ExaGOCheckError(ierr);
+  }
+  ~TCOPFLOW_wrapper(void) {
+    PetscErrorCode ierr;
+    ierr = TCOPFLOWDestroy(&tcopf);
+    ExaGOCheckError(ierr);
+  }
+};
+
+// -------------------------------------------------------------
+// init_exago_tcopflow
+// -------------------------------------------------------------
+void init_exago_tcopflow(pybind11::module &m) {
+
+  pybind11::class_<TCOPFLOW_wrapper>(m, "TCOPFLOW")
+      .def(pybind11::init())
+      .def("set_network_data",
+           [](TCOPFLOW_wrapper &w, std::string filename) {
+             PetscErrorCode ierr;
+             ierr = TCOPFLOWSetNetworkData(w.tcopf, filename.c_str());
+             ExaGOCheckError(ierr);
+           })
+      .def("set_solver",
+           [](TCOPFLOW_wrapper &w, std::string solver) {
+             PetscErrorCode ierr;
+             ierr = TCOPFLOWSetSolver(w.tcopf, solver.c_str());
+             ExaGOCheckError(ierr);
+           })
+      .def("set_tolerance",
+           [](TCOPFLOW_wrapper &w, double tol) {
+             PetscErrorCode ierr;
+             ierr = TCOPFLOWSetTolerance(w.tcopf, tol);
+             ExaGOCheckError(ierr);
+           })
+      .def("setup",
+           [](TCOPFLOW_wrapper &w) {
+             PetscErrorCode ierr;
+             ierr = TCOPFLOWSetUp(w.tcopf);
+             ExaGOCheckError(ierr);
+           })
+      .def("solve",
+           [](TCOPFLOW_wrapper &w) {
+             PetscErrorCode ierr;
+             ierr = TCOPFLOWSolve(w.tcopf);
+             ExaGOCheckError(ierr);
+           })
+
+      .def("get_convergence_status",
+           [](TCOPFLOW_wrapper &w) -> bool {
+             PetscErrorCode ierr;
+             PetscBool flag;
+             ierr = TCOPFLOWGetConvergenceStatus(w.tcopf, &flag);
+             ExaGOCheckError(ierr);
+             return flag;
+           })
+      .def("get_objective",
+           [](TCOPFLOW_wrapper &w) -> double {
+             PetscErrorCode ierr;
+             double obj;
+             ierr = TCOPFLOWGetObjective(w.tcopf, &obj);
+             ExaGOCheckError(ierr);
+             return obj;
+           })
+      .def("get_num_iterations", [](TCOPFLOW_wrapper &w) -> int {
+        PetscErrorCode ierr;
+        PetscInt n;
+        ierr = TCOPFLOWGetNumIterations(w.tcopf, &n);
+        ExaGOCheckError(ierr);
+        return n;
+      });
+}

interfaces/python/exago_python_tcopflow.hpp

@@ -0,0 +1,8 @@
+#ifndef _exago_python_tcopflow_hpp_
+#define _exago_python_tcopflow_hpp_
+
+#include "exago_python_opflow.hpp"
+#include <tcopflow.h>
+#include <private/tcopflowimpl.h>
+
+#endif

interfaces/python/example_tcopflow.py

@@ -0,0 +1,17 @@
+import os
+import exago
+
+# Initialize a given application to be run
+exago.initialize("tcopflow_test")
+tcopf = exago.TCOPFLOW()
+path = exago.prefix()
+tcopf.set_network_data(
+    os.path.join(path, 'share', 'exago', 'datafiles', 'case9', 'case9mod.m'))
+tcopf.set_solver("IPOPT")
+tcopf.solve()
+tcopf.print_solution(0)
+
+# Delete instance before finalization (try, at least)
+del tcopf
+
+exago.finalize()

tests/interfaces/python/CMakeLists.txt

@@ -22,7 +22,16 @@ endif()
 
 # The SCOPFLOW and SOPFLOW API tests are currently written only for IPOPT
 if(EXAGO_ENABLE_IPOPT)
-  string(APPEND TEST_FILES " " "test_3_scopflow.py" " " "test_4_sopflow.py")
+  string(
+    APPEND
+    TEST_FILES
+    " "
+    "test_3_scopflow.py"
+    " "
+    "test_4_sopflow.py"
+    " "
+    "test_5_tcopflow.py"
+  )
 endif()
 string(APPEND TEST_FILES " " "test_9_finalize.py")
 

tests/interfaces/python/test_0_initialize.py

@@ -1,10 +1,12 @@
 # test initializing exago only once
+import exago
+from check_preconditions import check_preconditions
 import os
 import pytest
-from check_preconditions import check_preconditions
 import mpi4py.rc
 mpi4py.rc.threads = False
 from mpi4py import MPI  # noqa
+check_preconditions()
 import exago  # noqa
 
 

tests/interfaces/python/test_5_tcopflow.py

@@ -0,0 +1,38 @@
+from mpi4py import MPI
+import tempfile
+import os
+import shutil
+import pytest
+from check_preconditions import check_preconditions
+import exago
+import mpi4py.rc
+mpi4py.rc.threads = False
+
+check_preconditions()
+
+
+def run_tcopflow(solver):
+    tcopf = exago.TCOPFLOW()
+    path = exago.prefix()
+
+    tcopf.set_tolerance(1.0E-03)
+    tcopf.set_network_data(os.path.join(
+        path, 'share', 'exago', 'datafiles', 'case9', 'case9mod_gen3_wind.m'))
+    tcopf.set_solver(solver)
+
+    tcopf.setup()
+    tcopf.solve()
+
+    assert tcopf.get_convergence_status()
+
+    obj = tcopf.get_objective()
+    assert isinstance(obj, float)
+
+    n = tcopf.get_num_iterations()
+    assert isinstance(n, int)
+
+
+@pytest.mark.nocomm
+@pytest.mark.MPI
+def test_tcopflow_1():
+    run_tcopflow('IPOPT')