diff --git a/python/py_akantu_pybind11_compatibility.hh b/python/py_akantu_pybind11_compatibility.hh
new file mode 100644
index 000000000..ea512ea51
--- /dev/null
+++ b/python/py_akantu_pybind11_compatibility.hh
@@ -0,0 +1,11 @@
+#ifndef PY_AKANTU_PYBIND11_COMPATIBILITY_HH_
+#define PY_AKANTU_PYBIND11_COMPATIBILITY_HH_
+
+#if not defined(PYBIND11_OVERRIDE)
+#define PYBIND11_OVERRIDE PYBIND11_OVERLOAD
+#define PYBIND11_OVERRIDE_NAME PYBIND11_OVERLOAD_NAME
+#define PYBIND11_OVERRIDE_PURE PYBIND11_OVERLOAD_PURE
+#define PYBIND11_OVERRIDE_PURE_NAME PYBIND11_OVERLOAD_PURE_NAME
+#endif
+
+#endif // PY_AKANTU_PYBIND11_COMPATIBILITY_HH_
diff --git a/python/py_boundary_conditions.cc b/python/py_boundary_conditions.cc
index 892ec0b84..9db4b44b5 100644
--- a/python/py_boundary_conditions.cc
+++ b/python/py_boundary_conditions.cc
@@ -1,97 +1,98 @@
 /* -------------------------------------------------------------------------- */
 #include "py_boundary_conditions.hh"
 #include "py_aka_array.hh"
+#include "py_akantu_pybind11_compatibility.hh"
 /* -------------------------------------------------------------------------- */
 #include <boundary_condition_functor.hh>
 /* -------------------------------------------------------------------------- */
-//#include <pybind11/operators.h>
 #include <pybind11/pybind11.h>
-//#include <pybind11/stl.h>
 /* -------------------------------------------------------------------------- */
 namespace py = pybind11;
 
 namespace akantu {
 
-/* -------------------------------------------------------------------------- */
-
-template <typename daughter = BC::Dirichlet::DirichletFunctor>
-class PyDirichletFunctor : public daughter {
-public:
-  /* Inherit the constructors */
-  using daughter::daughter;
-
-  /* Trampoline (need one for each virtual function) */
-  void operator()(UInt node, Vector<bool> & flags, Vector<Real> & primal,
-                  const Vector<Real> & coord) const override {
-    // NOLINTNEXTLINE
-    PYBIND11_OVERLOAD_NAME(void, daughter, "__call__", operator(), node, flags,
-                           primal, coord);
-  }
-};
-/* -------------------------------------------------------------------------- */
-
-template <typename daughter = BC::Neumann::NeumannFunctor>
-class PyNeumannFunctor : public daughter {
-public:
-  /* Inherit the constructors */
-  using daughter::daughter;
-
-  /* Trampoline (need one for each virtual function) */
-  void operator()(const IntegrationPoint & quad_point, Vector<Real> & dual,
-                  const Vector<Real> & coord,
-                  const Vector<Real> & normals) const override {
-    // NOLINTNEXTLINE
-    PYBIND11_OVERLOAD_PURE_NAME(void, daughter, "__call__", operator(),
-                                quad_point, dual, coord, normals);
+namespace {
+  /* ------------------------------------------------------------------------ */
+  template <typename daughter = BC::Dirichlet::DirichletFunctor>
+  class PyDirichletFunctor : public daughter {
+  public:
+    /* Inherit the constructors */
+    using daughter::daughter;
+
+    /* Trampoline (need one for each virtual function) */
+    void operator()(UInt node, Vector<bool> & flags, Vector<Real> & primal,
+                    const Vector<Real> & coord) const override {
+      // NOLINTNEXTLINE
+      PYBIND11_OVERRIDE_NAME(void, daughter, "__call__", operator(), node,
+                             flags, primal, coord);
+    }
+  };
+
+  /* ------------------------------------------------------------------------ */
+  template <typename daughter = BC::Neumann::NeumannFunctor>
+  class PyNeumannFunctor : public daughter {
+  public:
+    /* Inherit the constructors */
+    using daughter::daughter;
+
+    /* Trampoline (need one for each virtual function) */
+    void operator()(const IntegrationPoint & quad_point, Vector<Real> & dual,
+                    const Vector<Real> & coord,
+                    const Vector<Real> & normals) const override {
+      // NOLINTNEXTLINE
+      PYBIND11_OVERRIDE_PURE_NAME(void, daughter, "__call__", operator(),
+                                  quad_point, dual, coord, normals);
+    }
+  };
+
+  /* ------------------------------------------------------------------------ */
+  template <typename Functor, typename Constructor>
+  decltype(auto) register_dirichlet_functor(py::module mod, const char * name,
+                                            Constructor && cons) {
+    py::class_<Functor, PyDirichletFunctor<Functor>,
+               BC::Dirichlet::DirichletFunctor>(mod, name)
+        .def(cons);
   }
-};
 
-/* -------------------------------------------------------------------------- */
-
-template <typename Functor, typename Constructor>
-decltype(auto) register_dirichlet_functor(py::module mod, const char * name,
+  /* ------------------------------------------------------------------------ */
+  template <typename Functor, typename Constructor>
+  decltype(auto) register_neumann_functor(py::module mod, const char * name,
                                           Constructor && cons) {
-  py::class_<Functor, PyDirichletFunctor<Functor>,
-             BC::Dirichlet::DirichletFunctor>(mod, name)
-      .def(cons);
-}
-template <typename Functor, typename Constructor>
-decltype(auto) register_neumann_functor(py::module mod, const char * name,
-                                        Constructor && cons) {
-  py::class_<Functor, PyNeumannFunctor<Functor>, BC::Neumann::NeumannFunctor>(
-      mod, name)
-      .def(cons);
-}
+    py::class_<Functor, PyNeumannFunctor<Functor>, BC::Neumann::NeumannFunctor>(
+        mod, name)
+        .def(cons);
+  }
+} // namespace
 
 /* -------------------------------------------------------------------------- */
 void register_boundary_conditions(py::module & mod) {
 
   py::class_<BC::Functor>(mod, "BCFunctor");
   py::class_<BC::Dirichlet::DirichletFunctor, PyDirichletFunctor<>,
              BC::Functor>(mod, "DirichletFunctor")
       .def(py::init())
       .def(py::init<SpatialDirection>());
 
   py::class_<BC::Neumann::NeumannFunctor, PyNeumannFunctor<>, BC::Functor>(
       mod, "NeumannFunctor")
       .def(py::init());
 
   register_dirichlet_functor<BC::Dirichlet::FixedValue>(
       mod, "FixedValue", py::init<Real, BC::Axis>());
 
   register_dirichlet_functor<BC::Dirichlet::IncrementValue>(
       mod, "IncrementValue", py::init<Real, BC::Axis>());
 
   register_dirichlet_functor<BC::Dirichlet::Increment>(
       mod, "Increment", py::init<Vector<Real> &>());
 
   register_neumann_functor<BC::Neumann::FromHigherDim>(
       mod, "FromHigherDim", py::init<Matrix<Real> &>());
 
   register_neumann_functor<BC::Neumann::FromSameDim>(
       mod, "FromSameDim", py::init<Vector<Real> &>());
 
   register_neumann_functor<BC::Neumann::FreeBoundary>(mod, "FreeBoundary",
                                                       py::init());
 }
 } // namespace akantu
diff --git a/python/py_material.cc b/python/py_material.cc
index e374fe7d9..2d074e8c0 100644
--- a/python/py_material.cc
+++ b/python/py_material.cc
@@ -1,182 +1,178 @@
 /* -------------------------------------------------------------------------- */
+#include "py_akantu_pybind11_compatibility.hh"
 #include "py_aka_array.hh"
 /* -------------------------------------------------------------------------- */
 #include <solid_mechanics_model.hh>
 #if defined(AKANTU_COHESIVE_ELEMENT)
 #include <solid_mechanics_model_cohesive.hh>
 #endif
 #include <material_elastic.cc>
 /* -------------------------------------------------------------------------- */
 #include <pybind11/operators.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 /* -------------------------------------------------------------------------- */
 namespace py = pybind11;
 /* -------------------------------------------------------------------------- */
 
-#if not defined(PYBIND11_OVERRIDE)
-#define PYBIND11_OVERRIDE PYBIND11_OVERLOAD
-#define PYBIND11_OVERRIDE_PURE PYBIND11_OVERLOAD_PURE
-#endif
-
 namespace akantu {
 
 namespace {
   template <typename _Material> class PyMaterial : public _Material {
   public:
     /* Inherit the constructors */
     using _Material::_Material;
 
     ~PyMaterial() override = default;
 
     void initMaterial() override {
       // NOLINTNEXTLINE
       PYBIND11_OVERRIDE(void, _Material, initMaterial, );
     };
     void computeStress(ElementType el_type,
                        GhostType ghost_type = _not_ghost) override {
       // NOLINTNEXTLINE
       PYBIND11_OVERRIDE_PURE(void, _Material, computeStress, el_type,
                              ghost_type);
     }
     void computeTangentModuli(ElementType el_type, Array<Real> & tangent_matrix,
                               GhostType ghost_type = _not_ghost) override {
       // NOLINTNEXTLINE
       PYBIND11_OVERRIDE(void, _Material, computeTangentModuli, el_type,
                         tangent_matrix, ghost_type);
     }
 
     void computePotentialEnergy(ElementType el_type) override {
       // NOLINTNEXTLINE
       PYBIND11_OVERRIDE(void, _Material, computePotentialEnergy, el_type);
     }
 
     Real getPushWaveSpeed(const Element & element) const override {
       // NOLINTNEXTLINE
       PYBIND11_OVERRIDE(Real, _Material, getPushWaveSpeed, element);
     }
 
     Real getShearWaveSpeed(const Element & element) const override {
       // NOLINTNEXTLINE
       PYBIND11_OVERRIDE(Real, _Material, getShearWaveSpeed, element);
     }
 
     template <typename T>
     void registerInternal(const std::string & name, UInt nb_component) {
       auto && internal = std::make_shared<InternalField<T>>(name, *this);
       AKANTU_DEBUG_INFO("alloc internal " << name << " "
                                           << &this->internals[name]);
 
       internal->initialize(nb_component);
       this->internals[name] = internal;
     }
 
   protected:
     std::map<std::string, std::shared_ptr<ElementTypeMapBase>> internals;
   };
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   void register_internal_field(py::module & mod, const std::string & name) {
     py::class_<InternalField<T>, ElementTypeMapArray<T>,
                std::shared_ptr<InternalField<T>>>(
         mod, ("InternalField" + name).c_str());
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename _Material>
   decltype(auto) register_material_classes(py::module & mod,
                                            const std::string & name) {
     return py::class_<_Material, Material, Parsable, PyMaterial<_Material>>(
                mod, name.c_str(), py::multiple_inheritance())
         .def(py::init<SolidMechanicsModel &, const ID &>());
   }
 } // namespace
 
 /* -------------------------------------------------------------------------- */
 void register_material(py::module & mod) {
   py::class_<MaterialFactory>(mod, "MaterialFactory")
       .def_static(
           "getInstance",
           []() -> MaterialFactory & { return Material::getFactory(); },
           py::return_value_policy::reference)
       .def("registerAllocator",
            [](MaterialFactory & self, const std::string id, py::function func) {
              self.registerAllocator(
                  id,
                  [func, id](UInt dim, const ID & /*unused*/,
                             SolidMechanicsModel & model,
                             const ID & option) -> std::unique_ptr<Material> {
                    py::object obj = func(dim, id, model, option);
                    auto & ptr = py::cast<Material &>(obj);
 
                    obj.release();
                    return std::unique_ptr<Material>(&ptr);
                  });
            })
       .def("getPossibleAllocators", &MaterialFactory::getPossibleAllocators);
 
   register_internal_field<Real>(mod, "Real");
   register_internal_field<UInt>(mod, "UInt");
 
   py::class_<Material, Parsable, PyMaterial<Material>>(
       mod, "Material", py::multiple_inheritance())
       .def(py::init<SolidMechanicsModel &, const ID &>())
       .def(
           "getGradU",
           [](Material & self, ElementType el_type,
              GhostType ghost_type = _not_ghost) -> decltype(auto) {
             return self.getGradU(el_type, ghost_type);
           },
           py::arg("el_type"), py::arg("ghost_type") = _not_ghost,
           py::return_value_policy::reference)
       .def(
           "getStress",
           [](Material & self, ElementType el_type,
              GhostType ghost_type = _not_ghost) -> decltype(auto) {
             return self.getStress(el_type, ghost_type);
           },
           py::arg("el_type"), py::arg("ghost_type") = _not_ghost,
           py::return_value_policy::reference)
       .def(
           "getPotentialEnergy",
           [](Material & self, ElementType el_type) -> decltype(auto) {
             return self.getPotentialEnergy(el_type);
           },
           py::return_value_policy::reference)
       .def("initMaterial", &Material::initMaterial)
       .def("getModel", &Material::getModel)
       .def("registerInternalReal",
            [](Material & self, const std::string & name, UInt nb_component) {
              return dynamic_cast<PyMaterial<Material> &>(self)
                  .registerInternal<Real>(name, nb_component);
            })
       .def("registerInternalUInt",
            [](Material & self, const std::string & name, UInt nb_component) {
              return dynamic_cast<PyMaterial<Material> &>(self)
                  .registerInternal<UInt>(name, nb_component);
            })
       .def(
           "getInternalReal",
           [](Material & self, const ID & id) -> decltype(auto) {
             return self.getInternal<Real>(id);
           },
           py::arg("id"), py::return_value_policy::reference)
       .def(
           "getInternalUInt",
           [](Material & self, const ID & id) -> decltype(auto) {
             return self.getInternal<UInt>(id);
           },
           py::arg("id"), py::return_value_policy::reference)
       .def(
           "getElementFilter",
           [](Material & self) -> decltype(auto) {
             return self.getElementFilter();
           },
           py::return_value_policy::reference);
 
   register_material_classes<MaterialElastic<2>>(mod, "MaterialElastic2D");
   register_material_classes<MaterialElastic<3>>(mod, "MaterialElastic3D");
 }
 
 } // namespace akantu
diff --git a/python/py_material_selector.cc b/python/py_material_selector.cc
index f05d1d244..81a58bc43 100644
--- a/python/py_material_selector.cc
+++ b/python/py_material_selector.cc
@@ -1,85 +1,86 @@
+/* -------------------------------------------------------------------------- */
 #include "py_material_selector.hh"
-
+#include "py_akantu_pybind11_compatibility.hh"
 /* -------------------------------------------------------------------------- */
 #include <material_selector.hh>
 #include <solid_mechanics_model.hh>
 #if defined(AKANTU_COHESIVE_ELEMENT)
 #include <material_selector_cohesive.hh>
 #include <solid_mechanics_model_cohesive.hh>
 #endif
 /* -------------------------------------------------------------------------- */
 #include <pybind11/operators.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 /* -------------------------------------------------------------------------- */
 namespace py = pybind11;
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 namespace {
   template <class Base = MaterialSelector>
   class PyMaterialSelector : public Base {
   public:
     /* Inherit the constructors */
     using Base::Base;
 
     ~PyMaterialSelector() override = default;
 
     UInt operator()(const Element & element) override {
       // NOLINTNEXTLINE
       PYBIND11_OVERRIDE_NAME(UInt, MaterialSelector, "__call__", operator(),
                              element);
     }
   };
 
   template <class MaterialSelectorDaughter>
   decltype(auto) register_material_selectors(py::module & mod,
                                              const std::string & class_name) {
     return py::class_<MaterialSelectorDaughter, MaterialSelector,
                       PyMaterialSelector<MaterialSelectorDaughter>,
                       std::shared_ptr<MaterialSelectorDaughter>>(
         mod, class_name.c_str());
   }
 } // namespace
 
 void register_material_selector(py::module & mod) {
-    py::class_<MaterialSelector, PyMaterialSelector<>,
-               std::shared_ptr<MaterialSelector>>(mod, "MaterialSelector")
+  py::class_<MaterialSelector, PyMaterialSelector<>,
+             std::shared_ptr<MaterialSelector>>(mod, "MaterialSelector")
       .def(py::init())
       .def("setFallback",
            [](MaterialSelector & self, UInt f) { self.setFallback(f); })
       .def("setFallback",
            [](MaterialSelector & self,
               const std::shared_ptr<MaterialSelector> & fallback_selector) {
              self.setFallback(fallback_selector);
            })
       .def("__call__", &MaterialSelector::operator());
 
   register_material_selectors<DefaultMaterialSelector>(
       mod, "DefaultMaterialSelector")
       .def(py::init<const ElementTypeMapArray<UInt>>());
 
   register_material_selectors<MeshDataMaterialSelector<std::string>>(
       mod, "MeshDataMaterialSelectorString")
       .def(py::init<const std::string &, const SolidMechanicsModel &, UInt>(),
            py::arg("name"), py::arg("model"), py::arg("first_index") = 1);
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
   register_material_selectors<DefaultMaterialCohesiveSelector>(
       mod, "DefaultMaterialCohesiveSelector")
       .def(py::init<const SolidMechanicsModelCohesive &>());
 
   register_material_selectors<MeshDataMaterialCohesiveSelector>(
       mod, "MeshDataMaterialCohesiveSelector")
       .def(py::init<const SolidMechanicsModelCohesive &>());
 
   register_material_selectors<MaterialCohesiveRulesSelector>(
       mod, "MaterialCohesiveRulesSelector")
       .def(py::init<const SolidMechanicsModelCohesive &,
                     const MaterialCohesiveRules &, const ID &>(),
            py::arg("model"), py::arg("rules"),
            py::arg("mesh_data_id") = "physical_names");
 #endif
 }
 } // namespace akantu