python.cc
41def8729942master

python.cc
View Options

			#include "action_interface.hh"
			#include "communicator.hh"
			#include "compute_list.hh"
			#include "domain_multiscale.hh"
			#include "dumper_list.hh"
			#include "factory_multiscale.hh"
			#include "filter_interface.hh"
			#include "filter_list.hh"
			#include "geometry_list.hh"
			#include "geometry_manager.hh"
			#include "lib_continuum.hh"
			#include "lib_dd.hh"
			#include "lib_dumper.hh"
			#include "lib_filter.hh"
			#include "lib_geometry.hh"
			#include "lib_md.hh"
			#include "lib_stimulation.hh"
			#include "lm_common.hh"
			#include "lm_type_caster.hh"
			#include "stimulation_interface.hh"
			#include "stimulation_list.hh"
			#include <pybind11/eigen.h>
			#include <pybind11/pybind11.h>
			#include <pybind11/stl.h>

			namespace py = pybind11;
			using namespace libmultiscale;

			std::vector<std::string> fake_argv;
			std::vector<char *> c_argv;

			void loadModules() {
			// auto sys = py::module::import("sys");
			// auto argv = sys.attr("argv");
			// fake_argv = py::cast<std::vector<std::string>>(argv);
			// std::cout << "AAAA " << fake_argv.size() << std::endl;
			// for (auto &&v : fake_argv) {
			// std::cout << "AAAA " << &v[0] << std::endl;
			// c_argv.push_back(&v[0]);
			// }
			// loadModules(c_argv.size(), c_argv.data());
			loadModules(0, nullptr);
			create_seg_fault = false;
			}

			extern std::string lm_release_info;

			template <typename T2, typename T>
			void ModuleProperty(py::module &m, const char *n, T &var) {
			// setting a property
			// import the builtins and get the "property" python class

			auto property = py::module::import("builtins").attr("property");
			m.attr(n) = property(py::cpp_function([&]() { return var; }),
			py::cpp_function([&](T2 &a) { var = a; }));
			}

			#include "domain_lammps_dynamic.hh"

			template <typename Class>
			void declare_domain(py::module &m, const char *class_name) {

			py::class_<Class, DomainInterface, std::shared_ptr<Class>>(
			m, class_name, py::multiple_inheritance())
			.def(py::init<LMID, CommGroup &>())
			.def("init", [](Class &self) {
			self.checkAllKeywordsAreParsed();
			self.init();
			});
			}

			template <typename Class>
			void declare_geometry(py::module &m, const char *class_name) {

			py::class_<Class, Geometry, std::shared_ptr<Class>>(
			m, class_name, py::multiple_inheritance())
			.def(py::init<UInt, LMID>())
			.def("init", [](Class &self) {
			self.checkAllKeywordsAreParsed();
			self.init();
			});
			}

			template <typename Class>
			void declare_stimulation(py::module &m, const char *class_name) {

			py::class_<Class, StimulationInterface, std::shared_ptr<Class>>(
			m, class_name, py::multiple_inheritance())
			.def(py::init<LMID>())
			.def("init", [](Class &self) {
			self.checkAllKeywordsAreParsed();
			self.init();
			});
			}

			template <typename Class>
			void declare_compute(py::module &m, const char *class_name) {

			py::class_<Class, ComputeInterface, std::shared_ptr<Class>>(
			m, class_name, py::multiple_inheritance())
			.def(py::init<LMID>())
			.def("init", [](Class &self) {
			self.checkAllKeywordsAreParsed();
			self.init();
			});
			}

			template <typename Class>
			void declare_filter(py::module &m, const char *class_name) {

			py::class_<Class, FilterInterface, std::shared_ptr<Class>>(
			m, class_name, py::multiple_inheritance())
			.def(py::init<LMID>())
			.def("init", [](Class &self) {
			self.checkAllKeywordsAreParsed();
			self.init();
			});
			}

			template <typename Class>
			void declare_dumper(py::module &m, const char *class_name) {

			py::class_<Class, DumperInterface, std::shared_ptr<Class>>(
			m, class_name, py::multiple_inheritance())
			.def(py::init<LMID>())
			.def("init", [](Class &self) {
			self.checkAllKeywordsAreParsed();
			self.init();
			});
			}

			std::string clean_class_name(const std::string &arg) {
			std::string res = arg;

			res.erase(std::remove(res.begin(), res.end(), '<'), res.end());
			res.erase(std::remove(res.begin(), res.end(), '>'), res.end());
			return res;
			}

			PYBIND11_MODULE(pylibmultiscale, m) {
			m.doc() = "LibMultiScale python module";

			ModuleProperty<int>(m, "current_step", current_step);
			ModuleProperty<int>(m, "lm_my_proc_id", lm_my_proc_id);
			ModuleProperty<IntegrationSchemeStage>(m, "current_stage", current_stage);

			py::enum_<IntegrationSchemeStage>(m, "IntegrationSchemeStage")
			.value("NONE_STEP", NONE_STEP)
			.value("PRE_DUMP", PRE_DUMP)
			.value("PRE_STEP1", PRE_STEP1)
			.value("PRE_STEP2", PRE_STEP2)
			.value("PRE_STEP3", PRE_STEP3)
			.value("PRE_STEP4", PRE_STEP4)
			.value("PRE_STEP5", PRE_STEP5)
			.value("PRE_STEP6", PRE_STEP6)
			.value("PRE_STEP7", PRE_STEP7)
			.value("PRE_FATAL", PRE_FATAL)
			.value("ALL_STEP", ALL_STEP)
			.export_values();

			py::enum_<CouplingStage>(m, "CouplingStage")
			.value("COUPLING_STEP1", COUPLING_STEP1)
			.value("COUPLING_STEP2", COUPLING_STEP2)
			.value("COUPLING_STEP3", COUPLING_STEP3)
			.value("COUPLING_STEP4", COUPLING_STEP4)
			.value("COUPLING_STEP5", COUPLING_STEP5)
			.value("COUPLING_STEP6", COUPLING_STEP6)
			.value("COUPLING_STEP7", COUPLING_STEP7)
			.export_values();

			m.def("loadModules", &::loadModules,
			"Load all the module dependencies of libmultiscale");

			m.def("closeModules", &closeModules,
			"close all the module dependencies of libmultiscale");

			m.attr("release_info") = py::cast(lm_release_info);

			py::class_<DomainMultiScale>(m, "DomainMultiScale")
			.def("getManager", &DomainMultiScale::getManager,
			py::return_value_policy::reference)
			.def("build", &DomainMultiScale::build)
			.def("getObject", &DomainMultiScale::getObject,
			py::return_value_policy::reference)
			.def("getTimeStep", &DomainMultiScale::getTimeStep)
			.def("performStep1", &DomainMultiScale::performStep1)
			.def("performStep2", &DomainMultiScale::performStep2)
			.def("performStep3", &DomainMultiScale::performStep3)
			.def("coupling", &DomainMultiScale::coupling)
			.def("destroy", &DomainMultiScale::destroy)
			.def("addObject", py::overload_cast<std::shared_ptr<DomainInterface>>(
			&DomainMultiScale::addObject));

			py::class_<ActionManager>(m, "ActionManager")
			.def("getManager",
			[]() -> ActionManager & { return ActionManager::getManager(); },
			py::return_value_policy::reference)
			.def("getManager",
			[](UInt dim) -> ActionManager & {
			return ActionManager::getManager(dim);
			},
			py::return_value_policy::reference)
			.def("action", &ActionManager::action)
			.def("destroy", &ActionManager::destroy)
			.def("addObject", py::overload_cast<std::shared_ptr<ActionInterface>>(
			&ActionManager::addObject));

			py::class_<FilterManager>(m, "FilterManager")
			.def("getManager",
			[]() -> FilterManager & { return FilterManager::getManager(); },
			py::return_value_policy::reference)
			.def("getManager",
			[](UInt dim) -> FilterManager & {
			return FilterManager::getManager(dim);
			},
			py::return_value_policy::reference)
			.def("action", &FilterManager::action)
			.def("destroy", &FilterManager::destroy);

			py::class_<CommGroup>(m, "CommGroup")
			.def(py::init<const LMID &, int, UInt>());

			py::class_<Communicator>(m, "Communicator")
			.def("getCommunicator", &Communicator::getCommunicator,
			py::return_value_policy::reference)
			.def("getNumberFreeProcs", &Communicator::getNumberFreeProcs)
			.def("addGroup", &Communicator::addGroup)
			.def("getGroup", &Communicator::getGroup);

			m.attr("prologue") = py::module::import("prologue");

			py::class_<GeometryManager>(m, "GeometryManager")
			.def("getManager", &GeometryManager::getManager,
			py::return_value_policy::reference)
			.def("addGeometry", &GeometryManager::addGeometry)
			.def("destroy", &GeometryManager::destroy);

			py::class_<Parsable, std::shared_ptr<Parsable>>(m, "Parsable")
			.def("getPossibleKeywords", &Parsable::getPossibleKeywords)
			.def("getParam", &Parsable::getParam<py::object>)
			.def("setParam",
			[](Parsable &self, const std::string &keyword, py::object &val) {
			self.setParam<py::object>(keyword, val);
			})
			.def_property_readonly("params", [m](Parsable &self) {
			return m.attr("prologue").attr("LMParameters")(self);
			});

			py::class_<DomainInterface, Parsable, std::shared_ptr<DomainInterface>>(
			m, "DomainInterface", py::multiple_inheritance())
			.def("performStep1", &DomainInterface::performStep1)
			.def("performStep2", &DomainInterface::performStep2)
			.def("performStep3", &DomainInterface::performStep3)
			.def("performStep4", &DomainInterface::performStep4)
			.def("performStep5", &DomainInterface::performStep5);

			py::class_<Geometry, Parsable, std::shared_ptr<Geometry>>(
			m, "Geometry", py::multiple_inheritance());

			py::class_<ActionInterface, Parsable, std::shared_ptr<ActionInterface>>(
			m, "ActionInterface", py::multiple_inheritance())
			.def("action", &StimulationInterface::action);

			py::class_<StimulationInterface, ActionInterface,
			std::shared_ptr<StimulationInterface>>(m, "StimulationInterface",
			py::multiple_inheritance())
			.def("stimulate", &StimulationInterface::stimulate);

			py::class_<FilterInterface, ActionInterface,
			std::shared_ptr<FilterInterface>>(m, "FilterInterface",
			py::multiple_inheritance())
			.def("build", &FilterInterface::build);

			py::class_<DumperInterface, ActionInterface,
			std::shared_ptr<DumperInterface>>(m, "DumperInterface",
			py::multiple_inheritance())
			.def("dump", &DumperInterface::dump);

			py::class_<ComputeInterface, FilterInterface,
			std::shared_ptr<ComputeInterface>>(m, "ComputeInterface",
			py::multiple_inheritance())
			.def("compute", &ComputeInterface::compute)
			.def("getOutputs", &ComputeInterface::getOutputs,
			py::return_value_policy::reference)
			.def("getArray", [](ComputeInterface &self) {
			const UInt Dim = self.getDim();
			UInt sz = self.size() / Dim;
			if (sz == 0)
			return py::object(py::none());

			Eigen::Map<
			Eigen::Array<Real, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>>
			_array(&self[0], sz, Dim);
			return py::cast(_array);
			});

			py::class_<ContainerArray<Real>>(m, "ContainerArrayReal",
			py::multiple_inheritance());

			py::class_<ArgumentContainer>(m, "ArgumentContainer");

			#define PYTHON_DOMAIN(n, data, obj) \
			{ \
			using _class = BOOST_PP_TUPLE_ELEM(3, 0, obj); \
			std::string domain_name = \
			clean_class_name(BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(3, 0, obj))); \
			declare_domain<_class>(m, domain_name.c_str()); \
			}

			BOOST_PP_SEQ_FOR_EACH(PYTHON_DOMAIN, f, LIST_ATOM_MODEL);
			BOOST_PP_SEQ_FOR_EACH(PYTHON_DOMAIN, f, LIST_DD_MODEL);
			BOOST_PP_SEQ_FOR_EACH(PYTHON_DOMAIN, f, LIST_CONTINUUM_MODEL);

			#undef DECLARE_PYTHON

			#define PYTHON_GEOMETRY(n, data, obj) \
			{ \
			using _class = BOOST_PP_TUPLE_ELEM(2, 0, obj); \
			std::string geometry_name = \
			clean_class_name(BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(2, 0, obj))); \
			\
			declare_geometry<_class>(m, geometry_name.c_str()); \
			}

			BOOST_PP_SEQ_FOR_EACH(PYTHON_GEOMETRY, f, LIST_GEOMETRY);
			#undef PYTHON_GEOMETRY

			#define PYTHON_STIMULATION(n, data, obj) \
			{ \
			using _class = BOOST_PP_TUPLE_ELEM(2, 0, obj); \
			std::string stimulation_name = \
			clean_class_name(BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(2, 0, obj))); \
			\
			declare_stimulation<_class>(m, stimulation_name.c_str()); \
			}

			BOOST_PP_SEQ_FOR_EACH(PYTHON_STIMULATION, f, LIST_STIMULATION);
			#undef PYTHON_STIMULATION

			#define PYTHON_COMPUTE(n, data, obj) \
			{ \
			using _class = BOOST_PP_TUPLE_ELEM(2, 0, obj); \
			std::string compute_name = \
			clean_class_name(BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(2, 0, obj))); \
			\
			declare_compute<_class>(m, compute_name.c_str()); \
			}
			BOOST_PP_SEQ_FOR_EACH(PYTHON_COMPUTE, f, LIST_COMPUTE);
			#undef PYTHON_COMPUTE

			#define PYTHON_FILTER(n, data, obj) \
			{ \
			using _class = BOOST_PP_TUPLE_ELEM(2, 0, obj); \
			std::string filter_name = \
			clean_class_name(BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(2, 0, obj))); \
			\
			declare_filter<_class>(m, filter_name.c_str()); \
			}
			BOOST_PP_SEQ_FOR_EACH(PYTHON_FILTER, f, LIST_FILTER);
			#undef PYTHON_FILTER

			#define PYTHON_DUMPER(n, data, obj) \
			{ \
			using _class = BOOST_PP_TUPLE_ELEM(2, 0, obj); \
			std::string filter_name = \
			clean_class_name(BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(2, 0, obj))); \
			\
			declare_dumper<_class>(m, filter_name.c_str()); \
			}
			BOOST_PP_SEQ_FOR_EACH(PYTHON_DUMPER, f, LIST_DUMPER);
			#undef PYTHON_DUMPER
			}

libmultiscale/python/python.cc41def8729942master

python.ccView Options

libmultiscale/python/python.cc
41def8729942master

python.cc
View Options