bindings.cpp

Go to the documentation of this file.

#include <pybind11/pybind11.h>
#include <pybind11/stl.h> // Needed for vectors, maps, sets, strings
#include <pybind11/stl_bind.h> // Needed for binding std::vector, std::map etc if needed directly
#include <pybind11/numpy.h>
 
#include <string>
#include "bindings.h"
 
#include "approx8.h"
#include "network.h"
 
namespace py = pybind11;
 
 
void register_network_bindings(pybind11::module &network_submodule) {
    py::enum_<serif::network::NetworkFormat>(network_submodule, "NetworkFormat")
        .value("APPROX8", serif::network::NetworkFormat::APPROX8)
        .value("UNKNOWN", serif::network::NetworkFormat::UNKNOWN)
        .def("__str__", [](const serif::network::NetworkFormat format) {
            return serif::network::FormatStringLookup[format];
        });
 
    py::class_<serif::network::NetIn>(network_submodule, "NetIn")
        .def(py::init<>())
        .def_readwrite("composition", &serif::network::NetIn::composition)
        .def_readwrite("tMax", &serif::network::NetIn::tMax)
        .def_readwrite("dt0", &serif::network::NetIn::dt0)
        .def_readwrite("temperature", &serif::network::NetIn::temperature)
        .def_readwrite("density", &serif::network::NetIn::density)
        .def_readwrite("energy", &serif::network::NetIn::energy)
        .def("__repr__", [](const serif::network::NetIn &netIn) {
            std::stringstream ss;
            ss << "NetIn(composition=" << netIn.composition
               << ", tMax=" << netIn.tMax
               << ", dt0=" << netIn.dt0
               << ", temperature=" << netIn.temperature
               << ", density=" << netIn.density
               << ", energy=" << netIn.energy << ")";
            return ss.str();
        });
 
    py::class_<serif::network::NetOut>(network_submodule, "NetOut")
        .def_readonly("composition", &serif::network::NetOut::composition)
        .def_readonly("num_steps", &serif::network::NetOut::num_steps)
        .def_readonly("energy", &serif::network::NetOut::energy)
        .def("__repr__", [](const serif::network::NetOut &netOut) {
            std::stringstream ss;
            ss << "NetOut(composition=" << netOut.composition
               << ", num_steps=" << netOut.num_steps
               << ", energy=" << netOut.energy << ")";
            return ss.str();
        });
 
    py::class_<serif::network::Network>(network_submodule, "Network")
        .def(py::init<serif::network::NetworkFormat>(), py::arg("format"))
        .def("evaluate", &serif::network::Network::evaluate, py::arg("netIn"))
        .def("getFormat", &serif::network::Network::getFormat)
        .def("setFormat", &serif::network::Network::setFormat, py::arg("format"))
        .def("__repr__", [](const serif::network::Network &network) {
            std::stringstream ss;
            ss << "Network(format=" << serif::network::FormatStringLookup[network.getFormat()] << ")";
            return ss.str();
        });
 
    auto approx8Module = network_submodule.def_submodule("approx8", "Approx8 nuclear reaction network module");
    register_approx8_bindings(approx8Module);
 
}
 
void register_approx8_bindings(pybind11::module &network_submodule) {
    using namespace serif::network::approx8;
 
    py::class_<vec7>(network_submodule, "vec7")
    .def("__getitem__", [](const vec7 &v, const size_t i) {
        if (i >= v.size()) throw py::index_error();
        return v[i];
    })
    .def("__setitem__", [](vec7 &v, const size_t i, const double value) {
        if (i >= v.size()) throw py::index_error();
        v[i] = value;
    })
    .def("__len__", [](const vec7 &v) { return v.size(); })
    .def("__repr__", [](const vec7 &v) {
        std::stringstream ss;
        ss << "vec7(";
        for (size_t i = 0; i < v.size(); ++i) {
            ss << v[i];
            if (i < v.size() - 1) ss << ", ";
        }
        ss << ")";
        return ss.str();
    });
 
    network_submodule.def("sum_product", &sum_product, "Find the sum of the element wise product of two vec7 arrays", py::arg("a"), py::arg("b"));
    network_submodule.def("get_T9_array", &get_T9_array, "Return an array of T9 terms for the nuclear reaction rate fit", py::arg("T"));
    network_submodule.def("rate_fit", &rate_fit, "Evaluate the nuclear reaction rate given the T9 array and coefficients", py::arg("T9"), py::arg("coef"));
    network_submodule.def("pp_rate", &pp_rate, "Calculate the rate for the reaction p + p -> d", py::arg("T9"));
    network_submodule.def("dp_rate", &dp_rate, "Calculate the rate for the reaction p + d -> he3", py::arg("T9"));
    network_submodule.def("he3he3_rate", &he3he3_rate, "Calculate the rate for the reaction he3 + he3 -> he4 + 2p", py::arg("T9"));
    network_submodule.def("he3he4_rate", &he3he4_rate, "Calculate the rate for the reaction he3(he3,2p)he4", py::arg("T9"));
    network_submodule.def("triple_alpha_rate", &triple_alpha_rate, "Calculate the rate for the reaction he4 + he4 + he4 -> c12", py::arg("T9"));
    network_submodule.def("c12p_rate", &c12p_rate, "Calculate the rate for the reaction c12 + p -> n13", py::arg("T9"));
    network_submodule.def("c12a_rate", &c12a_rate, "Calculate the rate for the reaction c12 + he4 -> o16", py::arg("T9"));
    network_submodule.def("n14p_rate", &n14p_rate, "Calculate the rate for the reaction n14(p,g)o15 - o15 + p -> c12", py::arg("T9"));
    network_submodule.def("n14a_rate", &n14a_rate, "Calculate the rate for the reaction n14(a,g)f18 assumed to go on to ne20", py::arg("T9"));
    network_submodule.def("n15pa_rate", &n15pa_rate, "Calculate the rate for the reaction n15(p,a)c12 (CNO I)", py::arg("T9"));
    network_submodule.def("n15pg_rate", &n15pg_rate, "Calculate the rate for the reaction n15(p,g)o16 (CNO II)", py::arg("T9"));
    network_submodule.def("n15pg_frac", &n15pg_frac, "Calculate the fraction for the reaction n15(p,g)o16", py::arg("T9"));
    network_submodule.def("o16p_rate", &o16p_rate, "Calculate the rate for the reaction o16(p, g)f17 then f17 -> o17(p,a)n14", py::arg("T9"));
    network_submodule.def("o16a_rate", &o16a_rate, "Calculate the rate for the reaction o16(a,g)ne20", py::arg("T9"));
    network_submodule.def("ne20a_rate", &ne20a_rate, "Calculate the rate for the reaction ne20(a,g)mg24", py::arg("T9"));
    network_submodule.def("c12c12_rate", &c12c12_rate, "Calculate the rate for the reaction c12(c12,a)ne20", py::arg("T9"));
    network_submodule.def("c12o16_rate", &c12o16_rate, "Calculate the rate for the reaction c12(o16,a)mg24", py::arg("T9"));
 
    py::class_<Approx8Network>(network_submodule, "Approx8Network")
        .def(py::init<>())
        .def("evaluate", &Approx8Network::evaluate, py::arg("netIn"), "Evaluate the Approx8 nuclear reaction network with the given input")
        .def("setStiff", &Approx8Network::setStiff, py::arg("stiff"), "Set whether to use a stiff solver or not")
        .def("isStiff", &Approx8Network::isStiff, "Get whether the network is set to use a stiff solver or not")
        .def("__repr__", [](const Approx8Network &network) {
            std::stringstream ss;
            ss << "Approx8Network(stiff=" << (network.isStiff() ? "True" : "False") << ")";
            return ss.str();
        });
}