diff --git a/python/py_model_couplers.cc b/python/py_model_couplers.cc
index 7cc6f6424..9ab064d05 100644
--- a/python/py_model_couplers.cc
+++ b/python/py_model_couplers.cc
@@ -1,122 +1,121 @@
 /**
  * @file   py_model_couplers.cc
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Jun 20 2019
  * @date last modification: Thu Jun 24 2021
  *
  * @brief  Model Coupler python binding
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "py_aka_array.hh"
 /* -------------------------------------------------------------------------- */
+#include <aka_error.hh>
 #include <cohesive_contact_solvercallback.hh>
 #include <coupler_solid_cohesive_contact.hh>
 #include <coupler_solid_contact.hh>
 #include <non_linear_solver.hh>
 /* -------------------------------------------------------------------------- */
 #include <pybind11/pybind11.h>
 /* -------------------------------------------------------------------------- */
 namespace py = pybind11;
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 namespace {
   template <class CouplerSolidContact_>
   auto register_coupler_solid_contact(py::module & mod,
                                       const std::string & name)
       -> py::class_<CouplerSolidContact_, Model> {
     return py::class_<CouplerSolidContact_, Model>(mod, name.c_str(),
                                                    py::multiple_inheritance())
-        .def(py::init<Mesh &, UInt, const ID &, std::shared_ptr<DOFManager>,
-                      const ModelType>(),
+        .def(py::init<Mesh &, UInt, const ID &, std::shared_ptr<DOFManager>>(),
              py::arg("mesh"), py::arg("spatial_dimension") = _all_dimensions,
              py::arg("id") = "coupler_solid_contact",
-             py::arg("dof_manager") = nullptr,
-             py::arg("model_type") = ModelType::_coupler_solid_contact)
+             py::arg("dof_manager") = nullptr)
         .def("applyBC",
              [](CouplerSolidContact_ & self,
                 BC::Dirichlet::DirichletFunctor & func,
                 const std::string & element_group) {
                self.applyBC(func, element_group);
              })
         .def("applyBC",
              [](CouplerSolidContact_ & self, BC::Neumann::NeumannFunctor & func,
                 const std::string & element_group) {
                self.applyBC(func, element_group);
              })
 
         .def("setTimeStep", &CouplerSolidContact_::setTimeStep,
              py::arg("time_step"), py::arg("solver_id") = "")
         .def("getContactMechanicsModel",
              &CouplerSolidContact_::getContactMechanicsModel,
              py::return_value_policy::reference);
   }
 } // namespace
 
 /* -------------------------------------------------------------------------- */
 void register_model_couplers(py::module & mod) {
   register_coupler_solid_contact<CouplerSolidContact>(mod,
                                                       "CouplerSolidContact")
       .def(
           "getSolidMechanicsModel",
           [](CouplerSolidContact & self) -> decltype(auto) {
             return self.getSolidMechanicsModel();
           },
           py::return_value_policy::reference)
       .def(
           "initFull",
           [](CouplerSolidContact & self,
              const AnalysisMethod & analysis_method) {
             self.initFull(_analysis_method = analysis_method);
           },
           py::arg("_analysis_method") = _explicit_lumped_mass);
 
   register_coupler_solid_contact<CouplerSolidCohesiveContact>(
       mod, "CouplerSolidCohesiveContact")
       .def(
           "initFull",
           [](CouplerSolidCohesiveContact & self,
              const AnalysisMethod & analysis_method, bool is_extrinsic) {
             self.initFull(_analysis_method = analysis_method,
                           _is_extrinsic = is_extrinsic);
           },
           py::arg("_analysis_method") = _explicit_lumped_mass,
           py::arg("_is_extrinsic") = false)
       .def("checkCohesiveStress",
            [](CouplerSolidCohesiveContact & self) {
              return self.checkCohesiveStress();
            })
       .def(
           "getSolidMechanicsModelCohesive",
           [](CouplerSolidCohesiveContact & self) -> decltype(auto) {
             return self.getSolidMechanicsModelCohesive();
           },
           py::return_value_policy::reference);
 }
 
 } // namespace akantu
diff --git a/src/model/model_couplers/coupler_solid_cohesive_contact.cc b/src/model/model_couplers/coupler_solid_cohesive_contact.cc
index 68d0f9f81..3a2099ad0 100644
--- a/src/model/model_couplers/coupler_solid_cohesive_contact.cc
+++ b/src/model/model_couplers/coupler_solid_cohesive_contact.cc
@@ -1,76 +1,76 @@
 /**
  * @file   coupler_solid_cohesive_contact.cc
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Jan 21 2019
  * @date last modification: Wed Jun 23 2021
  *
  * @brief  class for coupling of solid mechanics cohesive and conatct mechanics
  * model
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "coupler_solid_cohesive_contact.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 template <>
 CouplerSolidContactTemplate<SolidMechanicsModelCohesive>::
     CouplerSolidContactTemplate(Mesh & mesh, UInt dim, const ID & id,
-                                std::shared_ptr<DOFManager> dof_manager,
-                                ModelType model_type)
-    : Model(mesh, model_type, dof_manager, dim, id) {
+                                std::shared_ptr<DOFManager> dof_manager)
+    : Model(mesh, ModelType::_coupler_solid_cohesive_contact, dof_manager, dim,
+            id) {
   this->mesh.registerDumper<DumperParaview>("coupler_solid_cohesive_contact",
                                             id, true);
   this->mesh.addDumpMeshToDumper("coupler_solid_cohesive_contact", mesh,
                                  Model::spatial_dimension, _not_ghost,
                                  _ek_cohesive);
 
   this->registerDataAccessor(*this);
 
   solid = std::make_unique<SolidMechanicsModelCohesive>(
       mesh, Model::spatial_dimension, "solid_mechanics_model_cohesive",
       this->dof_manager);
   contact = std::make_unique<ContactMechanicsModel>(mesh.getMeshFacets(),
                                                     Model::spatial_dimension,
                                                     "contact_mechanics_model");
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void CouplerSolidContactTemplate<SolidMechanicsModelCohesive>::initFullImpl(
     const ModelOptions & options) {
   Model::initFullImpl(options);
 
   const auto & cscc_options =
       aka::as_type<CouplerSolidCohesiveContactOptions>(options);
 
   solid->initFull(_analysis_method = cscc_options.analysis_method,
                   _is_extrinsic = cscc_options.is_extrinsic);
   contact->initFull(_analysis_method = cscc_options.analysis_method);
 }
 
 } // namespace akantu
diff --git a/src/model/model_couplers/coupler_solid_contact.cc b/src/model/model_couplers/coupler_solid_contact.cc
index 5dbedb121..5f111e9e2 100644
--- a/src/model/model_couplers/coupler_solid_contact.cc
+++ b/src/model/model_couplers/coupler_solid_contact.cc
@@ -1,69 +1,69 @@
 /**
  * @file   coupler_solid_contact.cc
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Jan 21 2019
  * @date last modification: Wed Jun 23 2021
  *
  * @brief  class for coupling of solid mechanics and conatct mechanics
  * model
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "coupler_solid_contact.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 template <>
 CouplerSolidContactTemplate<SolidMechanicsModel>::CouplerSolidContactTemplate(
     Mesh & mesh, UInt dim, const ID & id,
-    std::shared_ptr<DOFManager> dof_manager, ModelType model_type)
-    : Model(mesh, model_type, dof_manager, dim, id) {
+    std::shared_ptr<DOFManager> dof_manager)
+    : Model(mesh, ModelType::_coupler_solid_contact, dof_manager, dim, id) {
   this->mesh.registerDumper<DumperParaview>("coupler_solid_contact", id, true);
   this->mesh.addDumpMeshToDumper("coupler_solid_contact", mesh,
                                  Model::spatial_dimension, _not_ghost,
                                  _ek_regular);
   this->registerDataAccessor(*this);
 
   solid = std::make_unique<SolidMechanicsModel>(mesh, Model::spatial_dimension,
                                                 "solid_mechanics_model",
                                                 this->dof_manager);
   contact = std::make_unique<ContactMechanicsModel>(
       mesh, Model::spatial_dimension, "contact_mechanics_model",
       this->dof_manager);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void CouplerSolidContactTemplate<SolidMechanicsModel>::initFullImpl(
     const ModelOptions & options) {
   Model::initFullImpl(options);
 
   solid->initFull(_analysis_method = this->method);
   contact->initFull(_analysis_method = this->method);
 }
 
 } // namespace akantu
diff --git a/src/model/model_couplers/coupler_solid_contact.hh b/src/model/model_couplers/coupler_solid_contact.hh
index d82ffbec3..6c04b4770 100644
--- a/src/model/model_couplers/coupler_solid_contact.hh
+++ b/src/model/model_couplers/coupler_solid_contact.hh
@@ -1,280 +1,276 @@
 /**
  * @file   coupler_solid_contact.hh
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Sat Jun 26 2021
  *
  * @brief  class for coupling of solid mechanics and conatct mechanics
  * model in explicit
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "contact_mechanics_model.hh"
 #include "solid_mechanics_model.hh"
 #if defined(AKANTU_COHESIVE_ELEMENT)
 #include "solid_mechanics_model_cohesive.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_COUPLER_SOLID_CONTACT_HH__
 #define __AKANTU_COUPLER_SOLID_CONTACT_HH__
 
 /* ------------------------------------------------------------------------ */
 /* Coupling : Solid Mechanics / Contact Mechanics                           */
 /* ------------------------------------------------------------------------ */
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 class CouplerSolidContactTemplate : public Model,
                                     public DataAccessor<Element>,
                                     public DataAccessor<UInt> {
   static_assert(
       std::is_base_of<SolidMechanicsModel, SolidMechanicsModelType>::value,
       "SolidMechanicsModelType should be derived from SolidMechanicsModel");
   /* ------------------------------------------------------------------------ */
   /* Constructor/Destructor                                                   */
   /* ------------------------------------------------------------------------ */
 public:
   CouplerSolidContactTemplate(
       Mesh & mesh, UInt dim = _all_dimensions,
       const ID & id = "coupler_solid_contact",
-      std::shared_ptr<DOFManager> dof_manager = nullptr,
-      ModelType model_type = std::is_same<SolidMechanicsModelType,
-                                          SolidMechanicsModelCohesive>::value
-                                 ? ModelType::_coupler_solid_cohesive_contact
-                                 : ModelType::_coupler_solid_contact);
+      std::shared_ptr<DOFManager> dof_manager = nullptr);
 
   ~CouplerSolidContactTemplate() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 protected:
   /// initialize completely the model
   void initFullImpl(const ModelOptions & options) override;
 
   /// get some default values for derived classes
   std::tuple<ID, TimeStepSolverType>
   getDefaultSolverID(const AnalysisMethod & method) override;
 
   /* ------------------------------------------------------------------------ */
   /* Solver Interface                                                         */
   /* ------------------------------------------------------------------------ */
 public:
   /// assembles the contact stiffness matrix
   virtual void assembleStiffnessMatrix();
 
   /// assembles the contant internal forces
   virtual void assembleInternalForces();
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
   template <class Model_ = SolidMechanicsModelType,
             std::enable_if_t<std::is_same<
                 Model_, SolidMechanicsModelCohesive>::value> * = nullptr>
   UInt checkCohesiveStress() {
     return solid->checkCohesiveStress();
   }
 #endif
 
   template <typename FunctorType>
   inline void applyBC(const FunctorType & func) {
     solid->applyBC(func);
   }
 
   template <class FunctorType>
   inline void applyBC(const FunctorType & func,
                       const std::string & group_name) {
     solid->applyBC(func, group_name);
   }
 
   template <class FunctorType>
   inline void applyBC(const FunctorType & func,
                       const ElementGroup & element_group) {
     solid->applyBC(func, element_group);
   }
 
 protected:
   /// callback for the solver, this adds f_{ext} - f_{int} to the residual
   void assembleResidual() override;
 
   /// callback for the solver, this adds f_{ext} or  f_{int} to the residual
   void assembleResidual(const ID & residual_part) override;
   bool canSplitResidual() const override { return true; }
 
   /// get the type of matrix needed
   MatrixType getMatrixType(const ID & matrix_id) const override;
 
   /// callback for the solver, this assembles different matrices
   void assembleMatrix(const ID & matrix_id) override;
 
   /// callback for the solver, this assembles the stiffness matrix
   void assembleLumpedMatrix(const ID & matrix_id) override;
 
   /// callback for the solver, this is called at beginning of solve
   void predictor() override;
 
   /// callback for the solver, this is called at end of solve
   void corrector() override;
 
   /// callback for the solver, this is called at beginning of solve
   void beforeSolveStep() override;
 
   /// callback for the solver, this is called at end of solve
   void afterSolveStep(bool converged = true) override;
 
   /// callback for the model to instantiate the matricess when needed
   void initSolver(TimeStepSolverType time_step_solver_type,
                   NonLinearSolverType non_linear_solver_type) override;
 
   /* ------------------------------------------------------------------------ */
   /* Mass matrix for solid mechanics model                                    */
   /* ------------------------------------------------------------------------ */
 public:
   /// assemble the lumped mass matrix
   void assembleMassLumped();
 
   /// assemble the mass matrix for consistent mass resolutions
   void assembleMass();
 
 protected:
   /// assemble the lumped mass matrix for local and ghost elements
   void assembleMassLumped(GhostType ghost_type);
 
   /// assemble the mass matrix for either _ghost or _not_ghost elements
   void assembleMass(GhostType ghost_type);
 
 protected:
   /* ------------------------------------------------------------------------ */
   TimeStepSolverType getDefaultSolverType() const override;
   /* ------------------------------------------------------------------------ */
   ModelSolverOptions
   getDefaultSolverOptions(const TimeStepSolverType & type) const override;
 
 public:
   bool isDefaultSolverExplicit() { return method == _explicit_lumped_mass; }
 
   /* ------------------------------------------------------------------------ */
 public:
   // DataAccessor<Element>
   UInt getNbData(const Array<Element> & /*elements*/,
                  const SynchronizationTag & /*tag*/) const override {
     return 0;
   }
   void packData(CommunicationBuffer & /*buffer*/,
                 const Array<Element> & /*elements*/,
                 const SynchronizationTag & /*tag*/) const override {}
   void unpackData(CommunicationBuffer & /*buffer*/,
                   const Array<Element> & /*elements*/,
                   const SynchronizationTag & /*tag*/) override {}
 
   // DataAccessor<UInt> nodes
   UInt getNbData(const Array<UInt> & /*nodes*/,
                  const SynchronizationTag & /*tag*/) const override {
     return 0;
   }
   void packData(CommunicationBuffer & /*buffer*/, const Array<UInt> & /*nodes*/,
                 const SynchronizationTag & /*tag*/) const override {}
   void unpackData(CommunicationBuffer & /*buffer*/,
                   const Array<UInt> & /*nodes*/,
                   const SynchronizationTag & /*tag*/) override {}
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the solid mechanics model
 #if defined(AKANTU_COHESIVE_ELEMENT)
   template <class Model_ = SolidMechanicsModelType,
             std::enable_if_t<std::is_same<
                 Model_, SolidMechanicsModelCohesive>::value> * = nullptr>
   SolidMechanicsModelCohesive & getSolidMechanicsModelCohesive() {
     return *solid;
   }
 #endif
   template <class Model_ = SolidMechanicsModelType,
             std::enable_if_t<
                 std::is_same<Model_, SolidMechanicsModel>::value> * = nullptr>
   SolidMechanicsModelType & getSolidMechanicsModel() {
     return *solid;
   }
 
   /// get the contact mechanics model
   AKANTU_GET_MACRO(ContactMechanicsModel, *contact, ContactMechanicsModel &)
 
   /* ------------------------------------------------------------------------ */
   /* Dumpable interface                                                       */
   /* ------------------------------------------------------------------------ */
 public:
   std::shared_ptr<dumpers::Field>
   createNodalFieldReal(const std::string & field_name,
                        const std::string & group_name,
                        bool padding_flag) override;
 
   std::shared_ptr<dumpers::Field>
   createNodalFieldUInt(const std::string & field_name,
                        const std::string & group_name,
                        bool padding_flag) override;
 
   std::shared_ptr<dumpers::Field>
   createNodalFieldBool(const std::string & field_name,
                        const std::string & group_name,
                        bool padding_flag) override;
 
   std::shared_ptr<dumpers::Field>
   createElementalField(const std::string & field_name,
                        const std::string & group_name, bool padding_flag,
                        UInt spatial_dimension, ElementKind kind) override;
 
   void dump(const std::string & dumper_name) override;
   void dump(const std::string & dumper_name, UInt step) override;
   void dump(const std::string & dumper_name, Real time, UInt step) override;
 
   void dump() override;
 
   void dump(UInt step) override;
   void dump(Real time, UInt step) override;
 
   /* ------------------------------------------------------------------------ */
   /* Members                                                                  */
   /* ------------------------------------------------------------------------ */
 private:
   /// solid mechanics model
   std::unique_ptr<SolidMechanicsModelType> solid;
 
   /// contact mechanics model
   std::unique_ptr<ContactMechanicsModel> contact;
 
   UInt step;
 };
 
 using CouplerSolidContact = CouplerSolidContactTemplate<SolidMechanicsModel>;
 
 } // namespace akantu
 
 #include "coupler_solid_contact_tmpl.hh"
 
 #endif /* __COUPLER_SOLID_CONTACT_HH__  */