diff --git a/python/py_contact_mechanics_model.cc b/python/py_contact_mechanics_model.cc
index 6971f4fba..5f191a31e 100644
--- a/python/py_contact_mechanics_model.cc
+++ b/python/py_contact_mechanics_model.cc
@@ -1,130 +1,130 @@
 /* -------------------------------------------------------------------------- */
 #include "py_aka_array.hh"
 /* -------------------------------------------------------------------------- */
 #include <contact_detector.hh>
 #include <contact_mechanics_model.hh>
 #include <geometry_utils.hh>
 #include <mesh_events.hh>
 #include <parsable.hh>
 #include <surface_selector.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,                                                              \
       [](ContactMechanicsModel & self) -> decltype(auto) {                     \
         return self.func_name();                                               \
       },                                                                       \
       py::return_value_policy::reference)
 
 #define def_function(func_name)                                                \
   def(#func_name, [](ContactMechanicsModel & self) -> decltype(auto) {         \
     return self.func_name();                                                   \
   })
-/* -------------------------------------------------------------------------- */
 
+/* -------------------------------------------------------------------------- */
 void register_contact_mechanics_model(py::module & mod) {
   py::class_<ContactDetector>(mod, "ContactDetector",
                               py::multiple_inheritance())
       .def(py::init<Mesh &, const ID &>(), py::arg("mesh"),
            py::arg("id") = "contact_detector")
       .def(py::init<Mesh &, Array<Real>, const ID &>(), py::arg("mesh"),
            py::arg("positions"), py::arg("id") = "contact_detector")
       .def("setSurfaceSelector", &ContactDetector::setSurfaceSelector);
 
   py::class_<SurfaceSelector, std::shared_ptr<SurfaceSelector>>(
       mod, "SurfaceSelector", py::multiple_inheritance())
       .def(py::init<Mesh &>(), py::arg("mesh"));
 
   py::class_<PhysicalSurfaceSelector, SurfaceSelector,
              std::shared_ptr<PhysicalSurfaceSelector>>(
       mod, "PhysicalSurfaceSelector")
       .def(py::init<Mesh &>(), py::arg("mesh"));
 
   py::class_<CohesiveSurfaceSelector, SurfaceSelector,
              std::shared_ptr<CohesiveSurfaceSelector>>(
       mod, "CohesiveSurfaceSelector")
       .def(py::init<Mesh &>(), py::arg("mesh"));
 
   py::class_<AllSurfaceSelector, SurfaceSelector,
              std::shared_ptr<AllSurfaceSelector>>(mod, "AllSurfaceSelector")
       .def(py::init<Mesh &>(), py::arg("mesh"));
 
   py::class_<ContactMechanicsModelOptions>(mod, "ContactMechanicsModelOptions")
       .def(py::init<AnalysisMethod>(),
            py::arg("analysis_method") = _explicit_contact);
 
   /* ------------------------------------------------------------------------ */
   py::class_<ContactMechanicsModel, Model>(mod, "ContactMechanicsModel",
                                            py::multiple_inheritance())
       .def(py::init<Mesh &, UInt, const ID &, std::shared_ptr<DOFManager>,
                     const ModelType>(),
            py::arg("mesh"), py::arg("spatial_dimension") = _all_dimensions,
            py::arg("id") = "contact_mechanics_model",
            py::arg("dof_manager") = nullptr,
            py::arg("model_type") = ModelType::_contact_mechanics_model)
       .def(
           "initFull",
           [](ContactMechanicsModel & self,
              const ContactMechanicsModelOptions & options) {
             self.initFull(options);
           },
           py::arg("options") = ContactMechanicsModelOptions())
       .def(
           "initFull",
           [](ContactMechanicsModel & self,
              const AnalysisMethod & analysis_method) {
             self.initFull(_analysis_method = analysis_method);
           },
           py::arg("_analysis_method"))
       .def_function(search)
       .def_function(assembleStiffnessMatrix)
       .def_function(assembleInternalForces)
       .def_function_nocopy(getExternalForce)
       .def_function_nocopy(getNormalForce)
       .def_function_nocopy(getTangentialForce)
       .def_function_nocopy(getInternalForce)
       .def_function_nocopy(getGaps)
       .def_function_nocopy(getNormals)
       .def_function_nocopy(getNodalArea)
       .def_function_nocopy(getContactDetector);
 
-  py::class_<ContactElement>(mod, "ContactElement").def(py::init<>());
+  py::class_<ContactElement>(mod, "ContactElement")
+      .def(py::init<>())
+      .def_readwrite("master", &ContactElement::master)
+      .def_readwrite("slave", &ContactElement::slave);
 
   py::class_<GeometryUtils>(mod, "GeometryUtils")
       .def_static(
           "normal",
           py::overload_cast<const Mesh &, const Array<Real> &, const Element &,
                             Vector<Real> &, bool>(&GeometryUtils::normal),
           py::arg("mesh"), py::arg("positions"), py::arg("element"),
           py::arg("normal"), py::arg("outward") = true)
       .def_static(
           "covariantBasis",
           py::overload_cast<const Mesh &, const Array<Real> &, const Element &,
                             const Vector<Real> &, Vector<Real> &,
                             Matrix<Real> &>(&GeometryUtils::covariantBasis),
           py::arg("mesh"), py::arg("positions"), py::arg("element"),
           py::arg("normal"), py::arg("natural_projection"), py::arg("basis"))
       .def_static("curvature", &GeometryUtils::curvature)
       .def_static("contravariantBasis", &GeometryUtils::contravariantBasis,
                   py::arg("covariant_basis"), py::arg("basis"))
       .def_static("realProjection",
                   py::overload_cast<const Mesh &, const Array<Real> &,
                                     const Vector<Real> &, const Element &,
                                     const Vector<Real> &, Vector<Real> &>(
                       &GeometryUtils::realProjection),
                   py::arg("mesh"), py::arg("positions"), py::arg("slave"),
                   py::arg("element"), py::arg("normal"), py::arg("projection"))
       .def_static("isBoundaryElement", &GeometryUtils::isBoundaryElement);
 }
 
 } // namespace akantu
diff --git a/src/fe_engine/element_class_tmpl.hh b/src/fe_engine/element_class_tmpl.hh
index 8fa0a9797..9d6050356 100644
--- a/src/fe_engine/element_class_tmpl.hh
+++ b/src/fe_engine/element_class_tmpl.hh
@@ -1,542 +1,534 @@
 /**
  * @file   element_class_tmpl.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Thomas Menouillard <tmenouillard@stucky.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Feb 21 2013
  * @date last modification: Wed Nov 29 2017
  *
  * @brief  Implementation of the inline templated function of the element class
  * descriptions
  *
  *
  * Copyright (©) 2014-2018 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 "element_class.hh"
 #include "gauss_integration_tmpl.hh"
 /* -------------------------------------------------------------------------- */
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_ELEMENT_CLASS_TMPL_HH_
 #define AKANTU_ELEMENT_CLASS_TMPL_HH_
 
 namespace akantu {
 
 template <ElementType element_type, ElementKind element_kind>
 inline constexpr auto
 ElementClass<element_type, element_kind>::getFacetTypes() {
   return VectorProxy<const ElementType>(
       element_class_extra_geom_property::facet_type.data(),
       geometrical_element::getNbFacetTypes());
 }
 
 /* -------------------------------------------------------------------------- */
 /* GeometricalElement                                                         */
 /* -------------------------------------------------------------------------- */
 template <GeometricalType geometrical_type, GeometricalShapeType shape>
 inline constexpr auto
 GeometricalElement<geometrical_type,
                    shape>::getFacetLocalConnectivityPerElement(UInt t) {
   int pos = 0;
   for (UInt i = 0; i < t; ++i) {
     pos += geometrical_property::nb_facets[i] *
            geometrical_property::nb_nodes_per_facet[i];
   }
 
   return MatrixProxy<const UInt>(
       geometrical_property::facet_connectivity_vect.data() + pos,
       geometrical_property::nb_facets[t],
       geometrical_property::nb_nodes_per_facet[t]);
 }
 
 /* -------------------------------------------------------------------------- */
 template <GeometricalType geometrical_type, GeometricalShapeType shape>
 inline UInt
 GeometricalElement<geometrical_type, shape>::getNbFacetsPerElement() {
   UInt total_nb_facets = 0;
   for (UInt n = 0; n < geometrical_property::nb_facet_types; ++n) {
     total_nb_facets += geometrical_property::nb_facets[n];
   }
 
   return total_nb_facets;
 }
 
 /* -------------------------------------------------------------------------- */
 template <GeometricalType geometrical_type, GeometricalShapeType shape>
 inline UInt
 GeometricalElement<geometrical_type, shape>::getNbFacetsPerElement(UInt t) {
   return geometrical_property::nb_facets[t];
 }
 
 /* -------------------------------------------------------------------------- */
 template <GeometricalType geometrical_type, GeometricalShapeType shape>
 template <class vector_type>
 inline bool GeometricalElement<geometrical_type, shape>::contains(
     const vector_type & coords) {
   return GeometricalShapeContains<shape>::contains(coords);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline bool
 GeometricalShapeContains<_gst_point>::contains(const vector_type & coords) {
   return (coords(0) < std::numeric_limits<Real>::epsilon());
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline bool
 GeometricalShapeContains<_gst_square>::contains(const vector_type & coords) {
   bool in = true;
   for (UInt i = 0; i < coords.size() && in; ++i) {
     in &= ((coords(i) >= -(1. + std::numeric_limits<Real>::epsilon())) &&
            (coords(i) <= (1. + std::numeric_limits<Real>::epsilon())));
   }
   return in;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline bool
 GeometricalShapeContains<_gst_triangle>::contains(const vector_type & coords) {
   bool in = true;
   Real sum = 0;
   for (UInt i = 0; (i < coords.size()) && in; ++i) {
     in &= ((coords(i) >= -(Math::getTolerance())) &&
            (coords(i) <= (1. + Math::getTolerance())));
     sum += coords(i);
   }
   if (in) {
     return (in && (sum <= (1. + Math::getTolerance())));
   }
   return in;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline bool
 GeometricalShapeContains<_gst_prism>::contains(const vector_type & coords) {
   bool in = ((coords(0) >= -1.) && (coords(0) <= 1.)); // x in segment [-1, 1]
 
   // y and z in triangle
   in &= ((coords(1) >= 0) && (coords(1) <= 1.));
   in &= ((coords(2) >= 0) && (coords(2) <= 1.));
   Real sum = coords(1) + coords(2);
 
   return (in && (sum <= 1));
 }
 
 /* -------------------------------------------------------------------------- */
 /* InterpolationElement                                                       */
 /* -------------------------------------------------------------------------- */
 template <InterpolationType interpolation_type, InterpolationKind kind>
 inline void InterpolationElement<interpolation_type, kind>::computeShapes(
     const Matrix<Real> & natural_coord, Matrix<Real> & N) {
   UInt nb_points = natural_coord.cols();
   for (UInt p = 0; p < nb_points; ++p) {
     Vector<Real> Np(N(p));
     Vector<Real> ncoord_p(natural_coord(p));
     computeShapes(ncoord_p, Np);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <InterpolationType interpolation_type, InterpolationKind kind>
 inline void InterpolationElement<interpolation_type, kind>::computeDNDS(
     const Matrix<Real> & natural_coord, Tensor3<Real> & dnds) {
   UInt nb_points = natural_coord.cols();
   for (UInt p = 0; p < nb_points; ++p) {
     Matrix<Real> dnds_p(dnds(p));
     Vector<Real> ncoord_p(natural_coord(p));
     computeDNDS(ncoord_p, dnds_p);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * interpolate on a point a field for which values are given on the
  * node of the element using the shape functions at this interpolation point
  *
  * @param nodal_values values of the function per node @f$ f_{ij} = f_{n_i j}
  *@f$ so it should be a matrix of size nb_nodes_per_element @f$\times@f$
  *nb_degree_of_freedom
  * @param shapes value of shape functions at the interpolation point
  * @param interpolated interpolated value of f @f$ f_j(\xi) = \sum_i f_{n_i j}
  *N_i @f$
  */
 template <InterpolationType interpolation_type, InterpolationKind kind>
 inline void InterpolationElement<interpolation_type, kind>::interpolate(
     const Matrix<Real> & nodal_values, const Vector<Real> & shapes,
     Vector<Real> & interpolated) {
   Matrix<Real> interpm(interpolated.storage(), nodal_values.rows(), 1);
   Matrix<Real> shapesm(
       shapes.storage(),
       InterpolationProperty<interpolation_type>::nb_nodes_per_element, 1);
   interpm.mul<false, false>(nodal_values, shapesm);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * interpolate on several points a field  for which values are given on the
  * node of the element using the shape functions at the interpolation point
  *
  * @param nodal_values values of the function per node @f$ f_{ij} = f_{n_i j}
  *@f$ so it should be a matrix of size nb_nodes_per_element @f$\times@f$
  *nb_degree_of_freedom
  * @param shapes value of shape functions at the interpolation point
  * @param interpolated interpolated values of f @f$ f_j(\xi) = \sum_i f_{n_i j}
  *N_i @f$
  */
 template <InterpolationType interpolation_type, InterpolationKind kind>
 inline void InterpolationElement<interpolation_type, kind>::interpolate(
     const Matrix<Real> & nodal_values, const Matrix<Real> & shapes,
     Matrix<Real> & interpolated) {
   UInt nb_points = shapes.cols();
   for (UInt p = 0; p < nb_points; ++p) {
     Vector<Real> Np(shapes(p));
     Vector<Real> interpolated_p(interpolated(p));
     interpolate(nodal_values, Np, interpolated_p);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * interpolate the field on a point given in natural coordinates the field which
  * values are given on the node of the element
  *
  * @param natural_coords natural coordinates of point where to interpolate \xi
  * @param nodal_values values of the function per node @f$ f_{ij} = f_{n_i j}
  *@f$ so it should be a matrix of size nb_nodes_per_element @f$\times@f$
  *nb_degree_of_freedom
  * @param interpolated interpolated value of f @f$ f_j(\xi) = \sum_i f_{n_i j}
  *N_i @f$
  */
 template <InterpolationType interpolation_type, InterpolationKind kind>
 inline void
 InterpolationElement<interpolation_type, kind>::interpolateOnNaturalCoordinates(
     const Vector<Real> & natural_coords, const Matrix<Real> & nodal_values,
     Vector<Real> & interpolated) {
   Vector<Real> shapes(
       InterpolationProperty<interpolation_type>::nb_nodes_per_element);
   computeShapes(natural_coords, shapes);
 
   interpolate(nodal_values, shapes, interpolated);
 }
 
 /* -------------------------------------------------------------------------- */
 /// @f$ gradient_{ij} = \frac{\partial f_j}{\partial s_i} = \sum_k
 /// \frac{\partial N_k}{\partial s_i}f_{j n_k} @f$
 template <InterpolationType interpolation_type, InterpolationKind kind>
 inline void
 InterpolationElement<interpolation_type, kind>::gradientOnNaturalCoordinates(
     const Vector<Real> & natural_coords, const Matrix<Real> & f,
     Matrix<Real> & gradient) {
   Matrix<Real> dnds(
       InterpolationProperty<interpolation_type>::natural_space_dimension,
       InterpolationProperty<interpolation_type>::nb_nodes_per_element);
   computeDNDS(natural_coords, dnds);
   gradient.mul<false, true>(f, dnds);
 }
 
 /* -------------------------------------------------------------------------- */
 /* ElementClass                                                               */
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void
 ElementClass<type, kind>::computeJMat(const Tensor3<Real> & dnds,
                                       const Matrix<Real> & node_coords,
                                       Tensor3<Real> & J) {
   UInt nb_points = dnds.size(2);
   for (UInt p = 0; p < nb_points; ++p) {
     Matrix<Real> J_p(J(p));
     Matrix<Real> dnds_p(dnds(p));
     computeJMat(dnds_p, node_coords, J_p);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void
 ElementClass<type, kind>::computeJMat(const Matrix<Real> & dnds,
                                       const Matrix<Real> & node_coords,
                                       Matrix<Real> & J) {
   /// @f$ J = dxds = dnds * x @f$
   J.mul<false, true>(dnds, node_coords);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void
 ElementClass<type, kind>::computeJacobian(const Matrix<Real> & natural_coords,
                                           const Matrix<Real> & node_coords,
                                           Vector<Real> & jacobians) {
   UInt nb_points = natural_coords.cols();
   Matrix<Real> dnds(interpolation_property::natural_space_dimension,
                     interpolation_property::nb_nodes_per_element);
   Matrix<Real> J(natural_coords.rows(), node_coords.rows());
 
   for (UInt p = 0; p < nb_points; ++p) {
     Vector<Real> ncoord_p(natural_coords(p));
     interpolation_element::computeDNDS(ncoord_p, dnds);
     computeJMat(dnds, node_coords, J);
     computeJacobian(J, jacobians(p));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void
 ElementClass<type, kind>::computeJacobian(const Tensor3<Real> & J,
                                           Vector<Real> & jacobians) {
   UInt nb_points = J.size(2);
   for (UInt p = 0; p < nb_points; ++p) {
     computeJacobian(J(p), jacobians(p));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void ElementClass<type, kind>::computeJacobian(const Matrix<Real> & J,
                                                       Real & jacobians) {
   if (J.rows() == J.cols()) {
     jacobians = Math::det<element_property::spatial_dimension>(J.storage());
   } else {
     interpolation_element::computeSpecialJacobian(J, jacobians);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void
 ElementClass<type, kind>::computeShapeDerivatives(const Tensor3<Real> & J,
                                                   const Tensor3<Real> & dnds,
                                                   Tensor3<Real> & shape_deriv) {
   UInt nb_points = J.size(2);
   for (UInt p = 0; p < nb_points; ++p) {
     Matrix<Real> shape_deriv_p(shape_deriv(p));
     computeShapeDerivatives(J(p), dnds(p), shape_deriv_p);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void
 ElementClass<type, kind>::computeShapeDerivatives(const Matrix<Real> & J,
                                                   const Matrix<Real> & dnds,
                                                   Matrix<Real> & shape_deriv) {
   Matrix<Real> inv_J(J.rows(), J.cols());
   Math::inv<element_property::spatial_dimension>(J.storage(), inv_J.storage());
 
   shape_deriv.mul<false, false>(inv_J, dnds);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void ElementClass<type, kind>::computeNormalsOnNaturalCoordinates(
     const Matrix<Real> & coord, Matrix<Real> & f, Matrix<Real> & normals) {
   UInt dimension = normals.rows();
   UInt nb_points = coord.cols();
 
   AKANTU_DEBUG_ASSERT((dimension - 1) ==
                           interpolation_property::natural_space_dimension,
                       "cannot extract a normal because of dimension mismatch "
                           << dimension - 1 << " "
                           << interpolation_property::natural_space_dimension);
 
   Matrix<Real> J(dimension, interpolation_property::natural_space_dimension);
   for (UInt p = 0; p < nb_points; ++p) {
     interpolation_element::gradientOnNaturalCoordinates(coord(p), f, J);
     if (dimension == 2) {
       Math::normal2(J.storage(), normals(p).storage());
     }
     if (dimension == 3) {
       Math::normal3(J(0).storage(), J(1).storage(), normals(p).storage());
     }
   }
 }
 
 /* ------------------------------------------------------------------------- */
 /**
  * In the non linear cases we need to iterate to find the natural coordinates
  *@f$\xi@f$
  * provided real coordinates @f$x@f$.
  *
  * We want to solve: @f$ x- \phi(\xi) = 0@f$ with @f$\phi(\xi) = \sum_I N_I(\xi)
  *x_I@f$
  * the mapping function which uses the nodal coordinates @f$x_I@f$.
  *
  * To that end we use the Newton method and the following series:
  *
  * @f$ \frac{\partial \phi(x_k)}{\partial \xi} \left( \xi_{k+1} - \xi_k \right)
  *= x - \phi(x_k)@f$
  *
  * When we consider elements embedded in a dimension higher than them (2D
  *triangle in a 3D space for example)
  * @f$ J = \frac{\partial \phi(\xi_k)}{\partial \xi}@f$ is of dimension
  *@f$dim_{space} \times dim_{elem}@f$ which
  * is not invertible in most cases. Rather we can solve the problem:
  *
  * @f$ J^T J \left( \xi_{k+1} - \xi_k \right) = J^T \left( x - \phi(\xi_k)
  *\right) @f$
  *
  * So that
  *
  * @f$ d\xi = \xi_{k+1} - \xi_k = (J^T J)^{-1} J^T \left( x - \phi(\xi_k)
  *\right) @f$
  *
  * So that if the series converges we have:
  *
  * @f$ 0 = J^T \left( \phi(\xi_\infty) - x \right) @f$
  *
  * And we see that this is ill-posed only if @f$ J^T x = 0@f$ which means that
  *the vector provided
  * is normal to any tangent which means it is outside of the element itself.
  *
  * @param real_coords: the real coordinates the natural coordinates are sought
  *for
  * @param node_coords: the coordinates of the nodes forming the element
  * @param natural_coords: output->the sought natural coordinates
  * @param spatial_dimension: spatial dimension of the problem
  *
  **/
 template <ElementType type, ElementKind kind>
 inline void ElementClass<type, kind>::inverseMap(
     const Vector<Real> & real_coords, const Matrix<Real> & node_coords,
     Vector<Real> & natural_coords, UInt max_iterations, Real tolerance) {
   UInt spatial_dimension = real_coords.size();
   UInt dimension = natural_coords.size();
 
   // matrix copy of the real_coords
   Matrix<Real> mreal_coords(real_coords.storage(), spatial_dimension, 1);
 
   // initial guess
-  //  Matrix<Real> natural_guess(natural_coords.storage(), dimension, 1);
   natural_coords.zero();
 
   // real space coordinates provided by initial guess
-  Matrix<Real> physical_guess(spatial_dimension /*changed from
-                          dimension */
-                              ,
-                              1);
+  Matrix<Real> physical_guess(spatial_dimension, 1);
 
   // objective function f = real_coords - physical_guess
-  Matrix<Real> f(spatial_dimension /*changed from dimension */, 1);
-
-  // dnds computed on the natural_guess
-  //  Matrix<Real> dnds(interpolation_element::nb_nodes_per_element,
-  //  spatial_dimension);
+  Matrix<Real> f(spatial_dimension, 1);
 
   // J Jacobian matrix computed on the natural_guess
   Matrix<Real> J(dimension, spatial_dimension);
 
   // J^t
   Matrix<Real> Jt(spatial_dimension, dimension);
 
   // G = J^t * J
   Matrix<Real> G(dimension, dimension);
 
   // Ginv = G^{-1}
   Matrix<Real> Ginv(dimension, dimension);
 
   // J = Ginv * J^t
   Matrix<Real> F(spatial_dimension, dimension);
 
   // dxi = \xi_{k+1} - \xi in the iterative process
   Matrix<Real> dxi(dimension, 1);
 
   Matrix<Real> dxit(1, dimension);
 
   /* --------------------------- */
   /* init before iteration loop  */
   /* --------------------------- */
   // do interpolation
   auto update_f = [&f, &physical_guess, &natural_coords, &node_coords,
                    &mreal_coords, spatial_dimension]() {
     Vector<Real> physical_guess_v(physical_guess.storage(), spatial_dimension);
     interpolation_element::interpolateOnNaturalCoordinates(
         natural_coords, node_coords, physical_guess_v);
 
     // compute initial objective function value f = real_coords - physical_guess
     f = mreal_coords;
     f -= physical_guess;
 
     // compute initial error
     auto error = f.norm<L_2>();
     return error;
   };
 
   auto inverse_map_error = update_f();
   /* --------------------------- */
   /* iteration loop              */
   /* --------------------------- */
   UInt iterations{0};
   while (tolerance < inverse_map_error and iterations < max_iterations) {
     // compute J^t
     interpolation_element::gradientOnNaturalCoordinates(natural_coords,
                                                         node_coords, Jt);
     J = Jt.transpose();
 
     // compute G
     G.mul<false, true>(J, J);
 
     // inverse G
     Ginv.inverse(G);
 
     // compute F
     F.mul<true, false>(J, Ginv);
 
     // compute increment
     dxit.mul<true, false>(f, F);
 
     dxi = dxit.transpose();
 
     // update our guess
     natural_coords += Vector<Real>(dxi(0));
 
     inverse_map_error = update_f();
     iterations++;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void ElementClass<type, kind>::inverseMap(
     const Matrix<Real> & real_coords, const Matrix<Real> & node_coords,
     Matrix<Real> & natural_coords, UInt max_iterations, Real tolerance) {
   UInt nb_points = real_coords.cols();
   for (UInt p = 0; p < nb_points; ++p) {
     Vector<Real> X(real_coords(p));
     Vector<Real> ncoord_p(natural_coords(p));
     inverseMap(X, node_coords, ncoord_p, max_iterations, tolerance);
   }
 }
 
 } // namespace akantu
 
 #endif /* AKANTU_ELEMENT_CLASS_TMPL_HH_ */
diff --git a/src/model/contact_mechanics/contact_mechanics_model.cc b/src/model/contact_mechanics/contact_mechanics_model.cc
index bbde7c887..5b57fd65f 100644
--- a/src/model/contact_mechanics/contact_mechanics_model.cc
+++ b/src/model/contact_mechanics/contact_mechanics_model.cc
@@ -1,714 +1,712 @@
 /**
  * @file   coontact_mechanics_model.cc
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  *
  * @date creation: Tue May 08 2012
  * @date last modification: Wed Feb 21 2018
  *
  * @brief  Contact mechanics model
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2018 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 "boundary_condition_functor.hh"
 #include "dumpable_inline_impl.hh"
 #include "group_manager_inline_impl.hh"
 #include "integrator_gauss.hh"
 #include "shape_lagrange.hh"
 
 #ifdef AKANTU_USE_IOHELPER
 #include "dumper_iohelper_paraview.hh"
 #endif
 
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 ContactMechanicsModel::ContactMechanicsModel(
     Mesh & mesh, UInt dim, const ID & id,
     std::shared_ptr<DOFManager> dof_manager, const ModelType model_type)
     : Model(mesh, model_type, dof_manager, dim, id) {
 
   AKANTU_DEBUG_IN();
 
   this->registerFEEngineObject<MyFEEngineType>("ContactMechanicsModel", mesh,
                                                Model::spatial_dimension);
 #if defined(AKANTU_USE_IOHELPER)
   this->mesh.registerDumper<DumperParaview>("contact_mechanics", id, true);
   this->mesh.addDumpMeshToDumper("contact_mechanics", mesh,
                                  Model::spatial_dimension, _not_ghost,
                                  _ek_regular);
 #endif
 
   this->registerDataAccessor(*this);
 
   this->detector =
       std::make_unique<ContactDetector>(this->mesh, id + ":contact_detector");
 
   registerFEEngineObject<MyFEEngineType>("ContactFacetsFEEngine", mesh,
                                          Model::spatial_dimension - 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 ContactMechanicsModel::~ContactMechanicsModel() = default;
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::initFullImpl(const ModelOptions & options) {
 
   Model::initFullImpl(options);
 
   // initalize the resolutions
   if (not this->parser.getLastParsedFile().empty()) {
     this->instantiateResolutions();
     this->initResolutions();
   }
 
   this->initBC(*this, *displacement, *displacement_increment, *external_force);
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::instantiateResolutions() {
   ParserSection model_section;
   bool is_empty;
   std::tie(model_section, is_empty) = this->getParserSection();
 
   if (not is_empty) {
     auto model_resolutions =
         model_section.getSubSections(ParserType::_contact_resolution);
     for (const auto & section : model_resolutions) {
       this->registerNewResolution(section);
     }
   }
 
   auto sub_sections =
       this->parser.getSubSections(ParserType::_contact_resolution);
   for (const auto & section : sub_sections) {
     this->registerNewResolution(section);
   }
 
   if (resolutions.empty())
     AKANTU_EXCEPTION("No contact resolutions where instantiated for the model"
                      << getID());
   are_resolutions_instantiated = true;
 }
 
 /* -------------------------------------------------------------------------- */
 Resolution &
 ContactMechanicsModel::registerNewResolution(const ParserSection & section) {
   std::string res_name;
   std::string res_type = section.getName();
   std::string opt_param = section.getOption();
 
   try {
     std::string tmp = section.getParameter("name");
     res_name = tmp; /** this can seem weird, but there is an ambiguous operator
                      * overload that i couldn't solve. @todo remove the
                      * weirdness of this code
                      */
   } catch (debug::Exception &) {
     AKANTU_ERROR("A contact resolution of type \'"
                  << res_type
                  << "\' in the input file has been defined without a name!");
   }
   Resolution & res = this->registerNewResolution(res_name, res_type, opt_param);
 
   res.parseSection(section);
 
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 Resolution & ContactMechanicsModel::registerNewResolution(
     const ID & res_name, const ID & res_type, const ID & opt_param) {
   AKANTU_DEBUG_ASSERT(resolutions_names_to_id.find(res_name) ==
                           resolutions_names_to_id.end(),
                       "A resolution with this name '"
                           << res_name << "' has already been registered. "
                           << "Please use unique names for resolutions");
 
   UInt res_count = resolutions.size();
   resolutions_names_to_id[res_name] = res_count;
 
   std::stringstream sstr_res;
   sstr_res << this->id << ":" << res_count << ":" << res_type;
   ID res_id = sstr_res.str();
 
   std::unique_ptr<Resolution> resolution =
       ResolutionFactory::getInstance().allocate(res_type, spatial_dimension,
                                                 opt_param, *this, res_id);
 
   resolutions.push_back(std::move(resolution));
 
   return *(resolutions.back());
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::initResolutions() {
   AKANTU_DEBUG_ASSERT(resolutions.size() != 0,
                       "No resolutions to initialize !");
 
   if (!are_resolutions_instantiated) {
     instantiateResolutions();
   }
 
   // \TODO check if each resolution needs a initResolution() method
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::initModel() {
 
   AKANTU_DEBUG_IN();
 
   getFEEngine("ContactMechanicsModel").initShapeFunctions(_not_ghost);
   getFEEngine("ContactMechanicsModel").initShapeFunctions(_ghost);
 
   getFEEngine("ContactFacetsFEEngine").initShapeFunctions(_not_ghost);
   getFEEngine("ContactFacetsFEEngine").initShapeFunctions(_ghost);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 FEEngine & ContactMechanicsModel::getFEEngineBoundary(const ID & name) {
   return dynamic_cast<FEEngine &>(
       getFEEngineClassBoundary<MyFEEngineType>(name));
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::initSolver(
     TimeStepSolverType /*time_step_solver_type*/, NonLinearSolverType) {
 
   // for alloc type of solvers
   this->allocNodalField(this->displacement, spatial_dimension, "displacement");
   this->allocNodalField(this->displacement_increment, spatial_dimension,
                         "displacement_increment");
   this->allocNodalField(this->internal_force, spatial_dimension,
                         "internal_force");
   this->allocNodalField(this->external_force, spatial_dimension,
                         "external_force");
   this->allocNodalField(this->normal_force, spatial_dimension, "normal_force");
   this->allocNodalField(this->tangential_force, spatial_dimension,
                         "tangential_force");
 
   this->allocNodalField(this->gaps, 1, "gaps");
   this->allocNodalField(this->nodal_area, 1, "areas");
   this->allocNodalField(this->blocked_dofs, 1, "blocked_dofs");
   this->allocNodalField(this->contact_state, 1, "contact_state");
   this->allocNodalField(this->previous_master_elements, 1,
                         "previous_master_elements");
 
   this->allocNodalField(this->normals, spatial_dimension, "normals");
 
   auto surface_dimension = spatial_dimension - 1;
   this->allocNodalField(this->tangents, surface_dimension * spatial_dimension,
                         "tangents");
   this->allocNodalField(this->projections, surface_dimension, "projections");
   this->allocNodalField(this->previous_projections, surface_dimension,
                         "previous_projections");
   this->allocNodalField(this->previous_tangents,
                         surface_dimension * spatial_dimension,
                         "previous_tangents");
   this->allocNodalField(this->tangential_tractions, surface_dimension,
                         "tangential_tractions");
   this->allocNodalField(this->previous_tangential_tractions, surface_dimension,
                         "previous_tangential_tractions");
 
   // todo register multipliers as dofs for lagrange multipliers
 }
 
 /* -------------------------------------------------------------------------- */
 std::tuple<ID, TimeStepSolverType>
 ContactMechanicsModel::getDefaultSolverID(const AnalysisMethod & method) {
   switch (method) {
   case _explicit_lumped_mass: {
     return std::make_tuple("explicit_lumped",
                            TimeStepSolverType::_dynamic_lumped);
   }
   case _explicit_consistent_mass: {
     return std::make_tuple("explicit", TimeStepSolverType::_dynamic);
   }
   case _static: {
     return std::make_tuple("static", TimeStepSolverType::_static);
   }
   case _implicit_dynamic: {
     return std::make_tuple("implicit", TimeStepSolverType::_dynamic);
   }
   default:
     return std::make_tuple("unknown", TimeStepSolverType::_not_defined);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 ModelSolverOptions ContactMechanicsModel::getDefaultSolverOptions(
     const TimeStepSolverType & type) const {
   ModelSolverOptions options;
 
   switch (type) {
   case TimeStepSolverType::_dynamic: {
     options.non_linear_solver_type = NonLinearSolverType::_lumped;
     options.integration_scheme_type["displacement"] =
         IntegrationSchemeType::_central_difference;
     options.solution_type["displacement"] = IntegrationScheme::_acceleration;
     break;
   }
   case TimeStepSolverType::_dynamic_lumped: {
     options.non_linear_solver_type = NonLinearSolverType::_lumped;
     options.integration_scheme_type["displacement"] =
         IntegrationSchemeType::_central_difference;
     options.solution_type["displacement"] = IntegrationScheme::_acceleration;
     break;
   }
   case TimeStepSolverType::_static: {
     options.non_linear_solver_type =
         NonLinearSolverType::_newton_raphson_contact;
     options.integration_scheme_type["displacement"] =
         IntegrationSchemeType::_pseudo_time;
     options.solution_type["displacement"] = IntegrationScheme::_not_defined;
     break;
   }
   default:
     AKANTU_EXCEPTION(type << " is not a valid time step solver type");
     break;
   }
 
   return options;
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::assembleResidual() {
   AKANTU_DEBUG_IN();
 
   /* ------------------------------------------------------------------------ */
   // computes the internal forces
   this->assembleInternalForces();
 
   /* ------------------------------------------------------------------------ */
   this->getDOFManager().assembleToResidual("displacement",
                                            *this->internal_force, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::assembleInternalForces() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Assemble the contact forces");
 
   UInt nb_nodes = mesh.getNbNodes();
   this->internal_force->clear();
   this->normal_force->clear();
   this->tangential_force->clear();
 
   internal_force->resize(nb_nodes, 0.);
   normal_force->resize(nb_nodes, 0.);
   tangential_force->resize(nb_nodes, 0.);
 
   // assemble the forces due to contact
   auto assemble = [&](auto && ghost_type) {
     for (auto & resolution : resolutions) {
       resolution->assembleInternalForces(ghost_type);
     }
   };
 
   AKANTU_DEBUG_INFO("Assemble residual for local elements");
   assemble(_not_ghost);
 
   // assemble the stresses due to ghost elements
   AKANTU_DEBUG_INFO("Assemble residual for ghost elements");
   // assemble(_ghost);
   // TODO : uncomment when developing code for parallelization,
   // currently it addes the force twice for not ghost elements
   // hence source of error
 
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::search() {
 
   // save the previous state
   this->savePreviousState();
 
   contact_elements.clear();
 
   // this needs to be resized if cohesive elements are added
   UInt nb_nodes = mesh.getNbNodes();
 
   auto resize_arrays = [&](auto & internal_array) {
     internal_array->resize(nb_nodes);
     internal_array->zero();
   };
 
   resize_arrays(gaps);
   resize_arrays(normals);
   resize_arrays(tangents);
   resize_arrays(projections);
   resize_arrays(tangential_tractions);
   resize_arrays(contact_state);
   resize_arrays(nodal_area);
   resize_arrays(external_force);
 
   this->detector->search(contact_elements, *gaps, *normals, *tangents,
                          *projections);
 
   // intepenetration value must be positive for contact mechanics
   // model to work by default the gap value from detector is negative
   std::for_each((*gaps).begin(), (*gaps).end(), [](Real & gap) { gap *= -1.; });
 
   if (contact_elements.size() != 0) {
     this->computeNodalAreas();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::savePreviousState() {
 
   AKANTU_DEBUG_IN();
 
   // saving previous natural projections
   (*previous_projections).copy(*projections);
 
   // saving previous tangents
   (*previous_tangents).copy(*tangents);
 
   // saving previous tangential traction
   (*previous_tangential_tractions).copy(*tangential_tractions);
 
   previous_master_elements->clear();
   previous_master_elements->resize(projections->size());
   previous_master_elements->set(ElementNull);
   for (auto & element : contact_elements) {
     (*previous_master_elements)[element.slave] = element.master;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::computeNodalAreas(GhostType ghost_type) {
 
   UInt nb_nodes = mesh.getNbNodes();
 
   nodal_area->resize(nb_nodes);
   nodal_area->zero();
 
   external_force->resize(nb_nodes);
   external_force->zero();
 
   auto & fem_boundary =
       getFEEngineClassBoundary<MyFEEngineType>("ContactMechanicsModel");
 
   fem_boundary.initShapeFunctions(getPositions(), _not_ghost);
   fem_boundary.initShapeFunctions(getPositions(), _ghost);
 
   fem_boundary.computeNormalsOnIntegrationPoints(_not_ghost);
   fem_boundary.computeNormalsOnIntegrationPoints(_ghost);
 
   IntegrationPoint quad_point;
   quad_point.ghost_type = ghost_type;
 
   auto & group = mesh.getElementGroup("contact_surface");
   UInt nb_degree_of_freedom = external_force->getNbComponent();
 
   for (auto && type : group.elementTypes(spatial_dimension - 1, ghost_type)) {
     const auto & element_ids = group.getElements(type, ghost_type);
 
     UInt nb_quad_points = fem_boundary.getNbIntegrationPoints(type, ghost_type);
     UInt nb_elements = element_ids.size();
 
     UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
 
     Array<Real> dual_before_integ(nb_elements * nb_quad_points,
                                   nb_degree_of_freedom, 0.);
     Array<Real> quad_coords(nb_elements * nb_quad_points, spatial_dimension);
 
     const auto & normals_on_quad =
         fem_boundary.getNormalsOnIntegrationPoints(type, ghost_type);
 
     auto normals_begin = normals_on_quad.begin(spatial_dimension);
     decltype(normals_begin) normals_iter;
     auto quad_coords_iter = quad_coords.begin(spatial_dimension);
     auto dual_iter = dual_before_integ.begin(nb_degree_of_freedom);
 
     quad_point.type = type;
 
     Element subelement;
     subelement.type = type;
     subelement.ghost_type = ghost_type;
     for (auto el : element_ids) {
       subelement.element = el;
       const auto & element_to_subelement =
           mesh.getElementToSubelement(type)(el);
 
       Vector<Real> outside(spatial_dimension);
       mesh.getBarycenter(subelement, outside);
 
       Vector<Real> inside(spatial_dimension);
       if (mesh.isMeshFacets()) {
         mesh.getMeshParent().getBarycenter(element_to_subelement[0], inside);
       } else {
         mesh.getBarycenter(element_to_subelement[0], inside);
       }
 
       Vector<Real> inside_to_outside(spatial_dimension);
       inside_to_outside = outside - inside;
 
       normals_iter = normals_begin + el * nb_quad_points;
 
       quad_point.element = el;
       for (auto q : arange(nb_quad_points)) {
         quad_point.num_point = q;
         auto ddot = inside_to_outside.dot(*normals_iter);
         Vector<Real> normal(*normals_iter);
         if (ddot < 0)
           normal *= -1.0;
 
         (*dual_iter)
             .mul<false>(Matrix<Real>::eye(spatial_dimension, 1), normal);
         ++dual_iter;
         ++quad_coords_iter;
         ++normals_iter;
       }
     }
 
     Array<Real> dual_by_shapes(nb_elements * nb_quad_points,
                                nb_degree_of_freedom * nb_nodes_per_element);
 
     fem_boundary.computeNtb(dual_before_integ, dual_by_shapes, type, ghost_type,
                             element_ids);
 
     Array<Real> dual_by_shapes_integ(nb_elements, nb_degree_of_freedom *
                                                       nb_nodes_per_element);
     fem_boundary.integrate(dual_by_shapes, dual_by_shapes_integ,
                            nb_degree_of_freedom * nb_nodes_per_element, type,
                            ghost_type, element_ids);
 
     this->getDOFManager().assembleElementalArrayLocalArray(
         dual_by_shapes_integ, *external_force, type, ghost_type, 1.,
         element_ids);
   }
 
   for (auto && tuple :
        zip(*nodal_area, make_view(*external_force, spatial_dimension))) {
 
     auto & area = std::get<0>(tuple);
     Vector<Real> force(std::get<1>(tuple));
     area = force.norm();
   }
 
   this->external_force->clear();
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::printself(std::ostream & stream, int indent) const {
   std::string space(indent, AKANTU_INDENT);
 
   stream << space << "Contact Mechanics Model [" << std::endl;
   stream << space << " + id                : " << id << std::endl;
   stream << space << " + spatial dimension : " << Model::spatial_dimension
          << std::endl;
   stream << space << " + fem [" << std::endl;
   getFEEngine().printself(stream, indent + 2);
   stream << space << AKANTU_INDENT << "]" << std::endl;
 
   stream << space << " + resolutions [" << std::endl;
   for (auto & resolution : resolutions) {
     resolution->printself(stream, indent + 1);
   }
   stream << space << AKANTU_INDENT << "]" << std::endl;
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 MatrixType ContactMechanicsModel::getMatrixType(const ID & matrix_id) {
   if (matrix_id == "K")
     return _symmetric;
 
   return _mt_not_defined;
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::assembleMatrix(const ID & matrix_id) {
   if (matrix_id == "K") {
     this->assembleStiffnessMatrix();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::assembleStiffnessMatrix() {
-  AKANTU_DEBUG_IN();
-
   AKANTU_DEBUG_INFO("Assemble the new stiffness matrix");
 
   if (!this->getDOFManager().hasMatrix("K")) {
     this->getDOFManager().getNewMatrix("K", getMatrixType("K"));
   }
 
   for (auto & resolution : resolutions) {
     resolution->assembleStiffnessMatrix(_not_ghost);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::assembleLumpedMatrix(const ID & /*matrix_id*/) {
   AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::beforeSolveStep() {
   for (auto & resolution : resolutions) {
     resolution->beforeSolveStep();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::afterSolveStep(bool converged) {
   for (auto & resolution : resolutions) {
     resolution->afterSolveStep(converged);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 #ifdef AKANTU_USE_IOHELPER
 
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field>
 ContactMechanicsModel::createNodalFieldBool(const std::string &,
                                             const std::string &, bool) {
   return nullptr;
 }
 
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field>
 ContactMechanicsModel::createNodalFieldReal(const std::string & field_name,
                                             const std::string & group_name,
                                             bool padding_flag) {
   std::map<std::string, Array<Real> *> real_nodal_fields;
   real_nodal_fields["contact_force"] = this->internal_force.get();
   real_nodal_fields["normal_force"] = this->normal_force.get();
   real_nodal_fields["tangential_force"] = this->tangential_force.get();
   real_nodal_fields["blocked_dofs"] = this->blocked_dofs.get();
   real_nodal_fields["normals"] = this->normals.get();
   real_nodal_fields["tangents"] = this->tangents.get();
   real_nodal_fields["gaps"] = this->gaps.get();
   real_nodal_fields["areas"] = this->nodal_area.get();
   real_nodal_fields["tangential_traction"] = this->tangential_tractions.get();
 
   std::shared_ptr<dumpers::Field> field;
   if (padding_flag) {
     field = this->mesh.createNodalField(real_nodal_fields[field_name],
                                         group_name, 3);
   } else {
     field =
         this->mesh.createNodalField(real_nodal_fields[field_name], group_name);
   }
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field>
 ContactMechanicsModel::createNodalFieldUInt(const std::string & field_name,
                                             const std::string & group_name,
                                             bool /*padding_flag*/) {
   std::shared_ptr<dumpers::Field> field;
   if (field_name == "contact_state") {
     auto && func =
         std::make_unique<dumpers::ComputeUIntFromEnum<ContactState>>();
     field = mesh.createNodalField(this->contact_state.get(), group_name);
     field =
         dumpers::FieldComputeProxy::createFieldCompute(field, std::move(func));
   }
   return field;
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 UInt ContactMechanicsModel::getNbData(
     const Array<Element> & elements, const SynchronizationTag & /*tag*/) const {
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
   UInt nb_nodes_per_element = 0;
 
   for (const Element & el : elements) {
     nb_nodes_per_element += Mesh::getNbNodesPerElement(el.type);
   }
 
   AKANTU_DEBUG_OUT();
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::packData(CommunicationBuffer & /*buffer*/,
                                      const Array<Element> & /*elements*/,
                                      const SynchronizationTag & /*tag*/) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::unpackData(CommunicationBuffer & /*buffer*/,
                                        const Array<Element> & /*elements*/,
                                        const SynchronizationTag & /*tag*/) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 UInt ContactMechanicsModel::getNbData(
     const Array<UInt> & dofs, const SynchronizationTag & /*tag*/) const {
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
 
   AKANTU_DEBUG_OUT();
   return size * dofs.size();
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::packData(CommunicationBuffer & /*buffer*/,
                                      const Array<UInt> & /*dofs*/,
                                      const SynchronizationTag & /*tag*/) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::unpackData(CommunicationBuffer & /*buffer*/,
                                        const Array<UInt> & /*dofs*/,
                                        const SynchronizationTag & /*tag*/) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/src/model/contact_mechanics/contact_mechanics_model.hh b/src/model/contact_mechanics/contact_mechanics_model.hh
index cf3d64b10..f506fb631 100644
--- a/src/model/contact_mechanics/contact_mechanics_model.hh
+++ b/src/model/contact_mechanics/contact_mechanics_model.hh
@@ -1,372 +1,372 @@
 /**
  * @file   contact_mechanics_model.hh
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  *
  * @date creation: Tue Jul 27 2010
  * @date last modification: Wed Feb 21 2018
  *
  * @brief  Model of Contact Mechanics
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2018 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 "boundary_condition.hh"
 #include "contact_detector.hh"
 #include "data_accessor.hh"
 #include "fe_engine.hh"
 #include "model.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_CONTACT_MECHANICS_MODEL_HH__
 #define __AKANTU_CONTACT_MECHANICS_MODEL_HH__
 
 namespace akantu {
 class Resolution;
 template <ElementKind kind, class IntegrationOrderFunctor>
 class IntegratorGauss;
 template <ElementKind kind> class ShapeLagrange;
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 class ContactMechanicsModel : public Model,
                               public DataAccessor<Element>,
                               public DataAccessor<UInt>,
                               public BoundaryCondition<ContactMechanicsModel> {
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
   using MyFEEngineType = FEEngineTemplate<IntegratorGauss, ShapeLagrange>;
 
 public:
   ContactMechanicsModel(
       Mesh & mesh, UInt spatial_dimension = _all_dimensions,
       const ID & id = "contact_mechanics_model",
       std::shared_ptr<DOFManager> dof_manager = nullptr,
       const ModelType model_type = ModelType::_contact_mechanics_model);
 
   ~ContactMechanicsModel() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 protected:
   /// initialize completely the model
   void initFullImpl(const ModelOptions & options) override;
 
   /// allocate all vectors
   void initSolver(TimeStepSolverType, NonLinearSolverType) override;
 
   /// initialize all internal arrays for resolutions
   void initResolutions();
 
   /// initialize the modelType
   void initModel() override;
 
   /// call back for the solver, computes the force residual
   void assembleResidual() override;
 
   /// get the type of matrix needed
   MatrixType getMatrixType(const ID & matrix_id) 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;
 
   /// get some default values for derived classes
   std::tuple<ID, TimeStepSolverType>
   getDefaultSolverID(const AnalysisMethod & method) override;
 
   ModelSolverOptions
   getDefaultSolverOptions(const TimeStepSolverType & type) const 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 converted = true) override;
+  void afterSolveStep(bool converged = true) override;
 
   /// function to print the containt of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
   /* ------------------------------------------------------------------------ */
   /* Contact Detection                                                        */
   /* ------------------------------------------------------------------------ */
 public:
   void search();
 
   void computeNodalAreas(GhostType ghost_type = _not_ghost);
 
   /* ------------------------------------------------------------------------ */
   /* Contact Resolution                                                       */
   /* ------------------------------------------------------------------------ */
 public:
   /// register an empty contact resolution of a given type
   Resolution & registerNewResolution(const ID & res_name, const ID & res_type,
                                      const ID & opt_param);
 
 protected:
   /// register a resolution in the dynamic database
   Resolution & registerNewResolution(const ParserSection & res_section);
 
   /// read the resolution files to instantiate all the resolutions
   void instantiateResolutions();
 
   /// save the parameters from previous state
   void savePreviousState();
 
   /* ------------------------------------------------------------------------ */
   /* Solver Interface                                                         */
   /* ------------------------------------------------------------------------ */
 public:
   /// assembles the contact stiffness matrix
   virtual void assembleStiffnessMatrix();
 
   /// assembles the contant internal forces
   virtual void assembleInternalForces();
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   FEEngine & getFEEngineBoundary(const ID & name = "") override;
 
   /* ------------------------------------------------------------------------ */
   /* Dumpable interface                                                       */
   /* ------------------------------------------------------------------------ */
 public:
 #if defined(AKANTU_USE_IOHELPER)
   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;
 #endif
 
   /* ------------------------------------------------------------------------ */
   /* Data Accessor inherited members                                          */
   /* ------------------------------------------------------------------------ */
 public:
   UInt getNbData(const Array<Element> & elements,
                  const SynchronizationTag & tag) const override;
 
   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;
 
   UInt getNbData(const Array<UInt> & dofs,
                  const SynchronizationTag & tag) const override;
 
   void packData(CommunicationBuffer & buffer, const Array<UInt> & dofs,
                 const SynchronizationTag & tag) const override;
 
   void unpackData(CommunicationBuffer & buffer, const Array<UInt> & dofs,
                   const SynchronizationTag & tag) override;
 
 protected:
   /// contact detection class
   friend class ContactDetector;
 
   /// contact resolution class
   friend class Resolution;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the ContactMechanicsModel::displacement vector
   AKANTU_GET_MACRO(Displacement, *displacement, Array<Real> &);
 
   /// get  the ContactMechanicsModel::increment  vector \warn  only  consistent
   /// if ContactMechanicsModel::setIncrementFlagOn has been called before
   AKANTU_GET_MACRO(Increment, *displacement_increment, Array<Real> &);
 
   /// get the ContactMechanics::internal_force vector (internal forces)
   AKANTU_GET_MACRO(InternalForce, *internal_force, Array<Real> &);
 
   /// get the ContactMechanicsModel::external_force vector (external forces)
   AKANTU_GET_MACRO(ExternalForce, *external_force, Array<Real> &);
 
   /// get the ContactMechanics::normal_force vector (normal forces)
   AKANTU_GET_MACRO(NormalForce, *normal_force, Array<Real> &);
 
   /// get the ContactMechanics::tangential_force vector (friction forces)
   AKANTU_GET_MACRO(TangentialForce, *tangential_force, Array<Real> &);
 
   /// get the ContactMechanics::traction vector (friction traction)
   AKANTU_GET_MACRO(TangentialTractions, *tangential_tractions, Array<Real> &);
 
   /// get the ContactMechanics::previous_tangential_tractions vector
   AKANTU_GET_MACRO(PreviousTangentialTractions, *previous_tangential_tractions,
                    Array<Real> &);
 
   /// get the ContactMechanicsModel::force vector (external forces)
   Array<Real> & getForce() {
     AKANTU_DEBUG_WARNING("getForce was maintained for backward compatibility, "
                          "use getExternalForce instead");
     return *external_force;
   }
 
   /// get the ContactMechanics::blocked_dofs vector
   AKANTU_GET_MACRO(BlockedDOFs, *blocked_dofs, Array<Real> &);
 
   /// get the ContactMechanics::gaps (contact gaps)
   AKANTU_GET_MACRO(Gaps, *gaps, Array<Real> &);
 
   /// get the ContactMechanics::normals (normals on slave nodes)
   AKANTU_GET_MACRO(Normals, *normals, Array<Real> &);
 
   /// get the ContactMechanics::tangents (tangents on slave nodes)
   AKANTU_GET_MACRO(Tangents, *tangents, Array<Real> &);
 
   /// get the ContactMechanics::previous_tangents (tangents on slave nodes)
   AKANTU_GET_MACRO(PreviousTangents, *previous_tangents, Array<Real> &);
 
   /// get the ContactMechanics::areas (nodal areas)
   AKANTU_GET_MACRO(NodalArea, *nodal_area, Array<Real> &);
 
   /// get the ContactMechanics::previous_projections (previous_projections)
   AKANTU_GET_MACRO(PreviousProjections, *previous_projections, Array<Real> &);
 
   /// get the ContactMechanics::projections (projections)
   AKANTU_GET_MACRO(Projections, *projections, Array<Real> &);
 
   /// get the ContactMechanics::contact_state vector (no_contact/stick/slip
   /// state)
   AKANTU_GET_MACRO(ContactState, *contact_state, Array<ContactState> &);
 
   /// get the ContactMechanics::previous_master_elements
   AKANTU_GET_MACRO(PreviousMasterElements, *previous_master_elements,
                    Array<Element> &);
 
   /// get contact detector
   AKANTU_GET_MACRO_NOT_CONST(ContactDetector, *detector, ContactDetector &);
 
   /// get the contact elements
   inline Array<ContactElement> & getContactElements() {
     return contact_elements;
   }
 
   /// get the current positions of the nodes
   inline Array<Real> & getPositions() { return detector->getPositions(); }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// tells if the resolutions are instantiated
   bool are_resolutions_instantiated;
 
   /// displacements array
   std::unique_ptr<Array<Real>> displacement;
 
   /// increment of displacement
   std::unique_ptr<Array<Real>> displacement_increment;
 
   /// contact forces array
   std::unique_ptr<Array<Real>> internal_force;
 
   /// external forces array
   std::unique_ptr<Array<Real>> external_force;
 
   /// normal force array
   std::unique_ptr<Array<Real>> normal_force;
 
   /// friction force array
   std::unique_ptr<Array<Real>> tangential_force;
 
   /// friction traction array
   std::unique_ptr<Array<Real>> tangential_tractions;
 
   /// previous friction traction array
   std::unique_ptr<Array<Real>> previous_tangential_tractions;
 
   /// boundary vector
   std::unique_ptr<Array<Real>> blocked_dofs;
 
   /// array to store gap between slave and master
   std::unique_ptr<Array<Real>> gaps;
 
   /// array to store normals from master to slave
   std::unique_ptr<Array<Real>> normals;
 
   /// array to store tangents on the master element
   std::unique_ptr<Array<Real>> tangents;
 
   /// array to store previous tangents on the master element
   std::unique_ptr<Array<Real>> previous_tangents;
 
   /// array to store nodal areas
   std::unique_ptr<Array<Real>> nodal_area;
 
   /// array to store stick/slip state :
   std::unique_ptr<Array<ContactState>> contact_state;
 
   /// array to store previous projections in covariant basis
   std::unique_ptr<Array<Real>> previous_projections;
 
   // array to store projections in covariant basis
   std::unique_ptr<Array<Real>> projections;
 
   /// contact detection
   std::unique_ptr<ContactDetector> detector;
 
   /// list of contact resolutions
   std::vector<std::unique_ptr<Resolution>> resolutions;
 
   /// mapping between resolution name and resolution internal id
   std::map<std::string, UInt> resolutions_names_to_id;
 
   /// array to store contact elements
   Array<ContactElement> contact_elements;
 
   /// array to store previous master elements
   std::unique_ptr<Array<Element>> previous_master_elements;
 };
 
 } // namespace akantu
 
 /* ------------------------------------------------------------------------ */
 /* inline functions                                                         */
 /* ------------------------------------------------------------------------ */
 #include "parser.hh"
 #include "resolution.hh"
 /* ------------------------------------------------------------------------ */
 
 #endif /* __AKANTU_CONTACT_MECHANICS_MODEL_HH__ */