Rearrange build so that Python package can be tested from the build directory without install

Update README with info on the Python package
Don't re-use CVode solver memory between driver calls

Author: langmm

CMakeLists.txt

@@ -550,24 +550,36 @@ if(BUILD_PYTHON)
              COMMAND pytest -svx ${PROJECT_SOURCE_DIR}/tests/python)
 
     # Installation
+    # set(PYTHON_BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR})
+    cmake_path(
+        APPEND CMAKE_CURRENT_BINARY_DIR ${PYTHON_PACKAGE_NAME}
+        OUTPUT_VARIABLE PYTHON_BUILD_DIR
+    )
     cmake_path(
         APPEND Python_SITEARCH ${PYTHON_PACKAGE_NAME}
-        OUTPUT_VARIABLE EPHOTOSYNTHESIS_INSTALL_PYTHONDIR
+        OUTPUT_VARIABLE PYTHON_INSTALL_DIR
     )
     message(STATUS "Python_SITEARCH = ${Python_SITEARCH}")
     message(STATUS "PYTHON_PACKAGE_NAME = ${PYTHON_PACKAGE_NAME}")
-    message(STATUS "EPHOTOSYNTHESIS_INSTALL_PYTHONDIR = ${EPHOTOSYNTHESIS_INSTALL_PYTHONDIR}")
+    message(STATUS "PYTHON_INSTALL_DIR = ${PYTHON_INSTALL_DIR}")
+    message(STATUS "PYTHON_BUILD_DIR = ${PYTHON_BUILD_DIR}")
     install(
         TARGETS ${PYTHON_LIBRARY_NAME}
-        DESTINATION "${EPHOTOSYNTHESIS_INSTALL_PYTHONDIR}"
+        DESTINATION "${PYTHON_INSTALL_DIR}"
         COMPONENT Python
-        EXCLUDE_FROM_ALL
     )
-    configure_file(cmake/__init__.py.in __init__.py @ONLY)
+    set_target_properties(
+        ${PYTHON_LIBRARY_NAME} PROPERTIES
+        LIBRARY_OUTPUT_DIRECTORY ${PYTHON_BUILD_DIR}
+        RUNTIME_OUTPUT_DIRECTORY ${PYTHON_BUILD_DIR}
+    )
+    configure_file(
+        cmake/__init__.py.in
+        ${PYTHON_BUILD_DIR}/__init__.py @ONLY
+    )
     install(
-        FILES ${CMAKE_CURRENT_BINARY_DIR}/__init__.py
-        DESTINATION "${EPHOTOSYNTHESIS_INSTALL_PYTHONDIR}"
+        FILES ${PYTHON_BUILD_DIR}/__init__.py
+        DESTINATION "${PYTHON_INSTALL_DIR}"
         COMPONENT Python
-        EXCLUDE_FROM_ALL
     )
 endif()

README.md

@@ -19,7 +19,7 @@ All of the packages required to build & run the library, tests, & documentation
 - [GoogleTest](https://google.github.io/googletest/) - (optional) needed to build the tests
 - [LCOV](https://wiki.documentfoundation.org/Development/Lcov) - (optional) needed to get test coverage
 
-### Building
+### Building the C++ library & executable
 This can be built using a conda environment. This way, the cmake should be able to find the boost and sundials dependencies automatically. When using conda to manage the dependencies:
 
 1. Be sure to activate the related env the next time after login.
@@ -37,6 +37,33 @@ cmake --build .
 cmake --install . (if desired)
 ```
 
+### Building the Python extension
+Similar to building the C++ library & executable, with the exception that the Python cmake target (pyPhotosynthesis) should be passed to the build command and the ``Python`` component should be specified in the install command if only the Python extension should be installed.
+
+```
+mkdir build
+cd build
+cmake .. -DBUILD_PYTHON:BOOL=ON
+cmake --build . --target pyPhotosynthesis
+cmake --install . --component Python (if desired)
+```
+
+The Python extension has the name ``ePhotosynthesis`` and can be used to run drivers from Python. E.g.
+
+```
+import ePhotosynthesis
+theVars = ePhotosynthesis.Variables()
+theVars.readParam("InputEvn.txt")
+theVars.readParam("InputATPCost.txt")
+theVars.readEnzymeAct("InputEnzyme.txt")
+theVars.readGRN("InputGRNC.txt")
+theVars.RUBISCOMETHOD = 2
+theVars.debuglevel = 0
+ePhotosynthesis.modules.PR.setRUBISCOTOTAL(3)
+drv = ePhotosynthesis.drivers.EPSDriver(theVars, 0, 1, 5000, 750, 1e-5, 1e-4, 1, 1 25.0)
+results = drv.run()
+```
+
 ### Documentation
 The documentation is not automatically built. To build the docs run the following from the build directory (requires Doxygen)
 ```
@@ -47,7 +74,7 @@ cmake --build . --target docs
 This will build the documentation and put the resulting files in the doc directory.
 
 ### Tests
-The tests are not automatically built. To build and run the tests, can be run the following from the build directory (requires GoogleTest)
+The tests are not automatically built. To build and run the tests, can be run the following from the build directory (requires GoogleTest). If ``-DBUILD_PYTHON:BOOL=ON`` is passed to the configuration step, the Python tests will also be run.
 ```
 cmake .. -DBUILD_TESTS:BOOL=ON
 cmake --build .

include/Variables.hpp

@@ -60,6 +60,12 @@ namespace ePhotosynthesis {
 #ifdef SUNDIALS_CONTEXT_REQUIRED
 extern std::shared_ptr<SUNContext> global_context; //!< Global context
 
+/**
+   Create a new SUNContext instance.
+   \returns SUNContext instance.
+*/
+SUNContext* create_sundials_context();
+
 /**
    Initialize the global SUNContext.
 */
@@ -69,7 +75,7 @@ void init_global_sundials_context();
    Destroy the global SUNContext.
  */
 void cleanup_global_sundials_context();
-  
+
 #endif // SUNDIALS_CONTEXT_REQUIRED
 
 /**
@@ -90,8 +96,10 @@ class Variables {
     /**
        Construct a new variables instance for a given sundials context
        \param[in, out] ctx Sundials context.
+       \param[in] flags Bitwise CONTEXT_FLAGS flags describing how the
+         context was/should be created.
     */
-    Variables(SUNContext* ctx);
+    Variables(SUNContext* ctx, const int flags = 0);
     /**
        Get the shared pointer to the Sundials context.
        \return Sundials context shared pointer.
@@ -111,6 +119,8 @@ class Variables {
        Construct a new variables instance for a given sundials context
     */
     Variables();
+    /** Destructor */
+    ~Variables();
     /**
        Copy constructor for a pointer to another variables instance.
          Some variables are not included in the default copy (e.g. alfa, 

include/drivers/CVodeMem.hpp

@@ -32,6 +32,10 @@ class CVodeMem {
       \param y Specialized data vector containing the inputs for the solver.
       */
     void cvode_mem_init(Driver* driver, realtype t0, N_Vector y);
+    /**
+       Destroy the ODE solver.
+     */
+    void cvode_mem_free();
 private:
     CVodeMem() {
         initialized = false;

include/modules/BF.hpp

@@ -110,7 +110,7 @@ class BF : public ModuleBase<BF, conditions::BFCondition> {
         FI_connect = false;
         PS_connect = false;
         RROEA_connect = false;
-        N = 0;
+        N = 1;
         TIME = 0.;
         conditions::BFCondition::reset();
     }

scripts/devtasks.py

@@ -229,17 +229,16 @@ def __init__(self, args, test_flags=None,
             pytest_flags += ['-v']
         if args.only_python:
             args.with_python = True
-        if args.with_python:
-            assert not args.dont_install
-            # kwargs.setdefault('env', {})
-            # kwargs['env'].setdefault(
-            #     'PYTHONPATH', os.environ.get('PYTHONPATH', ''))
-            # kwargs['env']['PYTHONPATH'] = os.pathsep.join([
-            #     x for x in
-            #     [args.install_dir,
-            #      kwargs['env']['PYTHONPATH']]
-            #     if x
-            # ])
+        if args.with_python and args.dont_install:
+            kwargs.setdefault('env', {})
+            kwargs['env'].setdefault(
+                'PYTHONPATH', os.environ.get('PYTHONPATH', ''))
+            kwargs['env']['PYTHONPATH'] = os.pathsep.join([
+                x for x in
+                [args.build_dir,
+                 kwargs['env']['PYTHONPATH']]
+                if x
+            ])
         if args.only_python:
             testdir = os.path.join(_source_dir, 'tests', 'python')
             cmds = [f"python -m pytest {' '.join(pytest_flags)} {testdir}"]

src/Variables.cpp

@@ -11,14 +11,19 @@
 #ifdef SUNDIALS_CONTEXT_REQUIRED
 std::shared_ptr<SUNContext> ePhotosynthesis::global_context(NULL);
 
+SUNContext* ePhotosynthesis::create_sundials_context() {
+    SUNContext* context = new SUNContext();
+    SUNErrCode error_code = SUNContext_Create(SUN_COMM_NULL, context);
+    if (error_code) {
+        throw std::runtime_error("SUNContext_Create failed: " +
+                                 std::string(SUNGetErrMsg(error_code)));
+    }
+    return context;
+}
+
 void ePhotosynthesis::init_global_sundials_context() {
     if (!global_context) {
-        SUNContext* context = new SUNContext();
-        SUNErrCode error_code = SUNContext_Create(SUN_COMM_NULL, context);
-        if (error_code) {
-            throw std::runtime_error("SUNContext_Create failed: " +
-                                     std::string(SUNGetErrMsg(error_code)));
-        }
+        SUNContext* context = create_sundials_context();
         global_context.reset(context);
         std::atexit(cleanup_global_sundials_context);
     }
@@ -37,11 +42,17 @@ using namespace ePhotosynthesis;
 
 #ifdef SUNDIALS_CONTEXT_REQUIRED
 
-Variables::Variables(SUNContext* ctx) : _context(), _context_flags(0) {
+Variables::Variables(SUNContext* ctx, const int flags) :
+  _context(), _context_flags(flags) {
     if (_context == nullptr) {
-        init_global_sundials_context();
-        _context = global_context;
-        _context_flags |= CONTEXT_FLAG_GLOBAL;
+        if (flags & CONTEXT_FLAG_GLOBAL) {
+            std::cerr << "Using global context" << std::endl;
+            init_global_sundials_context();
+            _context = global_context;
+            _context_flags |= CONTEXT_FLAG_GLOBAL;
+        } else {
+            _context.reset(create_sundials_context());
+        }
     } else {
         _context.reset(ctx);
     }
@@ -55,6 +66,13 @@ Variables::Variables(const Variables* other) :
   _context(other->_context), _context_flags(other->_context_flags) {
     *this = *other;
 }
+Variables::~Variables() {
+    if (!(_context_flags & CONTEXT_FLAG_GLOBAL)) {
+        if (_context.use_count() == 1)
+          SUNContext_Free(_context.get());
+        _context.reset();
+    }
+}
 #else // SUNDIALS_CONTEXT_REQUIRED
 Variables::Variables() {}
 Variables::Variables(const Variables& other) : Variables() {
@@ -63,6 +81,7 @@ Variables::Variables(const Variables& other) : Variables() {
 Variables::Variables(const Variables* other) : Variables() {
     *this = *other;
 }
+Variables::~Variables() {}
 #endif // SUNDIALS_CONTEXT_REQUIRED
 
 Variables* Variables::deepcopy() const {

src/drivers/CVodeMem.cpp

@@ -59,6 +59,14 @@ void CVodeMem::cvode_mem_init(Driver* driver, realtype t0, N_Vector y) {
     driver->cvode_mem = _cvode_mem;
 
 }
+void CVodeMem::cvode_mem_free() {
+    if (initialized) {
+        CVodeFree(&_cvode_mem);
+        delete data;
+        data = nullptr;
+        initialized = false;
+    }
+}
 
 CVodeMem::~CVodeMem() {
     if (initialized) {

src/drivers/driver.cpp

@@ -84,7 +84,7 @@ arr Driver::run() {
             y_ptr[i] = constraints[i];
         realtype t0 = start;
 
-        CVodeMem *cmem;
+        CVodeMem *cmem = nullptr;
         try {
             cmem = &CVodeMem::create();
             cmem->cvode_mem_init(this, t0, y);
@@ -160,6 +160,10 @@ arr Driver::run() {
 Driver::~Driver() {
     if (origVars != nullptr)
         delete origVars;
+    CVodeMem *cmem = nullptr;
+    cmem = &CVodeMem::create();
+    cmem->cvode_mem_free();
+    cvode_mem = nullptr;
 }
 
 int Driver::calculate(realtype t, N_Vector u, N_Vector u_dot, void *user_data) {

src/python/wrappers.cpp

@@ -137,28 +137,33 @@ void python::exportDrivers() {
     bp::scope driverScope = driverModule;
     bp::class_<std::vector<double> >("stl_vector_double")
             .def(bp::vector_indexing_suite<std::vector<double> >());
+#define ADD_DRIVER_METHODS(mod)                                         \
+    .def("run", &drivers::mod ## Driver::run)                           \
+        .def("setup", &drivers::mod ## Driver::setup)                   \
+        .def("getResults", &drivers::mod ## Driver::getResults)         \
+        .def_readwrite("abstol", &drivers::mod ## Driver::abstol)       \
+        .def_readwrite("reltol", &drivers::mod ## Driver::reltol)       \
+        .def_readwrite("start", &drivers::mod ## Driver::start)         \
+        .def_readwrite("step", &drivers::mod ## Driver::step)           \
+        .def_readwrite("endtime", &drivers::mod ## Driver::endtime)     \
+        .def_readwrite("initialStep", &drivers::mod ## Driver::initialStep) \
+        .def_readwrite("time", &drivers::mod ## Driver::time)           \
+        .def_readwrite("maxStep", &drivers::mod ## Driver::maxStep)     \
+        .def_readwrite("results", &drivers::mod ## Driver::results)
     bp::class_<DriverWrap, boost::noncopyable>("Driver", bp::no_init)
-            .def("run", &drivers::Driver::run)
-            .def("setup", bp::pure_virtual(&drivers::Driver::setup))
-            .def("getResults", bp::pure_virtual(&drivers::Driver::getResults))
-            .def("MB", bp::pure_virtual(&drivers::Driver::MB));
+        .def("run", &drivers::Driver::run)
+        .def("setup", bp::pure_virtual(&drivers::Driver::setup))
+        .def("getResults", bp::pure_virtual(&drivers::Driver::getResults))
+        .def("MB", bp::pure_virtual(&drivers::Driver::MB));
     bp::class_<drivers::EPSDriver, bp::bases<DriverWrap>, boost::noncopyable>("EPSDriver", bp::init<Variables*, double, double, double, int, double, double, std::size_t, double, double, bool>()[bp::with_custodian_and_ward_postcall<0,2>()])
-            .def("run", &drivers::EPSDriver::run)
-            .def("setup", &drivers::EPSDriver::setup)
-            .def("getResults", &drivers::EPSDriver::getResults);
+        ADD_DRIVER_METHODS(EPS);
     bp::class_<drivers::trDynaPSDriver, bp::bases<DriverWrap>, boost::noncopyable>("trDynaPSDriver", bp::init<Variables*, double, double, double, int, double, double, std::size_t, double, bool>()[bp::with_custodian_and_ward_postcall<0,2>()])
-            .def("run", &drivers::trDynaPSDriver::run)
-            .def("setup", &drivers::trDynaPSDriver::setup)
-            .def("getResults", &drivers::trDynaPSDriver::getResults);
+        ADD_DRIVER_METHODS(trDynaPS);
     bp::class_<drivers::DynaPSDriver, bp::bases<DriverWrap>, boost::noncopyable>("DynaPSDriver", bp::init<Variables*, double, double, double, int, double, double, std::size_t, double, bool>()[bp::with_custodian_and_ward_postcall<0,2>()])
-            .def("run", &drivers::DynaPSDriver::run)
-            .def("setup", &drivers::DynaPSDriver::setup)
-            .def("getResults", &drivers::DynaPSDriver::getResults);
+        ADD_DRIVER_METHODS(DynaPS);
     bp::class_<drivers::CMDriver, bp::bases<DriverWrap>, boost::noncopyable>("CMDriver", bp::init<Variables*, double, double, double, int, double, double, bool>()[bp::with_custodian_and_ward_postcall<0,2>()])
-            .def("run", &drivers::CMDriver::run)
-            .def("setup", &drivers::CMDriver::setup)
-            .def("getResults", &drivers::CMDriver::getResults);
-
+        ADD_DRIVER_METHODS(CM);
+#undef ADD_DRIVER_METHODS
 }
 
 #endif