diff --git a/python/python.cc b/python/python.cc
index a5e71fe..808e3a8 100644
--- a/python/python.cc
+++ b/python/python.cc
@@ -1,388 +1,386 @@
 #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();
 
   py::enum_<DOFType>(m, "DOFType")
       .value("dt_local_master", dt_local_master)
       .value("dt_local_slave", dt_local_slave)
       .value("dt_local", dt_local)
       .value("dt_ghost", dt_ghost)
       .value("dt_all", dt_all)
       .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_static("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_static("getManager", py::overload_cast<>(&ActionManager::getManager),
                   py::return_value_policy::reference)
       .def_static("getManager",
                   py::overload_cast<UInt>(&ActionManager::getManager),
                   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_static("getManager", py::overload_cast<>(&FilterManager::getManager),
                   py::return_value_policy::reference)
       .def_static("getManager",
                   py::overload_cast<UInt>(&FilterManager::getManager),
                   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_static("getManager", &GeometryManager::getManager,
-           py::return_value_policy::reference)
+                  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("getOutput", &ComputeInterface::getOutput,
            py::return_value_policy::reference)
       .def("getArray", &ComputeInterface::getArray,
            py::return_value_policy::reference)
       .def("getCastedOutput",
            [](ComputeInterface &self, bool eval, std::string name) {
              return self.getCastedOutput<ContainerArray<Real>>(eval, name);
            },
            py::arg("eval") = true, py::arg("name") = "output");
 
   py::class_<ContainerArray<Real>>(m, "ContainerArrayReal",
                                    py::multiple_inheritance())
       .def_readwrite("name_computed", &ContainerArray<Real>::name_computed)
       .def("getDim", &ContainerArray<Real>::getDim)
       .def("size", &ContainerArray<Real>::size, py::arg("dt") = dt_local)
       .def("to_array", [](ContainerArray<Real> &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_<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
 }