diff --git a/python/py_heat_transfer_model.cc b/python/py_heat_transfer_model.cc
index 9f59c4040..0ade5ed10 100644
--- a/python/py_heat_transfer_model.cc
+++ b/python/py_heat_transfer_model.cc
@@ -1,68 +1,68 @@
 /* -------------------------------------------------------------------------- */
 #include "py_aka_array.hh"
 /* -------------------------------------------------------------------------- */
 #include <heat_transfer_model.hh>
 #include <non_linear_solver.hh>
 /* -------------------------------------------------------------------------- */
 //#include <pybind11/operators.h>
 #include <pybind11/pybind11.h>
 //#include <pybind11/stl.h>
 /* -------------------------------------------------------------------------- */
 namespace py = pybind11;
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 #define def_deprecated(func_name, mesg)                                        \
   def(func_name, [](py::args, py::kwargs) { AKANTU_ERROR(mesg); })
 
 #define def_function_nocopy(func_name)                                         \
   def(#func_name,                                                              \
       [](HeatTransferModel & self) -> decltype(auto) {                         \
         return self.func_name();                                               \
       },                                                                       \
       py::return_value_policy::reference)
 
 #define def_function(func_name)                                                \
   def(#func_name, [](HeatTransferModel & self) -> decltype(auto) {             \
     return self.func_name();                                                   \
   })
 /* -------------------------------------------------------------------------- */
 
 void register_heat_transfer_model(py::module & mod) {
-
   py::class_<HeatTransferModelOptions>(mod, "HeatTransferModelOptions")
       .def(py::init<AnalysisMethod>(),
            py::arg("analysis_method") = _explicit_lumped_mass);
 
-  py::class_<HeatTransferModel, Model, ModelSolver>(mod, "HeatTransferModel")
+  py::class_<HeatTransferModel, Model>(mod, "HeatTransferModel",
+                                       py::multiple_inheritance())
       .def(py::init<Mesh &, UInt, const ID &, const MemoryID &>(),
            py::arg("mesh"), py::arg("spatial_dimension") = _all_dimensions,
            py::arg("id") = "heat_transfer_model", py::arg("memory_id") = 0)
       .def("initFull",
            [](HeatTransferModel & self,
               const HeatTransferModelOptions & options) {
              self.initFull(options);
            },
            py::arg("_analysis_method") = HeatTransferModelOptions())
       .def("initFull",
            [](HeatTransferModel & self,
               const AnalysisMethod & _analysis_method) {
              self.initFull(HeatTransferModelOptions(_analysis_method));
            },
            py::arg("_analysis_method"))
       .def("setTimeStep", &HeatTransferModel::setTimeStep, py::arg("time_step"),
            py::arg("solver_id") = "")
       .def_function(getStableTimeStep)
       .def_function_nocopy(getTemperature)
       .def_function_nocopy(getBlockedDOFs)
       .def("getTemperatureGradient", &HeatTransferModel::getTemperatureGradient,
            py::arg("el_type"), py::arg("ghost_type") = _not_ghost,
            py::return_value_policy::reference)
       .def("getKgradT", &HeatTransferModel::getKgradT, py::arg("el_type"),
            py::arg("ghost_type") = _not_ghost,
            py::return_value_policy::reference);
 }
 
 } // namespace akantu
diff --git a/python/py_model.cc b/python/py_model.cc
index 6e5ee9ccc..025d114e6 100644
--- a/python/py_model.cc
+++ b/python/py_model.cc
@@ -1,73 +1,74 @@
 /* -------------------------------------------------------------------------- */
 #include "py_aka_array.hh"
 /* -------------------------------------------------------------------------- */
 #include <model.hh>
 #include <non_linear_solver.hh>
 #include <sparse_matrix_aij.hh>
 /* -------------------------------------------------------------------------- */
 #include <pybind11/operators.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 /* -------------------------------------------------------------------------- */
 namespace py = pybind11;
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 
 void register_model(py::module & mod) {
-
   py::class_<SparseMatrix>(mod, "SparseMatrix")
       .def("getMatrixType", &SparseMatrix::getMatrixType)
       .def("size", &SparseMatrix::size);
 
   py::class_<SparseMatrixAIJ, SparseMatrix>(mod, "SparseMatrixAIJ")
       .def("getIRN", &SparseMatrixAIJ::getIRN)
       .def("getJCN", &SparseMatrixAIJ::getJCN)
       .def("getA", &SparseMatrixAIJ::getA);
 
   py::class_<DOFManager>(mod, "DOFManager")
       .def("getMatrix",
            [](DOFManager & self, const std::string & name) {
              return dynamic_cast<akantu::SparseMatrixAIJ &>(
                  self.getMatrix(name));
            },
            py::return_value_policy::reference);
 
-  py::class_<Model>(mod, "Model")
-      .def("setBaseName", &Model::setBaseName)
-      .def("getFEEngine", &Model::getFEEngine, py::arg("name") = "",
-           py::return_value_policy::reference)
-      .def("addDumpFieldVector", &Model::addDumpFieldVector)
-      .def("addDumpField", &Model::addDumpField)
-      .def("setBaseNameToDumper", &Model::setBaseNameToDumper)
-      .def("addDumpFieldVectorToDumper", &Model::addDumpFieldVectorToDumper)
-      .def("addDumpFieldToDumper", &Model::addDumpFieldToDumper)
-      .def("dump", &Model::dump)
-      .def("initNewSolver", &Model::initNewSolver)
-      .def("getDOFManager", &Model::getDOFManager,
-           py::return_value_policy::reference);
-
   py::class_<NonLinearSolver>(mod, "NonLinearSolver")
       .def(
           "set",
           [](NonLinearSolver & self, const std::string & id, const Real & val) {
             if (id == "max_iterations")
               self.set(id, int(val));
-            else if (id == "convergence_type")
-              self.set(id, akantu::SolveConvergenceCriteria(UInt(val)));
             else
               self.set(id, val);
-          });
+          })
+      .def("set",
+           [](NonLinearSolver & self, const std::string & id,
+              const SolveConvergenceCriteria & val) { self.set(id, val); });
 
   py::class_<ModelSolver, Parsable>(mod, "ModelSolver",
                                     py::multiple_inheritance())
       .def("getNonLinearSolver",
            (NonLinearSolver & (ModelSolver::*)(const ID &)) &
                ModelSolver::getNonLinearSolver,
            py::arg("solver_id") = "", py::return_value_policy::reference)
       .def("solveStep", &ModelSolver::solveStep, py::arg("solver_id") = "");
+
+  py::class_<Model, ModelSolver>(mod, "Model", py::multiple_inheritance())
+      .def("setBaseName", &Model::setBaseName)
+      .def("getFEEngine", &Model::getFEEngine, py::arg("name") = "",
+           py::return_value_policy::reference)
+      .def("addDumpFieldVector", &Model::addDumpFieldVector)
+      .def("addDumpField", &Model::addDumpField)
+      .def("setBaseNameToDumper", &Model::setBaseNameToDumper)
+      .def("addDumpFieldVectorToDumper", &Model::addDumpFieldVectorToDumper)
+      .def("addDumpFieldToDumper", &Model::addDumpFieldToDumper)
+      .def("dump", &Model::dump)
+      .def("initNewSolver", &Model::initNewSolver)
+      .def("getDOFManager", &Model::getDOFManager,
+           py::return_value_policy::reference);
+
 }
 
 } // namespace akantu
diff --git a/python/py_solid_mechanics_model.cc b/python/py_solid_mechanics_model.cc
index 079ab411a..4d4fe5117 100644
--- a/python/py_solid_mechanics_model.cc
+++ b/python/py_solid_mechanics_model.cc
@@ -1,108 +1,108 @@
 /* -------------------------------------------------------------------------- */
 #include "py_aka_array.hh"
 /* -------------------------------------------------------------------------- */
 #include <non_linear_solver.hh>
 #include <solid_mechanics_model.hh>
 /* -------------------------------------------------------------------------- */
 #include <pybind11/pybind11.h>
 /* -------------------------------------------------------------------------- */
 namespace py = pybind11;
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 #define def_deprecated(func_name, mesg)                                        \
   def(func_name, [](py::args, py::kwargs) { AKANTU_ERROR(mesg); })
 
 #define def_function_nocopy(func_name)                                         \
   def(#func_name,                                                              \
       [](SolidMechanicsModel & self) -> decltype(auto) {                       \
         return self.func_name();                                               \
       },                                                                       \
       py::return_value_policy::reference)
 
 #define def_function(func_name)                                                \
   def(#func_name, [](SolidMechanicsModel & self) -> decltype(auto) {           \
     return self.func_name();                                                   \
   })
 /* -------------------------------------------------------------------------- */
 
 [[gnu::visibility("default")]] void
 register_solid_mechanics_model(py::module & mod) {
 
   py::class_<SolidMechanicsModelOptions>(mod, "SolidMechanicsModelOptions")
       .def(py::init<AnalysisMethod>(),
            py::arg("analysis_method") = _explicit_lumped_mass);
 
-  py::class_<SolidMechanicsModel, Model, ModelSolver>(mod,
-                                                      "SolidMechanicsModel")
+  py::class_<SolidMechanicsModel, Model>(mod, "SolidMechanicsModel",
+                                         py::multiple_inheritance())
       .def(py::init<Mesh &, UInt, const ID &, const MemoryID &,
                     const ModelType>(),
            py::arg("mesh"), py::arg("spatial_dimension") = _all_dimensions,
            py::arg("id") = "solid_mechanics_model", py::arg("memory_id") = 0,
            py::arg("model_type") = ModelType::_solid_mechanics_model)
       .def("initFull",
            [](SolidMechanicsModel & self,
               const SolidMechanicsModelOptions & options) {
              self.initFull(options);
            },
            py::arg("_analysis_method") = SolidMechanicsModelOptions())
       .def("initFull",
            [](SolidMechanicsModel & self,
               const AnalysisMethod & analysis_method) {
              self.initFull(_analysis_method = analysis_method);
            },
            py::arg("_analysis_method"))
       .def_deprecated("applyDirichletBC", "Deprecated: use applyBC")
       .def("applyBC",
            [](SolidMechanicsModel & self,
               BC::Dirichlet::DirichletFunctor & func,
               const std::string & element_group) {
              self.applyBC(func, element_group);
            })
       .def("applyBC",
            [](SolidMechanicsModel & self, BC::Neumann::NeumannFunctor & func,
               const std::string & element_group) {
              self.applyBC(func, element_group);
            })
       .def("setTimeStep", &SolidMechanicsModel::setTimeStep,
            py::arg("time_step"), py::arg("solver_id") = "")
       .def("getEnergy",
            py::overload_cast<const std::string &>(
                &SolidMechanicsModel::getEnergy),
            py::arg("energy_id"))
       .def_function(assembleStiffnessMatrix)
       .def_function(assembleInternalForces)
       .def_function(assembleMass)
       .def_function(assembleMassLumped)
       .def_function(getStableTimeStep)
       .def_function_nocopy(getExternalForce)
       .def_function_nocopy(getDisplacement)
       .def_function_nocopy(getPreviousDisplacement)
       .def_function_nocopy(getIncrement)
       .def_function_nocopy(getInternalForce)
       .def_function_nocopy(getMass)
       .def_function_nocopy(getVelocity)
       .def_function_nocopy(getAcceleration)
       .def_function_nocopy(getInternalForce)
       .def_function_nocopy(getBlockedDOFs)
       .def_function_nocopy(getMesh)
       .def("dump", py::overload_cast<>(&SolidMechanicsModel::dump))
       .def("dump",
            py::overload_cast<const std::string &>(&SolidMechanicsModel::dump))
       .def("dump", py::overload_cast<const std::string &, UInt>(
                        &SolidMechanicsModel::dump))
       .def("dump", py::overload_cast<const std::string &, Real, UInt>(
                        &SolidMechanicsModel::dump))
       .def("getMaterial",
            py::overload_cast<UInt>(&SolidMechanicsModel::getMaterial),
            py::return_value_policy::reference)
       .def("getMaterial",
            py::overload_cast<const std::string &>(
                &SolidMechanicsModel::getMaterial),
            py::return_value_policy::reference)
       .def("getMaterialIndex", &SolidMechanicsModel::getMaterialIndex);
 }
 
 } // namespace akantu
diff --git a/test/test_model/patch_tests/test_patch_linear_heat_transfer_static.py b/test/test_model/patch_tests/test_patch_linear_heat_transfer_static.py
index 5288a29ee..385e33d77 100644
--- a/test/test_model/patch_tests/test_patch_linear_heat_transfer_static.py
+++ b/test/test_model/patch_tests/test_patch_linear_heat_transfer_static.py
@@ -1,37 +1,36 @@
 #!/usr/bin/env python3
 
 # ------------------------------------------------------------------------------
 __author__ = "Guillaume Anciaux"
 __copyright__ = "Copyright (C) 2016-2018, EPFL (Ecole Polytechnique Fédérale" \
                 " de Lausanne) Laboratory (LSMS - Laboratoire de Simulation" \
                 " en Mécanique des Solides)"
 __credits__ = ["Guillaume Anciaux"]
 __license__ = "L-GPLv3"
 __maintainer__ = "Guillaume Anciaux"
 __email__ = "guillaume.anciaux@epfl.ch"
 # ------------------------------------------------------------------------------
 
 from patch_test_linear_heat_transfer_fixture import TestPatchTestHTMLinear
 import akantu
 import sys
 
 
 def foo(self):
     self.initModel(akantu._static, "heat_transfer_input.dat")
 
     solver = self.model.getNonLinearSolver()
     solver.set("max_iterations", 2)
     solver.set("threshold", 2e-4)
-    solver.set("convergence_type", akantu.SolveConvergenceCriteria__residual)
+    solver.set("convergence_type", akantu.SolveConvergenceCriteria.residual)
 
     self.model.solveStep()
-
     self.checkAll()
 
 
 def test():
     TestPatchTestHTMLinear.TYPED_TEST(foo, "Static")
 
 
 if 'pytest' not in sys.modules:
     test()