diff --git a/examples/implicit/implicit_dynamic.cc b/examples/implicit/implicit_dynamic.cc
index 417597edf..6dd55d316 100644
--- a/examples/implicit/implicit_dynamic.cc
+++ b/examples/implicit/implicit_dynamic.cc
@@ -1,148 +1,148 @@
 /**
  * @file   implicit_dynamic.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  *
  * @brief  This code refers to the implicit dynamic example from the user manual
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 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 "communicator.hh"
 #include "non_linear_solver.hh"
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 const Real bar_length = 10.;
 const Real bar_height = 1.;
 const Real bar_depth = 1.;
 const Real F = 5e3;
 const Real L = bar_length;
 const Real I = bar_depth * bar_height * bar_height * bar_height / 12.;
 const Real E = 12e7;
 const Real rho = 1000;
 const Real m = rho * bar_height * bar_depth;
 
 static Real w(UInt n) {
   return n * n * M_PI * M_PI / (L * L) * sqrt(E * I / m);
 }
 
 static Real analytical_solution(Real time) {
   return 2 * F * L * L * L / (pow(M_PI, 4) * E * I) *
          ((1. - cos(w(1) * time)) + (1. - cos(w(3) * time)) / 81. +
           (1. - cos(w(5) * time)) / 625.);
 }
 
 const UInt spatial_dimension = 2;
 const Real time_step = 1e-4;
 const Real max_time = 0.62;
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
 
   initialize("material_dynamic.dat", argc, argv);
 
   Mesh mesh(spatial_dimension);
 
   const auto & comm = Communicator::getStaticCommunicator();
   Int prank = comm.whoAmI();
 
   if (prank == 0)
     mesh.read("beam.msh");
 
   mesh.distribute();
 
   SolidMechanicsModel model(mesh);
 
   /// model initialization
   model.initFull(_analysis_method = _implicit_dynamic);
   Material & mat = model.getMaterial(0);
   mat.setParam("E", E);
   mat.setParam("rho", rho);
 
   Array<Real> & force = model.getForce();
   Array<Real> & displacment = model.getDisplacement();
 
   // boundary conditions
   model.applyBC(BC::Dirichlet::FixedValue(0.0, _x), "blocked");
   model.applyBC(BC::Dirichlet::FixedValue(0.0, _y), "blocked");
   model.applyBC(BC::Dirichlet::FixedValue(0.0, _y), "roller");
 
   const Array<UInt> & trac_nodes = mesh.getElementGroup("traction").getNodes();
 
   bool dump_node = false;
   if (trac_nodes.size() > 0 && mesh.isLocalOrMasterNode(trac_nodes(0))) {
     force(trac_nodes(0), 1) = F;
     dump_node = true;
   }
 
   // output setup
   std::ofstream pos;
   pos.open("position.csv");
   if (!pos.good())
-    AKANTU_DEBUG_ERROR("Cannot open file \"position.csv\"");
+    AKANTU_ERROR("Cannot open file \"position.csv\"");
 
   pos << "id,time,position,solution" << std::endl;
 
   model.setBaseName("dynamic");
   model.addDumpFieldVector("displacement");
   model.addDumpField("velocity");
   model.addDumpField("acceleration");
   model.addDumpField("force");
   model.addDumpField("residual");
   model.dump();
 
   model.setTimeStep(time_step);
 
   auto & solver = model.getNonLinearSolver();
   solver.set("max_iterations", 100);
   solver.set("threshold", 1e-12);
   solver.set("convergence_type", _scc_solution);
 
   /// time loop
   Real time = 0.;
   for (UInt s = 1; time < max_time; ++s, time += time_step) {
     if (prank == 0)
       std::cout << s << "\r" << std::flush;
 
     model.solveStep();
 
     if (dump_node)
       pos << s << "," << time << "," << displacment(trac_nodes(0), 1) << ","
           << analytical_solution(s * time_step) << std::endl;
 
     if (s % 100 == 0)
       model.dump();
   }
 
   std::cout << std::endl;
   pos.close();
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/extra_packages/extra-materials/src/material_FE2/solid_mechanics_model_RVE.cc b/extra_packages/extra-materials/src/material_FE2/solid_mechanics_model_RVE.cc
index 27306a2ed..c8d7ac833 100644
--- a/extra_packages/extra-materials/src/material_FE2/solid_mechanics_model_RVE.cc
+++ b/extra_packages/extra-materials/src/material_FE2/solid_mechanics_model_RVE.cc
@@ -1,553 +1,553 @@
 /**
  * @file   solid_mechanics_model_RVE.cc
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @date   Wed Jan 13 15:32:35 2016
  *
  * @brief  Implementation of SolidMechanicsModelRVE
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 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 "solid_mechanics_model_RVE.hh"
 #include "element_group.hh"
 #include "material_damage_iterative.hh"
 #include "node_group.hh"
 #include "non_linear_solver.hh"
 #include "parser.hh"
 #include "sparse_matrix.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 SolidMechanicsModelRVE::SolidMechanicsModelRVE(Mesh & mesh,
                                                bool use_RVE_mat_selector,
                                                UInt nb_gel_pockets, UInt dim,
                                                const ID & id,
                                                const MemoryID & memory_id)
     : SolidMechanicsModel(mesh, dim, id, memory_id), volume(0.),
       use_RVE_mat_selector(use_RVE_mat_selector),
       nb_gel_pockets(nb_gel_pockets), nb_dumps(0) {
   AKANTU_DEBUG_IN();
   /// find the four corner nodes of the RVE
   findCornerNodes();
 
   /// remove the corner nodes from the surface node groups:
   /// This most be done because corner nodes a not periodic
   mesh.getElementGroup("top").removeNode(corner_nodes(2));
   mesh.getElementGroup("top").removeNode(corner_nodes(3));
   mesh.getElementGroup("left").removeNode(corner_nodes(3));
   mesh.getElementGroup("left").removeNode(corner_nodes(0));
   mesh.getElementGroup("bottom").removeNode(corner_nodes(1));
   mesh.getElementGroup("bottom").removeNode(corner_nodes(0));
   mesh.getElementGroup("right").removeNode(corner_nodes(2));
   mesh.getElementGroup("right").removeNode(corner_nodes(1));
 
   const auto & bottom = mesh.getElementGroup("bottom").getNodeGroup();
   bottom_nodes.insert(bottom.begin(), bottom.end());
 
   const auto & left = mesh.getElementGroup("left").getNodeGroup();
   left_nodes.insert(left.begin(), left.end());
 
   // /// enforce periodicity on the displacement fluctuations
   // auto surface_pair_1 = std::make_pair("top", "bottom");
   // auto surface_pair_2 = std::make_pair("right", "left");
   // SurfacePairList surface_pairs_list;
   // surface_pairs_list.push_back(surface_pair_1);
   // surface_pairs_list.push_back(surface_pair_2);
   // TODO: To Nicolas correct the PBCs
   // this->setPBC(surface_pairs_list);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 SolidMechanicsModelRVE::~SolidMechanicsModelRVE() = default;
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelRVE::initFullImpl(const ModelOptions & options) {
   AKANTU_DEBUG_IN();
 
   auto options_cp(options);
   options_cp.analysis_method = AnalysisMethod::_static;
 
   SolidMechanicsModel::initFullImpl(options_cp);
 
   this->initMaterials();
 
   auto & fem = this->getFEEngine("SolidMechanicsFEEngine");
 
   /// compute the volume of the RVE
   GhostType gt = _not_ghost;
   for (auto element_type : this->mesh.elementTypes(spatial_dimension, gt, _ek_not_defined)) {
     Array<Real> Volume(this->mesh.getNbElement(element_type) *
                            fem.getNbIntegrationPoints(element_type),
                        1, 1.);
     this->volume = fem.integrate(Volume, element_type);
   }
 
   std::cout << "The volume of the RVE is " << this->volume << std::endl;
 
   /// dumping
   std::stringstream base_name;
   base_name << this->id; // << this->memory_id - 1;
   this->setBaseName(base_name.str());
   this->addDumpFieldVector("displacement");
   this->addDumpField("stress");
   this->addDumpField("grad_u");
   this->addDumpField("eigen_grad_u");
   this->addDumpField("blocked_dofs");
   this->addDumpField("material_index");
   this->addDumpField("damage");
   this->addDumpField("Sc");
   this->addDumpField("external_force");
   this->addDumpField("equivalent_stress");
   this->addDumpField("internal_force");
 
   this->dump();
   this->nb_dumps += 1;
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelRVE::applyBoundaryConditions(
     const Matrix<Real> & displacement_gradient) {
   AKANTU_DEBUG_IN();
   /// get the position of the nodes
   const Array<Real> & pos = mesh.getNodes();
   /// storage for the coordinates of a given node and the displacement that will
   /// be applied
   Vector<Real> x(spatial_dimension);
   Vector<Real> appl_disp(spatial_dimension);
 
   /// fix top right node
   UInt node = this->corner_nodes(2);
   x(0) = pos(node, 0);
   x(1) = pos(node, 1);
   appl_disp.mul<false>(displacement_gradient, x);
   (*this->blocked_dofs)(node, 0) = true;
   (*this->displacement)(node, 0) = appl_disp(0);
   (*this->blocked_dofs)(node, 1) = true;
   (*this->displacement)(node, 1) = appl_disp(1);
   // (*this->blocked_dofs)(node,0) = true; (*this->displacement)(node,0) = 0.;
   // (*this->blocked_dofs)(node,1) = true; (*this->displacement)(node,1) = 0.;
 
   /// apply Hx at all the other corner nodes; H: displ. gradient
   node = this->corner_nodes(0);
   x(0) = pos(node, 0);
   x(1) = pos(node, 1);
   appl_disp.mul<false>(displacement_gradient, x);
   (*this->blocked_dofs)(node, 0) = true;
   (*this->displacement)(node, 0) = appl_disp(0);
   (*this->blocked_dofs)(node, 1) = true;
   (*this->displacement)(node, 1) = appl_disp(1);
 
   node = this->corner_nodes(1);
   x(0) = pos(node, 0);
   x(1) = pos(node, 1);
   appl_disp.mul<false>(displacement_gradient, x);
   (*this->blocked_dofs)(node, 0) = true;
   (*this->displacement)(node, 0) = appl_disp(0);
   (*this->blocked_dofs)(node, 1) = true;
   (*this->displacement)(node, 1) = appl_disp(1);
 
   node = this->corner_nodes(3);
   x(0) = pos(node, 0);
   x(1) = pos(node, 1);
   appl_disp.mul<false>(displacement_gradient, x);
   (*this->blocked_dofs)(node, 0) = true;
   (*this->displacement)(node, 0) = appl_disp(0);
   (*this->blocked_dofs)(node, 1) = true;
   (*this->displacement)(node, 1) = appl_disp(1);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelRVE::findCornerNodes() {
   AKANTU_DEBUG_IN();
 
   // find corner nodes
   const auto & position = mesh.getNodes();
   const auto & lower_bounds = mesh.getLowerBounds();
   const auto & upper_bounds = mesh.getUpperBounds();
 
   AKANTU_DEBUG_ASSERT(spatial_dimension == 2, "This is 2D only!");
   corner_nodes.resize(4);
   corner_nodes.set(UInt(-1));
 
   for (auto && data : enumerate(make_view(position, spatial_dimension))) {
     auto node = std::get<0>(data);
     const auto & X = std::get<1>(data);
 
     auto distance = X.distance(lower_bounds);
     // node 1
     if (Math::are_float_equal(distance, 0)) {
       corner_nodes(0) = node;
     }
     // node 2
     else if (Math::are_float_equal(X(_x), upper_bounds(_x)) &&
              Math::are_float_equal(X(_y), lower_bounds(_y))) {
       corner_nodes(1) = node;
     }
     // node 3
     else if (Math::are_float_equal(X(_x), upper_bounds(_x)) &&
              Math::are_float_equal(X(_y), upper_bounds(_y))) {
       corner_nodes(2) = node;
     }
     // node 4
     else if (Math::are_float_equal(X(_x), lower_bounds(_x)) &&
              Math::are_float_equal(X(_y), upper_bounds(_y))) {
       corner_nodes(3) = node;
     }
   }
 
   for (UInt i = 0; i < corner_nodes.size(); ++i) {
     if (corner_nodes(i) == UInt(-1))
-      AKANTU_DEBUG_ERROR("The corner node " << i + 1 << " wasn't found");
+      AKANTU_ERROR("The corner node " << i + 1 << " wasn't found");
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelRVE::advanceASR(const Matrix<Real> & prestrain) {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG_ASSERT(spatial_dimension == 2, "This is 2D only!");
 
   /// apply the new eigenstrain
   for (auto element_type : mesh.elementTypes(_element_kind = _ek_not_defined)) {
     Array<Real> & prestrain_vect =
         const_cast<Array<Real> &>(this->getMaterial("gel").getInternal<Real>(
             "eigen_grad_u")(element_type));
     auto prestrain_it =
         prestrain_vect.begin(spatial_dimension, spatial_dimension);
     auto prestrain_end =
         prestrain_vect.end(spatial_dimension, spatial_dimension);
 
     for (; prestrain_it != prestrain_end; ++prestrain_it)
       (*prestrain_it) = prestrain;
   }
 
   /// advance the damage
   MaterialDamageIterative<2> & mat_paste =
       dynamic_cast<MaterialDamageIterative<2> &>(*this->materials[1]);
   MaterialDamageIterative<2> & mat_aggregate =
       dynamic_cast<MaterialDamageIterative<2> &>(*this->materials[0]);
   UInt nb_damaged_elements = 0;
   Real max_eq_stress_aggregate = 0;
   Real max_eq_stress_paste = 0;
 
   auto & solver = this->getNonLinearSolver();
   solver.set("max_iterations", 2);
   solver.set("threshold", 1e-6);
   solver.set("convergence_type", _scc_solution);
 
   do {
     this->solveStep();
 
     /// compute damage
     max_eq_stress_aggregate = mat_aggregate.getNormMaxEquivalentStress();
     max_eq_stress_paste = mat_paste.getNormMaxEquivalentStress();
 
     nb_damaged_elements = 0;
     if (max_eq_stress_aggregate > max_eq_stress_paste)
       nb_damaged_elements = mat_aggregate.updateDamage();
     else if (max_eq_stress_aggregate < max_eq_stress_paste)
       nb_damaged_elements = mat_paste.updateDamage();
     else
       nb_damaged_elements =
           (mat_paste.updateDamage() + mat_aggregate.updateDamage());
 
     std::cout << "the number of damaged elements is " << nb_damaged_elements
               << std::endl;
   } while (nb_damaged_elements);
 
   if (this->nb_dumps % 10 == 0) {
     this->dump();
   }
   this->nb_dumps += 1;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModelRVE::averageTensorField(UInt row_index, UInt col_index,
                                                 const ID & field_type) {
   AKANTU_DEBUG_IN();
   auto & fem = this->getFEEngine("SolidMechanicsFEEngine");
   Real average = 0;
 
   for (auto element_type : mesh.elementTypes(_element_kind = _ek_not_defined)) {
     if (field_type == "stress") {
       for (UInt m = 0; m < this->materials.size(); ++m) {
         const auto & stress_vec = this->materials[m]->getStress(element_type);
         const auto & elem_filter =
             this->materials[m]->getElementFilter(element_type);
         Array<Real> int_stress_vec(elem_filter.size(),
                                    spatial_dimension * spatial_dimension,
                                    "int_of_stress");
 
         fem.integrate(stress_vec, int_stress_vec,
                       spatial_dimension * spatial_dimension, element_type,
                       _not_ghost, elem_filter);
 
         for (UInt k = 0; k < elem_filter.size(); ++k)
           average += int_stress_vec(
               k, row_index * spatial_dimension + col_index); // 3 is the value
                                                              // for the yy (in
                                                              // 3D, the value is
                                                              // 4)
       }
     } else if (field_type == "strain") {
       for (UInt m = 0; m < this->materials.size(); ++m) {
         const auto & gradu_vec = this->materials[m]->getGradU(element_type);
         const auto & elem_filter =
             this->materials[m]->getElementFilter(element_type);
         Array<Real> int_gradu_vec(elem_filter.size(),
                                   spatial_dimension * spatial_dimension,
                                   "int_of_gradu");
 
         fem.integrate(gradu_vec, int_gradu_vec,
                       spatial_dimension * spatial_dimension, element_type,
                       _not_ghost, elem_filter);
 
         for (UInt k = 0; k < elem_filter.size(); ++k)
           /// averaging is done only for normal components, so stress and strain
           /// are equal
           average +=
               0.5 *
               (int_gradu_vec(k, row_index * spatial_dimension + col_index) +
                int_gradu_vec(k, col_index * spatial_dimension + row_index));
       }
     } else if (field_type == "eigen_grad_u") {
       for (UInt m = 0; m < this->materials.size(); ++m) {
         const auto & eigen_gradu_vec =
             this->materials[m]->getInternal<Real>("eigen_grad_u")(element_type);
         const auto & elem_filter =
             this->materials[m]->getElementFilter(element_type);
         Array<Real> int_eigen_gradu_vec(elem_filter.size(),
                                         spatial_dimension * spatial_dimension,
                                         "int_of_gradu");
 
         fem.integrate(eigen_gradu_vec, int_eigen_gradu_vec,
                       spatial_dimension * spatial_dimension, element_type,
                       _not_ghost, elem_filter);
 
         for (UInt k = 0; k < elem_filter.size(); ++k)
           /// averaging is done only for normal components, so stress and strain
           /// are equal
           average +=
               int_eigen_gradu_vec(k, row_index * spatial_dimension + col_index);
       }
     } else {
-      AKANTU_DEBUG_ERROR("Averaging not implemented for this field!!!");
+      AKANTU_ERROR("Averaging not implemented for this field!!!");
     }
   }
 
   return average / this->volume;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelRVE::homogenizeStiffness(Matrix<Real> & C_macro) {
   AKANTU_DEBUG_IN();
   const UInt dim = 2;
   AKANTU_DEBUG_ASSERT(this->spatial_dimension == dim,
                       "Is only implemented for 2D!!!");
 
   /// apply three independent loading states to determine C
   /// 1. eps_el = (1;0;0) 2. eps_el = (0,1,0) 3. eps_el = (0,0,0.5)
 
   /// clear the eigenstrain
   Matrix<Real> zero_eigengradu(dim, dim, 0.);
   GhostType gt = _not_ghost;
   for (auto element_type : mesh.elementTypes(dim, gt, _ek_not_defined)) {
     auto & prestrain_vect =
         const_cast<Array<Real> &>(this->getMaterial("gel").getInternal<Real>(
             "eigen_grad_u")(element_type));
     auto prestrain_it =
         prestrain_vect.begin(spatial_dimension, spatial_dimension);
     auto prestrain_end =
         prestrain_vect.end(spatial_dimension, spatial_dimension);
 
     for (; prestrain_it != prestrain_end; ++prestrain_it)
       (*prestrain_it) = zero_eigengradu;
   }
 
   /// storage for results of 3 different loading states
   UInt voigt_size = VoigtHelper<dim>::size;
   Matrix<Real> stresses(voigt_size, voigt_size, 0.);
   Matrix<Real> strains(voigt_size, voigt_size, 0.);
   Matrix<Real> H(dim, dim, 0.);
 
   /// save the damage state before filling up cracks
   // ElementTypeMapReal saved_damage("saved_damage");
   // saved_damage.initialize(getFEEngine(), _nb_component = 1, _default_value =
   // 0);
   // this->fillCracks(saved_damage);
 
   /// virtual test 1:
   H(0, 0) = 0.01;
   this->performVirtualTesting(H, stresses, strains, 0);
 
   /// virtual test 2:
   H.clear();
   H(1, 1) = 0.01;
   this->performVirtualTesting(H, stresses, strains, 1);
 
   /// virtual test 3:
   H.clear();
   H(0, 1) = 0.01;
   this->performVirtualTesting(H, stresses, strains, 2);
 
   /// drain cracks
   // this->drainCracks(saved_damage);
   /// compute effective stiffness
   Matrix<Real> eps_inverse(voigt_size, voigt_size);
   eps_inverse.inverse(strains);
   C_macro.mul<false, false>(stresses, eps_inverse);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelRVE::performVirtualTesting(const Matrix<Real> & H,
                                                    Matrix<Real> & eff_stresses,
                                                    Matrix<Real> & eff_strains,
                                                    const UInt test_no) {
   AKANTU_DEBUG_IN();
   this->applyBoundaryConditions(H);
 
   auto & solver = this->getNonLinearSolver();
   solver.set("max_iterations", 2);
   solver.set("threshold", 1e-6);
   solver.set("convergence_type", _scc_solution);
   this->solveStep();
 
   /// get average stress and strain
   eff_stresses(0, test_no) = this->averageTensorField(0, 0, "stress");
   eff_strains(0, test_no) = this->averageTensorField(0, 0, "strain");
   eff_stresses(1, test_no) = this->averageTensorField(1, 1, "stress");
   eff_strains(1, test_no) = this->averageTensorField(1, 1, "strain");
   eff_stresses(2, test_no) = this->averageTensorField(1, 0, "stress");
   eff_strains(2, test_no) = 2. * this->averageTensorField(1, 0, "strain");
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelRVE::homogenizeEigenGradU(
     Matrix<Real> & eigen_gradu_macro) {
   AKANTU_DEBUG_IN();
   eigen_gradu_macro(0, 0) = this->averageTensorField(0, 0, "eigen_grad_u");
   eigen_gradu_macro(1, 1) = this->averageTensorField(1, 1, "eigen_grad_u");
   eigen_gradu_macro(0, 1) = this->averageTensorField(0, 1, "eigen_grad_u");
   eigen_gradu_macro(1, 0) = this->averageTensorField(1, 0, "eigen_grad_u");
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelRVE::initMaterials() {
   AKANTU_DEBUG_IN();
 
   // make sure the material are instantiated
   if (!are_materials_instantiated)
     instantiateMaterials();
 
   if (use_RVE_mat_selector) {
     const Vector<Real> & lowerBounds = mesh.getLowerBounds();
     const Vector<Real> & upperBounds = mesh.getUpperBounds();
     Real bottom = lowerBounds(1);
     Real top = upperBounds(1);
     Real box_size = std::abs(top - bottom);
     Real eps = box_size * 1e-6;
 
     auto tmp = std::make_shared<GelMaterialSelector>(*this, box_size, "gel",
                                                      this->nb_gel_pockets, eps);
     tmp->setFallback(material_selector);
     material_selector = tmp;
   }
 
   SolidMechanicsModel::initMaterials();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelRVE::fillCracks(ElementTypeMapReal & saved_damage) {
   const auto & mat_gel = this->getMaterial("gel");
   Real E_gel = mat_gel.get("E");
   Real E_homogenized = 0.;
 
   for (auto && mat : materials) {
     if (mat->getName() == "gel" || mat->getName() == "FE2_mat")
       continue;
 
     Real E = mat->get("E");
     auto & damage = mat->getInternal<Real>("damage");
 
     for (auto && type : damage.elementTypes()) {
       const auto & elem_filter = mat->getElementFilter(type);
       auto nb_integration_point = getFEEngine().getNbIntegrationPoints(type);
 
       auto sav_dam_it =
           make_view(saved_damage(type), nb_integration_point).begin();
       for (auto && data :
            zip(elem_filter, make_view(damage(type), nb_integration_point))) {
         auto el = std::get<0>(data);
         auto & dam = std::get<1>(data);
         Vector<Real> sav_dam = sav_dam_it[el];
 
         sav_dam = dam;
 
         for (auto q : arange(dam.size())) {
           E_homogenized = (E_gel - E) * dam(q) + E;
           dam(q) = 1. - (E_homogenized / E);
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelRVE::drainCracks(
     const ElementTypeMapReal & saved_damage) {
   for (auto && mat : materials) {
     if (mat->getName() == "gel" || mat->getName() == "FE2_mat")
       continue;
     auto & damage = mat->getInternal<Real>("damage");
 
     for (auto && type : damage.elementTypes()) {
       const auto & elem_filter = mat->getElementFilter(type);
       auto nb_integration_point = getFEEngine().getNbIntegrationPoints(type);
 
       auto sav_dam_it = make_view(saved_damage(type), nb_integration_point).begin();
       for (auto && data :
            zip(elem_filter, make_view(damage(type), nb_integration_point))) {
         auto el = std::get<0>(data);
         auto & dam = std::get<1>(data);
         Vector<Real> sav_dam = sav_dam_it[el];
 
         dam = sav_dam;
       }
     }
   }
 }
 
 } // namespace akantu
diff --git a/extra_packages/extra-materials/src/material_damage/material_vreepeerlings_inline_impl.cc b/extra_packages/extra-materials/src/material_damage/material_vreepeerlings_inline_impl.cc
index 201eb94bc..8b15de85b 100644
--- a/extra_packages/extra-materials/src/material_damage/material_vreepeerlings_inline_impl.cc
+++ b/extra_packages/extra-materials/src/material_damage/material_vreepeerlings_inline_impl.cc
@@ -1,177 +1,177 @@
 /**
  * @file   material_vreepeerlings_inline_impl.cc
  *
  * @author Cyprien Wolff <cyprien.wolff@epfl.ch>
  *
  *
  * @brief  Specialization of the material class for the VreePeerlings material
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 
 /* -------------------------------------------------------------------------- */
 
 template<UInt spatial_dimension, template <UInt> class MatParent>
 inline void
 MaterialVreePeerlings<spatial_dimension, MatParent>::computeStressOnQuad(Matrix<Real> & grad_u,
                                                                          Matrix<Real> & sigma,
                                                                          Real & dam,
                                                                          Real & Equistrain,
                                                                          Real & Equistrain_rate,
                                                                          Real & Kapaq,
                                                                          Real dt,
                                                                          Matrix<Real> & strain_rate_vrplgs,
                                                                          Real & FullDam_ValStrain,
                                                                          Real & FullDam_ValStrain_rate,
                                                                          Real & Nb_damage) {
 
 
   Real I1=0.;      /// trace initialization of the strain tensor
   Real J2=0.;      /// J2 [J2=1/6(3 strain:strain - I1*I1)] initialization
   Real I1rate=0.;  /// trace initialization of the strain rate tensor
   Real J2rate=0.;  /// J2 [J2=1/3(3 strain:strainrate - I1*I1rate)] initialization
 
   if (spatial_dimension == 1){
 
     I1 = grad_u.trace();
     J2 = .5*grad_u(0,0)*grad_u(0,0) - I1 * I1/6.;
 
     I1rate = strain_rate_vrplgs.trace();
     J2rate = grad_u(0,0)*strain_rate_vrplgs(0,0) -I1 * I1rate/6.;
   }
   else {
     // if(this->plane_stress) {
 
     //   Real tmp = this->nu/(this->nu - 1);
     //   tmp *= tmp;
 
     //   I1 = (grad_u(0,0) + grad_u(1,1))*(1 - 2*this->nu)/(1 - this->nu);
     //   J2 = .5*(grad_u(0,0)*grad_u(0,0) +
     //            grad_u(1,1)*grad_u(1,1) +
     //            tmp*(grad_u(0,0) + grad_u(1,1))*(grad_u(0,0) + grad_u(1,1)) +
     //            .5*(grad_u(0,1) + grad_u(1,0))*(grad_u(0,1) + grad_u(1,0))) -
     //     I1*I1/6.;
 
     //   I1rate = (strain_rate_vrplgs(0,0) + strain_rate_vrplgs(1,1))*(1 - 2*this->nu)/(1 - this->nu);
     //   J2rate = (grad_u(0,0)*strain_rate_vrplgs(0,0) +
     //             grad_u(1,1)*strain_rate_vrplgs(1,1) +
     //             tmp*(grad_u(0,0) + grad_u(1,1))*(strain_rate_vrplgs(0,0) + strain_rate_vrplgs(1,1)) +
     //             (grad_u(0,1)*strain_rate_vrplgs(1,0)) + (grad_u(0,1)*strain_rate_vrplgs(1,0))) -
     //     I1*I1rate/3.;
 
     // }
     // else {
 
       I1 = grad_u.trace();
       for(UInt i=0; i<spatial_dimension; ++i )
         for(UInt j=i; j<spatial_dimension; ++j )
           J2 += 0.5*( (i==j)*grad_u(i,i)*grad_u(i,i) +0.5*(1- (i==j))*( (grad_u(i,j) + grad_u(j,i))*(grad_u(i,j) + grad_u(j,i)) ));
 
       J2-= I1 * I1/6.;
 
       I1rate = strain_rate_vrplgs.trace();
       bool is3D= spatial_dimension==3;
       J2rate = (grad_u(0,0)*strain_rate_vrplgs(0,0) +
                 grad_u(1,1)*strain_rate_vrplgs(1,1) +
                 is3D * grad_u(2,2)*strain_rate_vrplgs(2,2) +
                 (grad_u(0,1)*strain_rate_vrplgs(1,0)) + (grad_u(0,1)*strain_rate_vrplgs(1,0)) +
                 is3D * (grad_u(1,2)*strain_rate_vrplgs(2,1)) + is3D * (grad_u(1,2)*strain_rate_vrplgs(2,1)) +
                 is3D * (grad_u(2,0)*strain_rate_vrplgs(0,2)) + is3D * (grad_u(2,0)*strain_rate_vrplgs(0,2))) -
         I1 * I1rate/3.;
 
       //    }
   }
 
   Real tmp_1 = (Kct - 1)/(1 - 2*this->nu);
   Real tmp_2 = (12 * Kct)/((1 + this->nu)*(1 + this->nu));
 
   Equistrain = tmp_1 * I1 / (2*Kct) + 1./(2*Kct) * std::sqrt(tmp_1*tmp_1*I1*I1 + tmp_2*J2);
 
   if(I1 * I1rate > 0 || J2rate > 0){
     Equistrain_rate =tmp_1 * std::abs(I1rate) / (2*Kct) + 1./(4*Kct)*(2*tmp_1*tmp_1*I1*I1rate + tmp_2*J2rate) / std::sqrt(tmp_1*tmp_1*I1*I1 + tmp_2*J2);
   }else{
-    AKANTU_DEBUG_ERROR("This instruction here was commented but has to be checked");
+    AKANTU_ERROR("This instruction here was commented but has to be checked");
     //Equistrain_rate = Equistrain_rate;
   }
 
   if(!this->is_non_local) {
     computeDamageAndStressOnQuad(sigma, dam, Equistrain, Equistrain_rate, Kapaq, dt, FullDam_ValStrain, FullDam_ValStrain_rate, Nb_damage);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template<UInt spatial_dimension, template <UInt> class MatParent>
 inline void
 MaterialVreePeerlings<spatial_dimension, MatParent>::computeDamageAndStressOnQuad(Matrix<Real> & sigma,
                                                                                   Real & dam,
                                                                                   Real & Equistrain,
                                                                                   Real & Equistrain_rate,
                                                                                   Real & Kapaq,
                                                                                   Real dt,
                                                                                   Real & FullDam_ValStrain,
                                                                                   Real & FullDam_ValStrain_rate,
                                                                                   Real & Nb_damage) {
 
 
   //---------------------------------------------------------------------------------------
   // rate-dependence  model
   //
   //---------------------------------------------------------------------------------------
   Real Kapao = Crate*(1.+(std::pow(std::abs(Equistrain_rate)*Arate,Brate)))*(1.-Kapao_randomness) + Kapao_randomness*Kapaq;
   Real Kapac_99 = Kapac*.99;
   Real Kapaodyn = 0;
   if (Kapao > Kapaoi) {
     if (Kapao < Kapac_99) {
       Kapaodyn = Kapao;
     } else {
       Kapaodyn = Kapac_99;
     }
   } else {
     Kapaodyn = Kapaoi;
   }
 
   Real Fd1 = Equistrain - Kapaoi;
   if (Fd1 > 0)
     {
       Real dam1 = 1. - Kapaodyn/Equistrain * ((Kapac - Equistrain)/(Kapac - Kapaodyn));
       if (dam1 > dam){
         dam = std::min(dam1,1.);
         Nb_damage = Nb_damage + 1.;
 
         if (dam >= 1.){
           FullDam_ValStrain = Equistrain;
           FullDam_ValStrain_rate = Equistrain_rate;
         }
       }
     }
 
   //---------------------------------------------------------------------------------------
   // delayed damage (see Marions thesis page 68)
   //---------------------------------------------------------------------------------------
   //   Real viscosity = 10.;
   //   Real damRateInfini = 10000000.;
   //   Real gequi = 1. - Kapaq/Equistrain * ((Kapac-Equistrain)/(Kapac - Kapaq));
   //   if (gequi - dam > 0){
   //
   //     Real damRate = damRateInfini * (1. - std::exp(-1*viscosity * (gequi - dam)));
   //     if (damrate > 0){
   //
   //	if (dam < 1.){
   //      dam = dam + damRate*dt;
   //	} else {
   //      dam = 1.;
   //	}
   //     }
   //   }
   //
   //---------------------------------------------------------------------------------------
   sigma *= 1-dam;
 }
 /* -------------------------------------------------------------------------- */
diff --git a/extra_packages/parallel-cohesive-element/test/test_data_accessor.hh b/extra_packages/parallel-cohesive-element/test/test_data_accessor.hh
index ec366590e..7ac9bdd60 100644
--- a/extra_packages/parallel-cohesive-element/test/test_data_accessor.hh
+++ b/extra_packages/parallel-cohesive-element/test/test_data_accessor.hh
@@ -1,134 +1,134 @@
 /**
  * @file   test_data_accessor.hh
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Apr 11 2013
  * @date last modification: Thu Jun 05 2014
  *
  * @brief  Data Accessor class for testing
  *
  * @section LICENSE
  *
  * Copyright (©) 2014 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 "aka_common.hh"
 #include "mesh.hh"
 #include "data_accessor.hh"
 
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 class TestAccessor : public DataAccessor {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   inline TestAccessor(const Mesh & mesh, const ElementTypeMapArray<Real> & barycenters);
 
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Barycenter, barycenters, Real);
 
   /* ------------------------------------------------------------------------ */
   /* Ghost Synchronizer inherited members                                     */
   /* ------------------------------------------------------------------------ */
 protected:
   inline UInt getNbDataForElements(const Array<Element> & elements,
 				   SynchronizationTag tag) const;
   inline void packElementData(CommunicationBuffer & buffer,
 			      const Array<Element> & elements,
 			      SynchronizationTag tag) const;
   inline void unpackElementData(CommunicationBuffer & buffer,
 				const Array<Element> & elements,
 				SynchronizationTag tag);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   const ElementTypeMapArray<Real> & barycenters;
   const Mesh & mesh;
 };
 
 
 /* -------------------------------------------------------------------------- */
 /* TestSynchronizer implementation                                            */
 /* -------------------------------------------------------------------------- */
 inline TestAccessor::TestAccessor(const Mesh & mesh,
 				  const ElementTypeMapArray<Real> & barycenters)
   : barycenters(barycenters), mesh(mesh) { }
 
 inline UInt TestAccessor::getNbDataForElements(const Array<Element> & elements,
 					       __attribute__ ((unused)) SynchronizationTag tag) const {
   if(elements.getSize())
     // return Mesh::getSpatialDimension(elements(0).type) * sizeof(Real) * elements.getSize();
     return mesh.getSpatialDimension() * sizeof(Real) * elements.getSize();
   else
     return 0;
 }
 
 inline void TestAccessor::packElementData(CommunicationBuffer & buffer,
 					  const Array<Element> & elements,
 					  __attribute__ ((unused)) SynchronizationTag tag) const {
   UInt spatial_dimension = mesh.getSpatialDimension();
   Array<Element>::const_iterator<Element> bit  = elements.begin();
   Array<Element>::const_iterator<Element> bend = elements.end();
   for (; bit != bend; ++bit) {
     const Element & element = *bit;
 
     Vector<Real> bary(this->barycenters(element.type, element.ghost_type).storage()
 		      + element.element * spatial_dimension,
 		      spatial_dimension);
     buffer << bary;
   }
 }
 
 inline void TestAccessor::unpackElementData(CommunicationBuffer & buffer,
 					    const Array<Element> & elements,
 					    __attribute__ ((unused)) SynchronizationTag tag) {
   UInt spatial_dimension = mesh.getSpatialDimension();
   Array<Element>::const_iterator<Element> bit  = elements.begin();
   Array<Element>::const_iterator<Element> bend = elements.end();
   for (; bit != bend; ++bit) {
     const Element & element = *bit;
 
     Vector<Real> barycenter_loc(this->barycenters(element.type, element.ghost_type).storage()
 				+ element.element * spatial_dimension,
 				spatial_dimension);
 
     Vector<Real> bary(spatial_dimension);
     buffer >> bary;
     std::cout << element << barycenter_loc << std::endl;
     Real tolerance = 1e-15;
     for (UInt i = 0; i < spatial_dimension; ++i) {
       if(!(std::abs(bary(i) - barycenter_loc(i)) <= tolerance))
-        AKANTU_DEBUG_ERROR("Unpacking an unknown value for the element: "
+        AKANTU_ERROR("Unpacking an unknown value for the element: "
                            << element
                            << "(barycenter = " << barycenter_loc
                            << " and buffer = " << bary << ") direction (" << i << ")- tag: " << tag);
     }
   }
 }
 
 
 } // namespace akantu
diff --git a/extra_packages/traction-at-split-node-contact/src/functions/boundary_functions.cc b/extra_packages/traction-at-split-node-contact/src/functions/boundary_functions.cc
index 2b2185404..0594b0743 100644
--- a/extra_packages/traction-at-split-node-contact/src/functions/boundary_functions.cc
+++ b/extra_packages/traction-at-split-node-contact/src/functions/boundary_functions.cc
@@ -1,63 +1,63 @@
 /**
  * @file   boundary_functions.cc
  *
  *
  *
  * @brief  
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 
 #include "boundary_functions.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Real integrateResidual(const std::string & sub_boundary_name,
 		       const SolidMechanicsModel & model,
 		       UInt dir) {
   Real int_res = 0.;
   
   const Mesh & mesh = model.getMesh();
   const Array<Real> & residual = model.getResidual();
 
   // do not need try catch, as all subboundaries should be everywhere. 
   //  try {
   const ElementGroup & boundary = mesh.getElementGroup(sub_boundary_name);
   ElementGroup::const_node_iterator nit  = boundary.node_begin();
   ElementGroup::const_node_iterator nend = boundary.node_end();
   for (; nit != nend; ++nit) {
     bool is_local_node = mesh.isLocalOrMasterNode(*nit);
     if (is_local_node) {
       int_res += residual(*nit, dir);
     }
   }
   // } catch(debug::Exception e) {
-  //   // AKANTU_DEBUG_ERROR("Error computing integrateResidual. Cannot get SubBoundary: " 
+  //   // AKANTU_ERROR("Error computing integrateResidual. Cannot get SubBoundary: " 
   //   // 		       << sub_boundary_name << " [" << e.what() << "]");
   // }
 
   StaticCommunicator::getStaticCommunicator().allReduce(&int_res, 1, _so_sum);
   return int_res;
 }
 
 /* -------------------------------------------------------------------------- */
 void boundaryFix(Mesh & mesh, 
 		 const std::vector<std::string> & sub_boundary_names) {
   
    std::vector<std::string>::const_iterator it  = sub_boundary_names.begin();
   std::vector<std::string>::const_iterator end = sub_boundary_names.end();
 
   for (; it != end; ++it) {
     if (mesh.element_group_find(*it) == mesh.element_group_end()) {
       mesh.createElementGroup(*it,mesh.getSpatialDimension()-1); // empty element group
     }
   }
 }
 
 
 } // namespace akantu
diff --git a/extra_packages/traction-at-split-node-contact/src/functions/node_filter.hh b/extra_packages/traction-at-split-node-contact/src/functions/node_filter.hh
index 175d71d1a..daad5b664 100644
--- a/extra_packages/traction-at-split-node-contact/src/functions/node_filter.hh
+++ b/extra_packages/traction-at-split-node-contact/src/functions/node_filter.hh
@@ -1,106 +1,98 @@
 /**
  * @file   node_filter.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  *
  * @brief  to filter nodes with functors
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __AST_NODE_FILTER_HH__
 #define __AST_NODE_FILTER_HH__
 
 /* -------------------------------------------------------------------------- */
 // akantu
 #include "aka_common.hh"
 #include "mesh_filter.hh"
 
-
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 class GeometryFilter : public NodeFilterFunctor {
 
 public:
-  GeometryFilter(const Mesh & mesh,
-		 UInt dir,
-		 Real limit) :
-    NodeFilterFunctor(),
-    mesh(mesh), dir(dir), limit(limit) { 
+  GeometryFilter(const Mesh & mesh, UInt dir, Real limit)
+      : NodeFilterFunctor(), mesh(mesh), dir(dir), limit(limit) {
     this->positions = &(mesh.getNodes());
   };
-  ~GeometryFilter() {};
-  
-  bool operator() (UInt node) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
-  };
+  ~GeometryFilter(){};
+
+  bool operator()(UInt node) { AKANTU_TO_IMPLEMENT(); };
 
 protected:
   const Mesh & mesh;
   UInt dir;
   Real limit;
   const Array<Real> * positions;
 };
 
 /* -------------------------------------------------------------------------- */
 class FilterPositionsGreaterThan : public GeometryFilter {
 public:
-  FilterPositionsGreaterThan(const Mesh & mesh,
-			     UInt dir,
-			     Real limit) : GeometryFilter(mesh, dir, limit) {};
-  ~FilterPositionsGreaterThan() {};
+  FilterPositionsGreaterThan(const Mesh & mesh, UInt dir, Real limit)
+      : GeometryFilter(mesh, dir, limit){};
+  ~FilterPositionsGreaterThan(){};
 
-  bool operator() (UInt node) {
+  bool operator()(UInt node) {
     AKANTU_DEBUG_IN();
     bool to_filter = true;
-    if((*this->positions)(node,this->dir) > this->limit)
+    if ((*this->positions)(node, this->dir) > this->limit)
       to_filter = false;
     AKANTU_DEBUG_OUT();
     return to_filter;
   };
 };
 
 /* -------------------------------------------------------------------------- */
 class FilterPositionsLessThan : public GeometryFilter {
 public:
-  FilterPositionsLessThan(const Mesh & mesh,
-			     UInt dir,
-			     Real limit) : GeometryFilter(mesh, dir, limit) {};
-  ~FilterPositionsLessThan() {};
+  FilterPositionsLessThan(const Mesh & mesh, UInt dir, Real limit)
+      : GeometryFilter(mesh, dir, limit){};
+  ~FilterPositionsLessThan(){};
 
-  bool operator() (UInt node) {
+  bool operator()(UInt node) {
     AKANTU_DEBUG_IN();
     bool to_filter = true;
-    if((*this->positions)(node,this->dir) < this->limit)
+    if ((*this->positions)(node, this->dir) < this->limit)
       to_filter = false;
     AKANTU_DEBUG_OUT();
     return to_filter;
   };
 };
 
 /* -------------------------------------------------------------------------- */
 // this filter is erase because the convention of filter has changed!!
 // filter == true -> keep node
 
 // template<class FilterType>
 // void applyNodeFilter(Array<UInt> & nodes, FilterType & filter) {
 
 //   Array<UInt>::iterator<> it = nodes.begin();
 
 //   for (; it != nodes.end(); ++it) {
 //     if (filter(*it)) {
 //       it = nodes.erase(it);
 //     }
 //   }
-// }; 
+// };
 
 } // namespace akantu
 
 #endif /* __AST_NODE_FILTER_HH__ */
diff --git a/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_base_friction.hh b/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_base_friction.hh
index a14228f58..6452eda7a 100644
--- a/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_base_friction.hh
+++ b/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_base_friction.hh
@@ -1,161 +1,161 @@
 /**
  * @file   ntn_base_friction.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  *
  * @brief  base class for ntn and ntrf friction
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __AST_NTN_BASE_FRICTION_HH__
 #define __AST_NTN_BASE_FRICTION_HH__
 
 /* -------------------------------------------------------------------------- */
 // akantu
 #include "parsable.hh"
 
 // simtools
 #include "ntn_base_contact.hh"
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
 template<>
 inline void ParsableParamTyped< akantu::SynchronizedArray<Real> >::parseParam(const ParserParameter & in_param) {
   ParsableParam::parseParam(in_param);
   Real tmp = in_param;
   param.setAndChangeDefault(tmp);
 }
 
 /* -------------------------------------------------------------------------- */
 template<>
 template<>
 inline void ParsableParamTyped< akantu::SynchronizedArray<Real> >::setTyped<Real>(const Real & value) { 
   param.setAndChangeDefault(value); 
 }
 
 /* -------------------------------------------------------------------------- */
 class NTNBaseFriction : protected Memory, public Parsable, public Dumpable {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   
   NTNBaseFriction(NTNBaseContact * contact,
 		  const FrictionID & id = "friction",
 		  const MemoryID & memory_id = 0);
   virtual ~NTNBaseFriction() {};
   
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// compute friction traction
   virtual void computeFrictionTraction();
 
   /// compute stick traction (friction traction needed to stick the nodes)
   virtual void computeStickTraction();
 
   /// apply the friction force
   virtual void applyFrictionTraction();
 
   /// compute slip
   virtual void updateSlip();
 
   /// register Syncronizedarrays for sync
   virtual void registerSynchronizedArray(SynchronizedArrayBase & array);
   
   /// dump restart file
   virtual void dumpRestart(const std::string & file_name) const;
 
   /// read restart file
   virtual void readRestart(const std::string & file_name);
 
   /// set to steady state
   virtual void setToSteadyState() {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   };
 
   /// get the number of sticking nodes (in parallel)
   /// a node that is not in contact does not count as sticking
   virtual UInt getNbStickingNodes() const;
 
   /// function to print the contain of the class
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
 protected:
   /// compute frictional strength according to friction law
   virtual void computeFrictionalStrength() = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Dumpable                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   virtual void addDumpFieldToDumper(const std::string & dumper_name,
 				    const std::string & field_id);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   AKANTU_GET_MACRO(Contact, contact, const NTNBaseContact *)
 
   AKANTU_GET_MACRO(IsSticking,                 is_sticking, const SynchronizedArray<bool> &)
   AKANTU_GET_MACRO(FrictionalStrength, frictional_strength, const SynchronizedArray<Real> &)
   AKANTU_GET_MACRO(FrictionTraction,     friction_traction, const SynchronizedArray<Real> &)
   AKANTU_GET_MACRO(Slip,                              slip, const SynchronizedArray<Real> &)
   AKANTU_GET_MACRO(CumulativeSlip,         cumulative_slip, const SynchronizedArray<Real> &)
   AKANTU_GET_MACRO(SlipVelocity,             slip_velocity, const SynchronizedArray<Real> &)
 
   /// set parameter of a given node 
   /// (if you need to set to all: used the setMixed function of the Parsable).
   virtual void setParam(const std::string & name, UInt node, Real value);
 
   // replaced by the setMixed of the Parsable
   // virtual void setParam(const std::string & param, Real value) {
-  //   AKANTU_DEBUG_ERROR("Friction does not know the following parameter: " << param);
+  //   AKANTU_ERROR("Friction does not know the following parameter: " << param);
   // };
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   NTNBaseContact * contact;
 
   // if node is sticking
   SynchronizedArray<bool> is_sticking;
   // frictional strength
   SynchronizedArray<Real> frictional_strength;
   // friction force
   SynchronizedArray<Real> friction_traction;
   // slip
   SynchronizedArray<Real> slip;
   SynchronizedArray<Real> cumulative_slip;
   // slip velocity (tangential vector)
   SynchronizedArray<Real> slip_velocity;
 };
 
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 //#include "ntn_base_friction_inline_impl.cc"
 
 /// standard output stream operator
 inline std::ostream & operator <<(std::ostream & stream, const NTNBaseFriction & _this)
 {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #endif /* __AST_NTN_BASE_FRICTION_HH__ */
diff --git a/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_initiation_function.cc b/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_initiation_function.cc
index 4d3932e12..ca6701f64 100644
--- a/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_initiation_function.cc
+++ b/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_initiation_function.cc
@@ -1,398 +1,398 @@
 /**
  * @file   ntn_initiation_function.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  *
  * @brief  implementation of initializing ntn and ntrf friction
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 
 /* -------------------------------------------------------------------------- */
 // simtools
 #include "mIIasym_contact.hh"
 #include "ntn_initiation_function.hh"
 #include "ntn_friction.hh"
 #include "ntrf_friction.hh"
 
 // friction regularisations
 #include "ntn_fricreg_rubin_ampuero.hh"
 #include "ntn_fricreg_simplified_prakash_clifton.hh"
 
 // friction laws
 #include "ntn_friclaw_linear_cohesive.hh"
 #include "ntn_friclaw_linear_slip_weakening.hh"
 #include "ntn_friclaw_linear_slip_weakening_no_healing.hh"
 
 namespace akantu {
 
 NTNBaseFriction * initializeNTNFriction(NTNBaseContact * contact, 
 					ParameterReader & data) {
   AKANTU_DEBUG_IN();
   
   const std::string & friction_law = data.get<std::string>("friction_law");
   const std::string & friction_reg = data.get<std::string>("friction_regularisation");
   
   NTNBaseFriction * friction;
   
   bool is_ntn_contact = true;
   if (dynamic_cast<NTRFContact *>(contact) != NULL || 
       dynamic_cast<MIIASYMContact *>(contact) != NULL) {
     is_ntn_contact = false;
   }
 
   if (friction_law == "coulomb") {
     if (friction_reg == "no_regularisation") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawCoulomb,
 				   NTNFricRegNoRegularisation>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawCoulomb,
 				    NTNFricRegNoRegularisation>(contact);
     }
     else if (friction_reg == "rubin_ampuero") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawCoulomb,
 				   NTNFricRegRubinAmpuero>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawCoulomb,
 				    NTNFricRegRubinAmpuero>(contact);
       
       friction->setMixed< SynchronizedArray<Real> >("t_star", data.get<Real>("t_star"));
     }
     else if (friction_reg == "simplified_prakash_clifton") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawCoulomb, 
 				   NTNFricRegSimplifiedPrakashClifton>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawCoulomb, 
 				    NTNFricRegSimplifiedPrakashClifton>(contact);
       
       friction->setMixed< SynchronizedArray<Real> >("t_star", data.get<Real>("t_star"));
     }
     else {
-      AKANTU_DEBUG_ERROR("Do not know the following friction regularisation: " 
+      AKANTU_ERROR("Do not know the following friction regularisation: " 
 			 << friction_reg);
     }
 
     friction->setMixed< SynchronizedArray<Real> >("mu_s", data.get<Real>("mu_s"));
   }
 
   // Friction Law: Linear Slip Weakening
   else if (friction_law == "linear_slip_weakening") {
     if (friction_reg == "no_regularisation") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearSlipWeakening, 
 				   NTNFricRegNoRegularisation>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearSlipWeakening, 
 				    NTNFricRegNoRegularisation>(contact);
     }
     else if (friction_reg == "rubin_ampuero") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearSlipWeakening, 
 				   NTNFricRegRubinAmpuero>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearSlipWeakening, 
 				    NTNFricRegRubinAmpuero>(contact);
 
       friction->setMixed< SynchronizedArray<Real> >("t_star", data.get<Real>("t_star"));
     }
     else if (friction_reg == "simplified_prakash_clifton") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearSlipWeakening, 
 				   NTNFricRegSimplifiedPrakashClifton>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearSlipWeakening, 
 				    NTNFricRegSimplifiedPrakashClifton>(contact);
 
       friction->setMixed< SynchronizedArray<Real> >("t_star", data.get<Real>("t_star"));
     }
     else {
-      AKANTU_DEBUG_ERROR("Do not know the following friction regularisation: " 
+      AKANTU_ERROR("Do not know the following friction regularisation: " 
 			 << friction_reg);
     }
 
     friction->setMixed< SynchronizedArray<Real> >("mu_s", data.get<Real>("mu_s"));
     friction->setMixed< SynchronizedArray<Real> >("mu_k", data.get<Real>("mu_k"));
     friction->setMixed< SynchronizedArray<Real> >("d_c",  data.get<Real>("d_c"));
   }
 
   // Friction Law: Linear Slip Weakening No Healing
   else if (friction_law == "linear_slip_weakening_no_healing") {
     if (friction_reg == "no_regularisation") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearSlipWeakeningNoHealing, 
 				   NTNFricRegNoRegularisation>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearSlipWeakeningNoHealing, 
 				    NTNFricRegNoRegularisation>(contact);
     }
     else if (friction_reg == "rubin_ampuero") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearSlipWeakeningNoHealing, 
 				   NTNFricRegRubinAmpuero>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearSlipWeakeningNoHealing, 
 				    NTNFricRegRubinAmpuero>(contact);
 
       friction->setMixed< SynchronizedArray<Real> >("t_star", data.get<Real>("t_star"));
     }
     else if (friction_reg == "simplified_prakash_clifton") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearSlipWeakeningNoHealing, 
 				   NTNFricRegSimplifiedPrakashClifton>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearSlipWeakeningNoHealing, 
 				    NTNFricRegSimplifiedPrakashClifton>(contact);
 
       friction->setMixed< SynchronizedArray<Real> >("t_star", data.get<Real>("t_star"));
     }
     else {
-      AKANTU_DEBUG_ERROR("Do not know the following friction regularisation: " 
+      AKANTU_ERROR("Do not know the following friction regularisation: " 
 			 << friction_reg);
     }
 
     friction->setMixed< SynchronizedArray<Real> >("mu_s", data.get<Real>("mu_s"));
     friction->setMixed< SynchronizedArray<Real> >("mu_k", data.get<Real>("mu_k"));
     friction->setMixed< SynchronizedArray<Real> >("d_c",  data.get<Real>("d_c"));
   }
 
   // Friction Law: Linear Cohesive
   else if (friction_law == "linear_cohesive") {
     if (friction_reg == "no_regularisation") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearCohesive,
 				   NTNFricRegNoRegularisation>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearCohesive,
 				    NTNFricRegNoRegularisation>(contact);
     }
     else if (friction_reg == "rubin_ampuero") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearCohesive,
 				   NTNFricRegRubinAmpuero>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearCohesive,
 				    NTNFricRegRubinAmpuero>(contact);
       
       friction->setMixed< SynchronizedArray<Real> >("t_star", data.get<Real>("t_star"));
     }
     else if (friction_reg == "simplified_prakash_clifton") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearCohesive, 
 				   NTNFricRegSimplifiedPrakashClifton>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearCohesive, 
 				    NTNFricRegSimplifiedPrakashClifton>(contact);
       
       friction->setMixed< SynchronizedArray<Real> >("t_star", data.get<Real>("t_star"));
     }
     else {
-      AKANTU_DEBUG_ERROR("Do not know the following friction regularisation: " 
+      AKANTU_ERROR("Do not know the following friction regularisation: " 
 			 << friction_reg);
     }
 
     friction->setMixed< SynchronizedArray<Real> >("G_c", data.get<Real>("G_c"));
     friction->setMixed< SynchronizedArray<Real> >("tau_c", data.get<Real>("tau_c"));
     friction->setMixed< SynchronizedArray<Real> >("tau_r", data.get<Real>("tau_r"));
   }
   
   else {
-    AKANTU_DEBUG_ERROR("Do not know the following friction law: " 
+    AKANTU_ERROR("Do not know the following friction law: " 
 		       << friction_law);
   }
 
   AKANTU_DEBUG_OUT();
   return friction;
 }
 
 /* -------------------------------------------------------------------------- */
 NTNBaseFriction * initializeNTNFriction(NTNBaseContact * contact) {
   AKANTU_DEBUG_IN();
   std::pair<Parser::const_section_iterator, Parser::const_section_iterator>
     sub_sect = getStaticParser().getSubSections(_st_friction);
 
   Parser::const_section_iterator it = sub_sect.first;
   const ParserSection & section = *it;
 
   std::string friction_law = section.getName();
   std::string friction_reg = section.getOption();
   if (friction_reg == "") {
     std::string friction_reg = "no_regularisation";
   }
   
   NTNBaseFriction * friction = initializeNTNFriction(contact,
 						     friction_law,
 						     friction_reg);
 
   friction->parseSection(section);
 
   if (++it != sub_sect.second) {
     AKANTU_DEBUG_WARNING("There were several friction sections in input file. " 
 			 << "Only first one was used and all others ignored.");
   }
   
   AKANTU_DEBUG_OUT();
   return friction;
 }
 
 
 /* -------------------------------------------------------------------------- */
 NTNBaseFriction * initializeNTNFriction(NTNBaseContact * contact,
 					const std::string & friction_law,
 					const std::string & friction_reg) {
   AKANTU_DEBUG_IN();
   
   NTNBaseFriction * friction;
   
   // check whether is is node-to-rigid-flat contact or mIIasym (which is also ntrf)
   bool is_ntn_contact = true;
   if (dynamic_cast<NTRFContact *>(contact) != NULL ||
       dynamic_cast<MIIASYMContact *>(contact) != NULL) {
     is_ntn_contact = false;
   }
 
   if (friction_law == "coulomb") {
     if (friction_reg == "no_regularisation") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawCoulomb,
 				   NTNFricRegNoRegularisation>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawCoulomb,
 				    NTNFricRegNoRegularisation>(contact);
     }
     else if (friction_reg == "rubin_ampuero") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawCoulomb,
 				   NTNFricRegRubinAmpuero>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawCoulomb,
 				    NTNFricRegRubinAmpuero>(contact);
     }
     else if (friction_reg == "simplified_prakash_clifton") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawCoulomb, 
 				   NTNFricRegSimplifiedPrakashClifton>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawCoulomb, 
 				    NTNFricRegSimplifiedPrakashClifton>(contact);
     }
     else {
-      AKANTU_DEBUG_ERROR("Do not know the following friction regularisation: " 
+      AKANTU_ERROR("Do not know the following friction regularisation: " 
 			 << friction_reg);
     }
   }
 
   // Friction Law: Linear Slip Weakening
   else if (friction_law == "linear_slip_weakening") {
     if (friction_reg == "no_regularisation") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearSlipWeakening, 
 				   NTNFricRegNoRegularisation>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearSlipWeakening, 
 				    NTNFricRegNoRegularisation>(contact);
     }
     else if (friction_reg == "rubin_ampuero") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearSlipWeakening, 
 				   NTNFricRegRubinAmpuero>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearSlipWeakening, 
 				    NTNFricRegRubinAmpuero>(contact);
     }
     else if (friction_reg == "simplified_prakash_clifton") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearSlipWeakening, 
 				   NTNFricRegSimplifiedPrakashClifton>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearSlipWeakening, 
 				    NTNFricRegSimplifiedPrakashClifton>(contact);
     }
     else {
-      AKANTU_DEBUG_ERROR("Do not know the following friction regularisation: " 
+      AKANTU_ERROR("Do not know the following friction regularisation: " 
 			 << friction_reg);
     }
   }
 
 
   // Friction Law: Linear Slip Weakening No Healing
   else if (friction_law == "linear_slip_weakening_no_healing") {
     if (friction_reg == "no_regularisation") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearSlipWeakeningNoHealing, 
 				   NTNFricRegNoRegularisation>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearSlipWeakeningNoHealing, 
 				    NTNFricRegNoRegularisation>(contact);
     }
     else if (friction_reg == "rubin_ampuero") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearSlipWeakeningNoHealing, 
 				   NTNFricRegRubinAmpuero>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearSlipWeakeningNoHealing, 
 				    NTNFricRegRubinAmpuero>(contact);
     }
     else if (friction_reg == "simplified_prakash_clifton") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearSlipWeakeningNoHealing, 
 				   NTNFricRegSimplifiedPrakashClifton>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearSlipWeakeningNoHealing, 
 				    NTNFricRegSimplifiedPrakashClifton>(contact);
     }
     else {
-      AKANTU_DEBUG_ERROR("Do not know the following friction regularisation: " 
+      AKANTU_ERROR("Do not know the following friction regularisation: " 
 			 << friction_reg);
     }
   }
 
   // Friction Law: Linear Cohesive
   else if (friction_law == "linear_cohesive") {
     if (friction_reg == "no_regularisation") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearCohesive,
 				   NTNFricRegNoRegularisation>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearCohesive,
 				    NTNFricRegNoRegularisation>(contact);
     }
     else if (friction_reg == "rubin_ampuero") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearCohesive,
 				   NTNFricRegRubinAmpuero>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearCohesive,
 				    NTNFricRegRubinAmpuero>(contact);
     }
     else if (friction_reg == "simplified_prakash_clifton") {
       if (is_ntn_contact)
 	friction = new NTNFriction<NTNFricLawLinearCohesive, 
 				   NTNFricRegSimplifiedPrakashClifton>(contact);
       else
 	friction = new NTRFFriction<NTNFricLawLinearCohesive, 
 				    NTNFricRegSimplifiedPrakashClifton>(contact);
     }
     else {
-      AKANTU_DEBUG_ERROR("Do not know the following friction regularisation: " 
+      AKANTU_ERROR("Do not know the following friction regularisation: " 
 			 << friction_reg);
     }
   }
   else {
-    AKANTU_DEBUG_ERROR("Do not know the following friction law: " 
+    AKANTU_ERROR("Do not know the following friction law: " 
 		       << friction_law);
   }
   
   AKANTU_DEBUG_OUT();
   return friction;
 }
 
 
 } // namespace akantu
diff --git a/src/common/aka_array.cc b/src/common/aka_array.cc
index a9950241f..d014ca3ab 100644
--- a/src/common/aka_array.cc
+++ b/src/common/aka_array.cc
@@ -1,124 +1,124 @@
 /**
  * @file   aka_array.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Aug 18 2015
  *
  * @brief  Implementation of akantu::Array
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 <memory>
 #include <utility>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "aka_common.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* Functions ArrayBase                                                       */
 /* -------------------------------------------------------------------------- */
 ArrayBase::ArrayBase(ID id)
     : id(std::move(id)), allocated_size(0), size_(0), nb_component(1),
       size_of_type(0) {}
 
 /* -------------------------------------------------------------------------- */
 ArrayBase::~ArrayBase() = default;
 
 /* -------------------------------------------------------------------------- */
 void ArrayBase::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
   stream << space << "ArrayBase [" << std::endl;
   stream << space << " + size             : " << size_ << std::endl;
   stream << space << " + nb component     : " << nb_component << std::endl;
   stream << space << " + allocated size   : " << allocated_size << std::endl;
   Real mem_size = (allocated_size * nb_component * size_of_type) / 1024.;
   stream << space << " + size of type     : " << size_of_type << "B"
          << std::endl;
   stream << space << " + memory allocated : " << mem_size << "kB" << std::endl;
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 template <> UInt Array<Real>::find(const Real & elem) const {
   AKANTU_DEBUG_IN();
 
   Real epsilon = std::numeric_limits<Real>::epsilon();
   auto it = std::find_if(begin(), end(), [&elem, &epsilon](auto && a) {
     return std::abs(a - elem) <= epsilon;
   });
 
   AKANTU_DEBUG_OUT();
   return (it != end()) ? end() - it : UInt(-1);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 Array<ElementType> & Array<ElementType>::operator*=(__attribute__((unused))
                                                     const ElementType & alpha) {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
   return *this;
 }
 
 template <>
 Array<ElementType> & Array<ElementType>::
 operator-=(__attribute__((unused)) const Array<ElementType> & vect) {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
   return *this;
 }
 
 template <>
 Array<ElementType> & Array<ElementType>::
 operator+=(__attribute__((unused)) const Array<ElementType> & vect) {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
   return *this;
 }
 
 template <>
 Array<char> & Array<char>::operator*=(__attribute__((unused))
                                       const char & alpha) {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
   return *this;
 }
 
 template <>
 Array<char> & Array<char>::operator-=(__attribute__((unused))
                                       const Array<char> & vect) {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
   return *this;
 }
 
 template <>
 Array<char> & Array<char>::operator+=(__attribute__((unused))
                                       const Array<char> & vect) {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
   return *this;
 }
 
 } // namespace akantu
diff --git a/src/common/aka_array_tmpl.hh b/src/common/aka_array_tmpl.hh
index 87082c357..5f779890e 100644
--- a/src/common/aka_array_tmpl.hh
+++ b/src/common/aka_array_tmpl.hh
@@ -1,1280 +1,1280 @@
 /**
  * @file   aka_array_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Jul 15 2010
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  Inline functions of the classes Array<T> and ArrayBase
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 /* Inline Functions Array<T>                                                 */
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 /* -------------------------------------------------------------------------- */
 #include <memory>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_ARRAY_TMPL_HH__
 #define __AKANTU_AKA_ARRAY_TMPL_HH__
 
 namespace akantu {
 
 namespace debug {
   struct ArrayException : public Exception {};
 } // namespace debug
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline T & Array<T, is_scal>::operator()(UInt i, UInt j) {
   AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < size_) && (j < nb_component),
                       "The value at position ["
                           << i << "," << j << "] is out of range in array \""
                           << id << "\"");
   return values[i * nb_component + j];
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline const T & Array<T, is_scal>::operator()(UInt i, UInt j) const {
   AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < size_) && (j < nb_component),
                       "The value at position ["
                           << i << "," << j << "] is out of range in array \""
                           << id << "\"");
   return values[i * nb_component + j];
 }
 
 template <class T, bool is_scal>
 inline T & Array<T, is_scal>::operator[](UInt i) {
   AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < size_ * nb_component),
                       "The value at position ["
                           << i << "] is out of range in array \"" << id
                           << "\"");
   return values[i];
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline const T & Array<T, is_scal>::operator[](UInt i) const {
   AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < size_ * nb_component),
                       "The value at position ["
                           << i << "] is out of range in array \"" << id
                           << "\"");
   return values[i];
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * append a tuple to the array with the value value for all components
  * @param value the new last tuple or the array will contain nb_component copies
  * of value
  */
 template <class T, bool is_scal>
 inline void Array<T, is_scal>::push_back(const T & value) {
   resizeUnitialized(size_ + 1, true, value);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * append a tuple to the array
  * @param new_elem a C-array containing the values to be copied to the end of
  * the array */
 // template <class T, bool is_scal>
 // inline void Array<T, is_scal>::push_back(const T new_elem[]) {
 //   UInt pos = size_;
 
 //   resizeUnitialized(size_ + 1, false);
 
 //   T * tmp = values + nb_component * pos;
 //   std::uninitialized_copy(new_elem, new_elem + nb_component, tmp);
 // }
 
 /* -------------------------------------------------------------------------- */
 #ifndef SWIG
 /**
  * append a matrix or a vector to the array
  * @param new_elem a reference to a Matrix<T> or Vector<T> */
 template <class T, bool is_scal>
 template <template <typename> class C, typename>
 inline void Array<T, is_scal>::push_back(const C<T> & new_elem) {
   AKANTU_DEBUG_ASSERT(
       nb_component == new_elem.size(),
       "The vector("
           << new_elem.size()
           << ") as not a size compatible with the Array (nb_component="
           << nb_component << ").");
   UInt pos = size_;
   resizeUnitialized(size_ + 1, false);
 
   T * tmp = values + nb_component * pos;
   std::uninitialized_copy(new_elem.storage(), new_elem.storage() + nb_component,
                           tmp);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * append a tuple to the array
  * @param it an iterator to the tuple to be copied to the end of the array */
 template <class T, bool is_scal>
 template <class Ret>
 inline void
 Array<T, is_scal>::push_back(const Array<T, is_scal>::iterator<Ret> & it) {
   UInt pos = size_;
 
   resizeUnitialized(size_ + 1, false);
 
   T * tmp = values + nb_component * pos;
   T * new_elem = it.data();
   std::uninitialized_copy(new_elem, new_elem + nb_component, tmp);
 }
 #endif
 /* -------------------------------------------------------------------------- */
 /**
  * erase an element. If the erased element is not the last of the array, the
  * last element is moved into the hole in order to maintain contiguity. This
  * may invalidate existing iterators (For instance an iterator obtained by
  * Array::end() is no longer correct) and will change the order of the
  * elements.
  * @param i index of element to erase
  */
 template <class T, bool is_scal> inline void Array<T, is_scal>::erase(UInt i) {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG_ASSERT((size_ > 0), "The array is empty");
   AKANTU_DEBUG_ASSERT((i < size_),
                       "The element at position [" << i << "] is out of range ("
                                                   << i << ">=" << size_ << ")");
 
   if (i != (size_ - 1)) {
     for (UInt j = 0; j < nb_component; ++j) {
       values[i * nb_component + j] = values[(size_ - 1) * nb_component + j];
     }
   }
 
   resize(size_ - 1);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Subtract another array entry by entry from this array in place. Both arrays
  * must
  * have the same size and nb_component. If the arrays have different shapes,
  * code compiled in debug mode will throw an expeption and optimised code
  * will behave in an unpredicted manner
  * @param other array to subtract from this
  * @return reference to modified this
  */
 template <class T, bool is_scal>
 Array<T, is_scal> & Array<T, is_scal>::
 operator-=(const Array<T, is_scal> & vect) {
   AKANTU_DEBUG_ASSERT((size_ == vect.size_) &&
                           (nb_component == vect.nb_component),
                       "The too array don't have the same sizes");
 
   T * a = values;
   T * b = vect.storage();
   for (UInt i = 0; i < size_ * nb_component; ++i) {
     *a -= *b;
     ++a;
     ++b;
   }
 
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Add another array entry by entry to this array in place. Both arrays must
  * have the same size and nb_component. If the arrays have different shapes,
  * code compiled in debug mode will throw an expeption and optimised code
  * will behave in an unpredicted manner
  * @param other array to add to this
  * @return reference to modified this
  */
 template <class T, bool is_scal>
 Array<T, is_scal> & Array<T, is_scal>::
 operator+=(const Array<T, is_scal> & vect) {
   AKANTU_DEBUG_ASSERT((size_ == vect.size()) &&
                           (nb_component == vect.nb_component),
                       "The too array don't have the same sizes");
 
   T * a = values;
   T * b = vect.storage();
   for (UInt i = 0; i < size_ * nb_component; ++i) {
     *a++ += *b++;
   }
 
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Multiply all entries of this array by a scalar in place
  * @param alpha scalar multiplicant
  * @return reference to modified this
  */
 
 #ifndef SWIG
 template <class T, bool is_scal>
 Array<T, is_scal> & Array<T, is_scal>::operator*=(const T & alpha) {
   T * a = values;
   for (UInt i = 0; i < size_ * nb_component; ++i) {
     *a++ *= alpha;
   }
 
   return *this;
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 /**
  * Compare this array element by element to another.
  * @param other array to compare to
  * @return true it all element are equal and arrays have the same shape, else
  * false
  */
 template <class T, bool is_scal>
 bool Array<T, is_scal>::operator==(const Array<T, is_scal> & array) const {
   bool equal = nb_component == array.nb_component && size_ == array.size_ &&
                id == array.id;
   if (!equal)
     return false;
 
   if (values == array.storage())
     return true;
   else
     return std::equal(values, values + size_ * nb_component, array.storage());
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 bool Array<T, is_scal>::operator!=(const Array<T, is_scal> & array) const {
   return !operator==(array);
 }
 
 /* -------------------------------------------------------------------------- */
 #ifndef SWIG
 /**
  * set all tuples of the array to a given vector or matrix
  * @param vm Matrix or Vector to fill the array with
  */
 template <class T, bool is_scal>
 template <template <typename> class C, typename>
 inline void Array<T, is_scal>::set(const C<T> & vm) {
   AKANTU_DEBUG_ASSERT(
       nb_component == vm.size(),
       "The size of the object does not match the number of components");
   for (T * it = values; it < values + nb_component * size_;
        it += nb_component) {
     std::copy(vm.storage(), vm.storage() + nb_component, it);
   }
 }
 #endif
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 void Array<T, is_scal>::append(const Array<T> & other) {
   AKANTU_DEBUG_ASSERT(
       nb_component == other.nb_component,
       "Cannot append an array with a different number of component");
   UInt old_size = this->size_;
   this->resizeUnitialized(this->size_ + other.size(), false);
 
   T * tmp = values + nb_component * old_size;
   std::uninitialized_copy(other.storage(),
                           other.storage() + other.size() * nb_component, tmp);
 }
 
 /* -------------------------------------------------------------------------- */
 /* Functions Array<T, is_scal>                                                */
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(UInt size, UInt nb_component, const ID & id)
     : ArrayBase(id), values(nullptr) {
   AKANTU_DEBUG_IN();
   allocate(size, nb_component);
 
   if (!is_scal) {
     T val = T();
     std::uninitialized_fill(values, values + size * nb_component, val);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(UInt size, UInt nb_component, const T def_values[],
                          const ID & id)
     : ArrayBase(id), values(NULL) {
   AKANTU_DEBUG_IN();
   allocate(size, nb_component);
 
   T * tmp = values;
 
   for (UInt i = 0; i < size; ++i) {
     tmp = values + nb_component * i;
     std::uninitialized_copy(def_values, def_values + nb_component, tmp);
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(UInt size, UInt nb_component, const T & value,
                          const ID & id)
     : ArrayBase(id), values(nullptr) {
   AKANTU_DEBUG_IN();
   allocate(size, nb_component);
 
   std::uninitialized_fill_n(values, size * nb_component, value);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(const Array<T, is_scal> & vect, bool deep,
                          const ID & id)
     : ArrayBase(vect) {
   AKANTU_DEBUG_IN();
   this->id = (id == "") ? vect.id : id;
 
   if (deep) {
     allocate(vect.size_, vect.nb_component);
     T * tmp = values;
     std::uninitialized_copy(vect.storage(),
                             vect.storage() + size_ * nb_component, tmp);
   } else {
     this->values = vect.storage();
     this->size_ = vect.size_;
     this->nb_component = vect.nb_component;
     this->allocated_size = vect.allocated_size;
     this->size_of_type = vect.size_of_type;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 #ifndef SWIG
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(const std::vector<T> & vect) {
   AKANTU_DEBUG_IN();
   this->id = "";
 
   allocate(vect.size(), 1);
   T * tmp = values;
   std::uninitialized_copy(&(vect[0]), &(vect[size_ - 1]), tmp);
 
   AKANTU_DEBUG_OUT();
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal> Array<T, is_scal>::~Array() {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG(dblAccessory,
                "Freeing " << printMemorySize<T>(allocated_size * nb_component)
                           << " (" << id << ")");
 
   if (values) {
     if (!is_scal)
       for (UInt i = 0; i < size_ * nb_component; ++i) {
         T * obj = values + i;
         obj->~T();
       }
     free(values);
   }
   size_ = allocated_size = 0;
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * perform the allocation for the constructors
  * @param size is the size of the array
  * @param nb_component is the number of component of the array
  */
 template <class T, bool is_scal>
 void Array<T, is_scal>::allocate(UInt size, UInt nb_component) {
   AKANTU_DEBUG_IN();
   if (size == 0) {
     values = nullptr;
   } else {
     values = static_cast<T *>(malloc(nb_component * size * sizeof(T)));
     AKANTU_DEBUG_ASSERT(values != nullptr,
                         "Cannot allocate "
                             << printMemorySize<T>(size * nb_component) << " ("
                             << id << ")");
   }
 
   if (values == nullptr) {
     this->size_ = this->allocated_size = 0;
   } else {
     AKANTU_DEBUG(dblAccessory,
                  "Allocated " << printMemorySize<T>(size * nb_component) << " ("
                               << id << ")");
     this->size_ = this->allocated_size = size;
   }
 
   this->size_of_type = sizeof(T);
   this->nb_component = nb_component;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 void Array<T, is_scal>::reserve(UInt new_size) {
   UInt tmp_size = this->size_;
   resizeUnitialized(new_size, false);
   this->size_ = tmp_size;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the size of the array and allocate or free memory if needed. If the
  * size increases, the new tuples are filled with zeros
  * @param new_size new number of tuples contained in the array */
 template <class T, bool is_scal> void Array<T, is_scal>::resize(UInt new_size) {
   resizeUnitialized(new_size, !is_scal);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the size of the array and allocate or free memory if needed. If the
  * size increases, the new tuples are filled with zeros
  * @param new_size new number of tuples contained in the array */
 template <class T, bool is_scal>
 void Array<T, is_scal>::resize(UInt new_size, const T & val) {
   this->resizeUnitialized(new_size, true, val);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the size of the array and allocate or free memory if needed.
  * @param new_size new number of tuples contained in the array */
 template <class T, bool is_scal>
 void Array<T, is_scal>::resizeUnitialized(UInt new_size, bool fill,
                                           const T & val) {
   //  AKANTU_DEBUG_IN();
   // free some memory
   if (new_size <= allocated_size) {
     if (!is_scal) {
       T * old_values = values;
       if (new_size < size_) {
         for (UInt i = new_size * nb_component; i < size_ * nb_component; ++i) {
           T * obj = old_values + i;
           obj->~T();
         }
       }
     }
 
     if (allocated_size - new_size > AKANTU_MIN_ALLOCATION) {
       AKANTU_DEBUG(dblAccessory,
                    "Freeing " << printMemorySize<T>((allocated_size - size_) *
                                                     nb_component)
                               << " (" << id << ")");
 
       // Normally there are no allocation problem when reducing an array
       if (new_size == 0) {
         free(values);
         values = nullptr;
       } else {
         auto * tmp_ptr = static_cast<T *>(
             realloc(values, new_size * nb_component * sizeof(T)));
 
         if (tmp_ptr == nullptr) {
           AKANTU_EXCEPTION("Cannot free data ("
                            << id << ")"
                            << " [current allocated size : " << allocated_size
                            << " | "
                            << "requested size : " << new_size << "]");
         }
         values = tmp_ptr;
       }
       allocated_size = new_size;
     }
   } else {
     // allocate more memory
     UInt size_to_alloc = (new_size - allocated_size < AKANTU_MIN_ALLOCATION)
                              ? allocated_size + AKANTU_MIN_ALLOCATION
                              : new_size;
 
     auto * tmp_ptr = static_cast<T *>(
         realloc(values, size_to_alloc * nb_component * sizeof(T)));
     AKANTU_DEBUG_ASSERT(
         tmp_ptr != nullptr,
         "Cannot allocate " << printMemorySize<T>(size_to_alloc * nb_component));
     if (tmp_ptr == nullptr) {
-      AKANTU_DEBUG_ERROR("Cannot allocate more data ("
+      AKANTU_ERROR("Cannot allocate more data ("
                          << id << ")"
                          << " [current allocated size : " << allocated_size
                          << " | "
                          << "requested size : " << new_size << "]");
     }
 
     AKANTU_DEBUG(dblAccessory,
                  "Allocating " << printMemorySize<T>(
                      (size_to_alloc - allocated_size) * nb_component));
 
     allocated_size = size_to_alloc;
     values = tmp_ptr;
   }
 
   if (fill && this->size_ < new_size) {
     std::uninitialized_fill(values + size_ * nb_component,
                             values + new_size * nb_component, val);
   }
 
   size_ = new_size;
   //  AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the number of components by interlacing data
  * @param multiplicator number of interlaced components add
  * @param block_size blocks of data in the array
  * Examaple for block_size = 2, multiplicator = 2
  * array = oo oo oo -> new array = oo nn nn oo nn nn oo nn nn */
 template <class T, bool is_scal>
 void Array<T, is_scal>::extendComponentsInterlaced(UInt multiplicator,
                                                    UInt block_size) {
   AKANTU_DEBUG_IN();
 
   if (multiplicator == 1)
     return;
 
   AKANTU_DEBUG_ASSERT(multiplicator > 1, "invalid multiplicator");
   AKANTU_DEBUG_ASSERT(nb_component % block_size == 0,
                       "stride must divide actual number of components");
 
   values = static_cast<T *>(
       realloc(values, nb_component * multiplicator * size_ * sizeof(T)));
 
   UInt new_component = nb_component / block_size * multiplicator;
 
   for (UInt i = 0, k = size_ - 1; i < size_; ++i, --k) {
     for (UInt j = 0; j < new_component; ++j) {
       UInt m = new_component - j - 1;
       UInt n = m / multiplicator;
       for (UInt l = 0, p = block_size - 1; l < block_size; ++l, --p) {
         values[k * nb_component * multiplicator + m * block_size + p] =
             values[k * nb_component + n * block_size + p];
       }
     }
   }
 
   nb_component = nb_component * multiplicator;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * search elem in the array, return  the position of the first occurrence or
  * -1 if not found
  *  @param elem the element to look for
  *  @return index of the first occurrence of elem or -1 if elem is not present
  */
 template <class T, bool is_scal>
 UInt Array<T, is_scal>::find(const T & elem) const {
   AKANTU_DEBUG_IN();
 
   auto begin = this->begin();
   auto end = this->end();
   auto it = std::find(begin, end, elem);
 
   AKANTU_DEBUG_OUT();
   return (it != end) ? it - begin : UInt(-1);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal> UInt Array<T, is_scal>::find(T elem[]) const {
   AKANTU_DEBUG_IN();
   T * it = values;
   UInt i = 0;
   for (; i < size_; ++i) {
     if (*it == elem[0]) {
       T * cit = it;
       UInt c = 0;
       for (; (c < nb_component) && (*cit == elem[c]); ++c, ++cit)
         ;
       if (c == nb_component) {
         AKANTU_DEBUG_OUT();
         return i;
       }
     }
     it += nb_component;
   }
   return UInt(-1);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <template <typename> class C, typename>
 inline UInt Array<T, is_scal>::find(const C<T> & elem) {
   AKANTU_DEBUG_ASSERT(elem.size() == nb_component,
                       "Cannot find an element with a wrong size ("
                           << elem.size() << ") != " << nb_component);
   return this->find(elem.storage());
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * copy the content of another array. This overwrites the current content.
  * @param other Array to copy into this array. It has to have the same
  * nb_component as this. If compiled in debug mode, an incorrect other will
  * result in an exception being thrown. Optimised code may result in
  * unpredicted behaviour.
  */
 template <class T, bool is_scal>
 void Array<T, is_scal>::copy(const Array<T, is_scal> & vect,
                              bool no_sanity_check) {
   AKANTU_DEBUG_IN();
 
   if (!no_sanity_check)
     if (vect.nb_component != nb_component)
-      AKANTU_DEBUG_ERROR(
+      AKANTU_ERROR(
           "The two arrays do not have the same number of components");
 
   resize((vect.size_ * vect.nb_component) / nb_component);
 
   T * tmp = values;
   std::uninitialized_copy(vect.storage(), vect.storage() + size_ * nb_component,
                           tmp);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_scal> class ArrayPrintHelper {
 public:
   template <typename T>
   static void print_content(const Array<T> & vect, std::ostream & stream,
                             int indent) {
     if (AKANTU_DEBUG_TEST(dblDump) || AKANTU_DEBUG_LEVEL_IS_TEST()) {
       std::string space;
       for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
         ;
 
       stream << space << " + values         : {";
       for (UInt i = 0; i < vect.size(); ++i) {
         stream << "{";
         for (UInt j = 0; j < vect.getNbComponent(); ++j) {
           stream << vect(i, j);
           if (j != vect.getNbComponent() - 1)
             stream << ", ";
         }
         stream << "}";
         if (i != vect.size() - 1)
           stream << ", ";
       }
       stream << "}" << std::endl;
     }
   }
 };
 
 template <> class ArrayPrintHelper<false> {
 public:
   template <typename T>
   static void print_content(__attribute__((unused)) const Array<T> & vect,
                             __attribute__((unused)) std::ostream & stream,
                             __attribute__((unused)) int indent) {}
 };
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 void Array<T, is_scal>::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   std::streamsize prec = stream.precision();
   std::ios_base::fmtflags ff = stream.flags();
 
   stream.setf(std::ios_base::showbase);
   stream.precision(2);
 
   stream << space << "Array<" << debug::demangle(typeid(T).name()) << "> ["
          << std::endl;
   stream << space << " + id             : " << this->id << std::endl;
   stream << space << " + size           : " << this->size_ << std::endl;
   stream << space << " + nb_component   : " << this->nb_component << std::endl;
   stream << space << " + allocated size : " << this->allocated_size
          << std::endl;
   stream << space << " + memory size    : "
          << printMemorySize<T>(allocated_size * nb_component) << std::endl;
   if (!AKANTU_DEBUG_LEVEL_IS_TEST())
     stream << space << " + address        : " << std::hex << this->values
            << std::dec << std::endl;
 
   stream.precision(prec);
   stream.flags(ff);
 
   ArrayPrintHelper<is_scal>::print_content(*this, stream, indent);
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 /* Inline Functions ArrayBase                                                */
 /* -------------------------------------------------------------------------- */
 
 inline UInt ArrayBase::getMemorySize() const {
   return allocated_size * nb_component * size_of_type;
 }
 
 inline void ArrayBase::empty() { size_ = 0; }
 
 #ifndef SWIG
 /* -------------------------------------------------------------------------- */
 /* Iterators                                                                  */
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <class R, class daughter, class IR, bool is_tensor>
 class Array<T, is_scal>::iterator_internal {
 public:
   using value_type = R;
   using pointer = R *;
   using reference = R &;
   using proxy = typename R::proxy;
   using const_proxy = const typename R::proxy;
   using const_reference = const R &;
   using internal_value_type = IR;
   using internal_pointer = IR *;
   using difference_type = std::ptrdiff_t;
   using iterator_category = std::random_access_iterator_tag;
 
 public:
   iterator_internal() = default;
 
   iterator_internal(pointer_type data, UInt _offset)
       : _offset(_offset), initial(data), ret(nullptr), ret_ptr(data) {
-    AKANTU_DEBUG_ERROR(
+    AKANTU_ERROR(
         "The constructor should never be called it is just an ugly trick...");
   }
 
   iterator_internal(std::unique_ptr<internal_value_type> && wrapped)
       : _offset(wrapped->size()), initial(wrapped->storage()),
         ret(std::move(wrapped)), ret_ptr(ret->storage()) {}
 
   iterator_internal(const iterator_internal & it) {
     if (this != &it) {
       this->_offset = it._offset;
       this->initial = it.initial;
       this->ret_ptr = it.ret_ptr;
       this->ret = std::make_unique<internal_value_type>(*it.ret, false);
     }
   }
 
   iterator_internal(iterator_internal && it) = default;
 
   virtual ~iterator_internal() = default;
 
   inline iterator_internal & operator=(const iterator_internal & it) {
     if (this != &it) {
       this->_offset = it._offset;
       this->initial = it.initial;
       this->ret_ptr = it.ret_ptr;
       if (this->ret)
         this->ret->shallowCopy(*it.ret);
       else
         this->ret = std::make_unique<internal_value_type>(*it.ret, false);
     }
     return *this;
   }
 
   UInt getCurrentIndex() {
     return (this->ret_ptr - this->initial) / this->_offset;
   };
 
   inline reference operator*() {
     ret->values = ret_ptr;
     return *ret;
   };
   inline const_reference operator*() const {
     ret->values = ret_ptr;
     return *ret;
   };
   inline pointer operator->() {
     ret->values = ret_ptr;
     return ret.get();
   };
   inline daughter & operator++() {
     ret_ptr += _offset;
     return static_cast<daughter &>(*this);
   };
   inline daughter & operator--() {
     ret_ptr -= _offset;
     return static_cast<daughter &>(*this);
   };
 
   inline daughter & operator+=(const UInt n) {
     ret_ptr += _offset * n;
     return static_cast<daughter &>(*this);
   }
   inline daughter & operator-=(const UInt n) {
     ret_ptr -= _offset * n;
     return static_cast<daughter &>(*this);
   }
 
   inline proxy operator[](const UInt n) {
     ret->values = ret_ptr + n * _offset;
     return proxy(*ret);
   }
   inline const_proxy operator[](const UInt n) const {
     ret->values = ret_ptr + n * _offset;
     return const_proxy(*ret);
   }
 
   inline bool operator==(const iterator_internal & other) const {
     return this->ret_ptr == other.ret_ptr;
   }
   inline bool operator!=(const iterator_internal & other) const {
     return this->ret_ptr != other.ret_ptr;
   }
   inline bool operator<(const iterator_internal & other) const {
     return this->ret_ptr < other.ret_ptr;
   }
   inline bool operator<=(const iterator_internal & other) const {
     return this->ret_ptr <= other.ret_ptr;
   }
   inline bool operator>(const iterator_internal & other) const {
     return this->ret_ptr > other.ret_ptr;
   }
   inline bool operator>=(const iterator_internal & other) const {
     return this->ret_ptr >= other.ret_ptr;
   }
 
   inline daughter operator+(difference_type n) {
     daughter tmp(static_cast<daughter &>(*this));
     tmp += n;
     return tmp;
   }
   inline daughter operator-(difference_type n) {
     daughter tmp(static_cast<daughter &>(*this));
     tmp -= n;
     return tmp;
   }
 
   inline difference_type operator-(const iterator_internal & b) {
     return (this->ret_ptr - b.ret_ptr) / _offset;
   }
 
   inline pointer_type data() const { return ret_ptr; }
   inline difference_type offset() const { return _offset; }
 
 protected:
   UInt _offset{0};
   pointer_type initial{nullptr};
   std::unique_ptr<internal_value_type> ret{nullptr};
   pointer_type ret_ptr{nullptr};
 };
 
 /* -------------------------------------------------------------------------- */
 /**
  * Specialization for scalar types
  */
 template <class T, bool is_scal>
 template <class R, class daughter, class IR>
 class Array<T, is_scal>::iterator_internal<R, daughter, IR, false> {
 public:
   using value_type = R;
   using pointer = R *;
   using reference = R &;
   using const_reference = const R &;
   using internal_value_type = IR;
   using internal_pointer = IR *;
   using difference_type = std::ptrdiff_t;
   using iterator_category = std::random_access_iterator_tag;
 
 public:
   iterator_internal(pointer data = nullptr) : ret(data), initial(data){};
   iterator_internal(const iterator_internal & it) = default;
   iterator_internal(iterator_internal && it) = default;
 
   virtual ~iterator_internal() = default;
 
   inline iterator_internal & operator=(const iterator_internal & it) = default;
 
   UInt getCurrentIndex() { return (this->ret - this->initial); };
 
   inline reference operator*() { return *ret; };
   inline const_reference operator*() const { return *ret; };
   inline pointer operator->() { return ret; };
   inline daughter & operator++() {
     ++ret;
     return static_cast<daughter &>(*this);
   };
   inline daughter & operator--() {
     --ret;
     return static_cast<daughter &>(*this);
   };
 
   inline daughter & operator+=(const UInt n) {
     ret += n;
     return static_cast<daughter &>(*this);
   }
   inline daughter & operator-=(const UInt n) {
     ret -= n;
     return static_cast<daughter &>(*this);
   }
 
   inline reference operator[](const UInt n) { return ret[n]; }
 
   inline bool operator==(const iterator_internal & other) const {
     return ret == other.ret;
   }
   inline bool operator!=(const iterator_internal & other) const {
     return ret != other.ret;
   }
   inline bool operator<(const iterator_internal & other) const {
     return ret < other.ret;
   }
   inline bool operator<=(const iterator_internal & other) const {
     return ret <= other.ret;
   }
   inline bool operator>(const iterator_internal & other) const {
     return ret > other.ret;
   }
   inline bool operator>=(const iterator_internal & other) const {
     return ret >= other.ret;
   }
 
   inline daughter operator-(difference_type n) { return daughter(ret - n); }
   inline daughter operator+(difference_type n) { return daughter(ret + n); }
 
   inline difference_type operator-(const iterator_internal & b) {
     return ret - b.ret;
   }
 
   inline pointer data() const { return ret; }
 
 protected:
   pointer ret{nullptr};
   pointer initial{nullptr};
 };
 
 /* -------------------------------------------------------------------------- */
 /* Begin/End functions implementation                                         */
 /* -------------------------------------------------------------------------- */
 namespace detail {
   template <class Tuple, size_t... Is>
   constexpr auto take_front_impl(Tuple && t, std::index_sequence<Is...>) {
     return std::make_tuple(std::get<Is>(std::forward<Tuple>(t))...);
   }
 
   template <size_t N, class Tuple> constexpr auto take_front(Tuple && t) {
     return take_front_impl(std::forward<Tuple>(t),
                            std::make_index_sequence<N>{});
   }
 
   template <typename... V> constexpr auto product_all(V &&... v) {
     std::common_type_t<int, V...> result = 1;
     (void)std::initializer_list<int>{(result *= v, 0)...};
     return result;
   }
 
   template <typename... T> std::string to_string_all(T &&... t) {
     if (sizeof...(T) == 0)
       return "";
 
     std::stringstream ss;
     bool noComma = true;
     ss << "(";
     (void)std::initializer_list<bool>{
         (ss << (noComma ? "" : ", ") << t, noComma = false)...};
     ss << ")";
     return ss.str();
   }
 
   template <std::size_t N> struct InstantiationHelper {
     template <typename type, typename T, typename... Ns>
     static auto instantiate(T && data, Ns... ns) {
       return std::make_unique<type>(data, ns...);
     }
   };
 
   template <> struct InstantiationHelper<0> {
     template <typename type, typename T> static auto instantiate(T && data) {
       return data;
     }
   };
 
   template <typename Arr, typename T, typename... Ns>
   decltype(auto) get_iterator(Arr && array, T * data, Ns &&... ns) {
     using type = IteratorHelper_t<sizeof...(Ns) - 1, T>;
     using array_type = std::decay_t<Arr>;
     using iterator =
         std::conditional_t<std::is_const<std::remove_reference_t<Arr>>::value,
                            typename array_type::template const_iterator<type>,
                            typename array_type::template iterator<type>>;
     static_assert(sizeof...(Ns), "You should provide a least one size");
 
     if (array.getNbComponent() * array.size() !=
         product_all(std::forward<Ns>(ns)...)) {
       AKANTU_CUSTOM_EXCEPTION_INFO(
           debug::ArrayException(),
           "The iterator on "
               << debug::demangle(typeid(Arr).name())
               << to_string_all(array.size(), array.getNbComponent())
               << "is not compatible with the type "
               << debug::demangle(typeid(type).name()) << to_string_all(ns...));
     }
 
     auto && wrapped = aka::apply(
         [&](auto... n) {
           return InstantiationHelper<sizeof...(n)>::template instantiate<type>(
               data, n...);
         },
         take_front<sizeof...(Ns) - 1>(std::make_tuple(ns...)));
 
     return iterator(std::move(wrapped));
   }
 } // namespace detail
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::begin(Ns &&... ns) {
   return detail::get_iterator(*this, values, std::forward<Ns>(ns)..., size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::end(Ns &&... ns) {
   return detail::get_iterator(*this, values + nb_component * size_,
                               std::forward<Ns>(ns)..., size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::begin(Ns &&... ns) const {
   return detail::get_iterator(*this, values, std::forward<Ns>(ns)..., size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::end(Ns &&... ns) const {
   return detail::get_iterator(*this, values + nb_component * size_,
                               std::forward<Ns>(ns)..., size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::begin_reinterpret(Ns &&... ns) {
   return detail::get_iterator(*this, values, std::forward<Ns>(ns)...);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::end_reinterpret(Ns &&... ns) {
   return detail::get_iterator(
       *this, values + detail::product_all(std::forward<Ns>(ns)...),
       std::forward<Ns>(ns)...);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::begin_reinterpret(Ns &&... ns) const {
   return detail::get_iterator(*this, values, std::forward<Ns>(ns)...);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::end_reinterpret(Ns &&... ns) const {
   return detail::get_iterator(
       *this, values + detail::product_all(std::forward<Ns>(ns)...),
       std::forward<Ns>(ns)...);
 }
 
 /* -------------------------------------------------------------------------- */
 /* Views                                                                      */
 /* -------------------------------------------------------------------------- */
 namespace detail {
   template <typename Array, typename... Ns> class ArrayView {
     using tuple = std::tuple<Ns...>;
 
   public:
     ArrayView(Array && array, Ns... ns)
         : array(std::forward<Array>(array)), sizes(std::move(ns)...) {}
 
     ArrayView(ArrayView && array_view) = default;
 
     ArrayView & operator=(const ArrayView & array_view) = default;
     ArrayView & operator=(ArrayView && array_view) = default;
 
     decltype(auto) begin() {
       return aka::apply(
           [&](auto &&... ns) { return array.begin_reinterpret(ns...); }, sizes);
     }
 
     decltype(auto) begin() const {
       return aka::apply(
           [&](auto &&... ns) { return array.begin_reinterpret(ns...); }, sizes);
     }
 
     decltype(auto) end() {
       return aka::apply(
           [&](auto &&... ns) { return array.end_reinterpret(ns...); }, sizes);
     }
 
     decltype(auto) end() const {
       return aka::apply(
           [&](auto &&... ns) { return array.end_reinterpret(ns...); }, sizes);
     }
 
     decltype(auto) size() const {
       return std::get<std::tuple_size<tuple>::value - 1>(sizes);
     }
 
     decltype(auto) dims() const { return std::tuple_size<tuple>::value - 1; }
 
   private:
     Array array;
     tuple sizes;
   };
 } // namespace detail
 
 /* -------------------------------------------------------------------------- */
 template <typename Array, typename... Ns>
 decltype(auto) make_view(Array && array, Ns... ns) {
   static_assert(aka::conjunction<std::is_integral<std::decay_t<Ns>>...>::value,
                 "Ns should be integral types");
   auto size = std::forward<decltype(array)>(array).size() *
               std::forward<decltype(array)>(array).getNbComponent() /
               detail::product_all(ns...);
 
   return detail::ArrayView<Array, std::common_type_t<size_t, Ns>...,
                            std::common_type_t<size_t, decltype(size)>>(
       std::forward<Array>(array), std::move(ns)..., size);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <typename R>
 class Array<T, is_scal>::const_iterator
     : public iterator_internal<const R, Array<T, is_scal>::const_iterator<R>,
                                R> {
 public:
   using parent = iterator_internal<const R, const_iterator, R>;
   using value_type = typename parent::value_type;
   using pointer = typename parent::pointer;
   using reference = typename parent::reference;
   using difference_type = typename parent::difference_type;
   using iterator_category = typename parent::iterator_category;
 
 public:
   const_iterator() : parent(){};
   // const_iterator(pointer_type data, UInt offset) : parent(data, offset) {}
   // const_iterator(pointer warped) : parent(warped) {}
   // const_iterator(const parent & it) : parent(it) {}
 
   const_iterator(const const_iterator & it) = default;
   const_iterator(const_iterator && it) = default;
 
   template <typename P, typename = std::enable_if_t<not is_tensor<P>::value>>
   const_iterator(P * data) : parent(data) {}
 
   template <typename UP_P,
             typename =
                 std::enable_if_t<is_tensor<typename UP_P::element_type>::value>>
   const_iterator(UP_P && tensor) : parent(std::forward<UP_P>(tensor)) {}
 
   const_iterator & operator=(const const_iterator & it) = default;
 };
 
 template <class T, class R, bool is_tensor_ = is_tensor<R>::value>
 struct ConstConverterIteratorHelper {
   using const_iterator = typename Array<T>::template const_iterator<R>;
   using iterator = typename Array<T>::template iterator<R>;
 
   static inline const_iterator convert(const iterator & it) {
     return const_iterator(std::unique_ptr<R>(new R(*it, false)));
   }
 };
 
 template <class T, class R> struct ConstConverterIteratorHelper<T, R, false> {
   using const_iterator = typename Array<T>::template const_iterator<R>;
   using iterator = typename Array<T>::template iterator<R>;
   static inline const_iterator convert(const iterator & it) {
     return const_iterator(it.data());
   }
 };
 
 template <class T, bool is_scal>
 template <typename R>
 class Array<T, is_scal>::iterator
     : public iterator_internal<R, Array<T, is_scal>::iterator<R>> {
 public:
   using parent = iterator_internal<R, iterator>;
   using value_type = typename parent::value_type;
   using pointer = typename parent::pointer;
   using reference = typename parent::reference;
   using difference_type = typename parent::difference_type;
   using iterator_category = typename parent::iterator_category;
 
 public:
   iterator() : parent(){};
   iterator(const iterator & it) = default;
   iterator(iterator && it) = default;
 
   template <typename P, typename = std::enable_if_t<not is_tensor<P>::value>>
   iterator(P * data) : parent(data) {}
 
   template <typename UP_P,
             typename =
                 std::enable_if_t<is_tensor<typename UP_P::element_type>::value>>
   iterator(UP_P && tensor) : parent(std::forward<UP_P>(tensor)) {}
 
   iterator & operator=(const iterator & it) = default;
 
   operator const_iterator<R>() {
     return ConstConverterIteratorHelper<T, R>::convert(*this);
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <typename R>
 inline typename Array<T, is_scal>::template iterator<R>
 Array<T, is_scal>::erase(const iterator<R> & it) {
   T * curr = it.data();
   UInt pos = (curr - values) / nb_component;
   erase(pos);
   iterator<R> rit = it;
   return --rit;
 }
 #endif
 
 } // namespace akantu
 
 #endif /* __AKANTU_AKA_ARRAY_TMPL_HH__ */
diff --git a/src/common/aka_blas_lapack.hh b/src/common/aka_blas_lapack.hh
index 725fbcd0e..3da5ed016 100644
--- a/src/common/aka_blas_lapack.hh
+++ b/src/common/aka_blas_lapack.hh
@@ -1,343 +1,343 @@
 /**
  * @file   aka_blas_lapack.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Mar 06 2013
  * @date last modification: Mon Jan 18 2016
  *
  * @brief  Interface of the Fortran BLAS/LAPACK libraries
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_BLAS_LAPACK_HH__
 #define __AKANTU_AKA_BLAS_LAPACK_HH__
 
 /* -------------------------------------------------------------------------- */
 #ifdef AKANTU_USE_BLAS
 #include "aka_fortran_mangling.hh"
 extern "C" {
 
   /* ------------------------------------------------------------------------ */
   /* Double precision                                                         */
   /* ------------------------------------------------------------------------ */
   // LEVEL 1
   double AKA_FC_GLOBAL(ddot, DDOT)(int *, double *, int *, double *, int *);
 void AKA_FC_GLOBAL(daxpy, DAXPY)(int *, double *, double *, int *, double *,
                                  int *);
 
 // LEVEL 2
 void AKA_FC_GLOBAL(dgemv, DGEMV)(char *, int *, int *, double *, double *,
                                  int *, double *, int *, double *, double *,
                                  int *);
 // LEVEL 3
 void AKA_FC_GLOBAL(dgemm, DGEMM)(char *, char *, int *, int *, int *, double *,
                                  double *, int *, double *, int *, double *,
                                  double *, int *);
 /* ------------------------------------------------------------------------ */
 /* Simple precision                                                         */
 /* ------------------------------------------------------------------------ */
 // LEVEL 1
 float AKA_FC_GLOBAL(sdot, SDOT)(int *, float *, int *, float *, int *);
 void AKA_FC_GLOBAL(saxpy, SAXPY)(int *, float *, float *, int *, float *,
                                  int *);
 
 // LEVEL 2
 void AKA_FC_GLOBAL(sgemv, SGEMV)(char *, int *, int *, float *, float *, int *,
                                  float *, int *, float *, float *, int *);
 // LEVEL 3
 void AKA_FC_GLOBAL(sgemm, SGEMM)(char *, char *, int *, int *, int *, float *,
                                  float *, int *, float *, int *, float *,
                                  float *, int *);
 }
 #endif
 
 namespace akantu {
 
 #define AKANTU_WARNING_IGNORE_UNUSED_PARAMETER
 #include "aka_warning.hh"
 
 /// Wrapper around the S/DDOT BLAS function that returns the dot product of two
 /// vectors
 template <typename T>
 inline T aka_dot(int * n, T * x, int * incx, T * y, int * incy) {
-  AKANTU_DEBUG_ERROR(debug::demangle(typeid(T).name())
+  AKANTU_ERROR(debug::demangle(typeid(T).name())
                      << "is not a type recognized, or you didn't activated "
                         "BLAS in the compilation options!");
 }
 
 /// Wrapper around the S/DAXPY BLAS function that computes \f$y := \alpha x +
 /// y\f$
 template <typename T>
 inline void aka_axpy(int * n, T * alpha, T * x, int * incx, T * y, int * incy) {
-  AKANTU_DEBUG_ERROR(debug::demangle(typeid(T).name())
+  AKANTU_ERROR(debug::demangle(typeid(T).name())
                      << "is not a type recognized, or you didn't activated "
                         "BLAS in the compilation options!");
 }
 
 /// Wrapper around the S/DGEMV BLAS function that computes matrix-vector product
 /// \f$y := \alpha A^{(T)}x + \beta y \f$
 template <typename T>
 inline void aka_gemv(char * trans, int * m, int * n, T * alpha, T * a,
                      int * lda, T * x, int * incx, T * beta, T * y,
                      int * incy) {
-  AKANTU_DEBUG_ERROR(debug::demangle(typeid(T).name())
+  AKANTU_ERROR(debug::demangle(typeid(T).name())
                      << "is not a type recognized, or you didn't activated "
                         "BLAS in the compilation options!");
 }
 
 /// Wrapper around the S/DGEMM BLAS function that computes the product of two
 /// matrices \f$C := \alpha A^{(T)} B^{(T)} + \beta C \f$
 template <typename T>
 inline void aka_gemm(char * transa, char * transb, int * m, int * n, int * k,
                      T * alpha, T * a, int * lda, T * b, int * ldb, T * beta,
                      T * c, int * ldc) {
-  AKANTU_DEBUG_ERROR(debug::demangle(typeid(T).name())
+  AKANTU_ERROR(debug::demangle(typeid(T).name())
                      << "is not a type recognized, or you didn't activated "
                         "BLAS in the compilation options!");
 }
 
 #if defined(AKANTU_USE_BLAS)
 template <>
 inline double aka_dot<double>(int * n, double * x, int * incx, double * y,
                               int * incy) {
   return AKA_FC_GLOBAL(ddot, DDOT)(n, x, incx, y, incy);
 }
 
 template <>
 inline void aka_axpy(int * n, double * alpha, double * x, int * incx,
                      double * y, int * incy) {
   return AKA_FC_GLOBAL(daxpy, DAXPY)(n, alpha, x, incx, y, incy);
 }
 
 template <>
 inline void aka_gemv<double>(char * trans, int * m, int * n, double * alpha,
                              double * a, int * lda, double * x, int * incx,
                              double * beta, double * y, int * incy) {
   return AKA_FC_GLOBAL(dgemv, DGEMV)(trans, m, n, alpha, a, lda, x, incx, beta,
                                      y, incy);
 }
 
 template <>
 inline void aka_gemm<double>(char * transa, char * transb, int * m, int * n,
                              int * k, double * alpha, double * a, int * lda,
                              double * b, int * ldb, double * beta, double * c,
                              int * ldc) {
   AKA_FC_GLOBAL(dgemm, DGEMM)
   (transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc);
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
 template <>
 inline float aka_dot<float>(int * n, float * x, int * incx, float * y,
                             int * incy) {
   return AKA_FC_GLOBAL(sdot, SDOT)(n, x, incx, y, incy);
 }
 
 template <>
 inline void aka_axpy(int * n, float * alpha, float * x, int * incx, float * y,
                      int * incy) {
   return AKA_FC_GLOBAL(daxpy, DAXPY)(n, alpha, x, incx, y, incy);
 }
 
 template <>
 inline void aka_gemv<float>(char * trans, int * m, int * n, float * alpha,
                             float * a, int * lda, float * x, int * incx,
                             float * beta, float * y, int * incy) {
   AKA_FC_GLOBAL(sgemv, SGEMV)
   (trans, m, n, alpha, a, lda, x, incx, beta, y, incy);
 }
 
 template <>
 inline void aka_gemm<float>(char * transa, char * transb, int * m, int * n,
                             int * k, float * alpha, float * a, int * lda,
                             float * b, int * ldb, float * beta, float * c,
                             int * ldc) {
   AKA_FC_GLOBAL(sgemm, SGEMM)
   (transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc);
 }
 
 #endif
 
 } // akantu
 
 #ifdef AKANTU_USE_LAPACK
 #include "aka_fortran_mangling.hh"
 extern "C" {
 /* ------------------------------------------------------------------------ */
 /* Double general matrix                                                    */
 /* ------------------------------------------------------------------------ */
 /// compute the eigenvalues/vectors
 void AKA_FC_GLOBAL(dgeev, DGEEV)(char * jobvl, char * jobvr, int * n,
                                  double * a, int * lda, double * wr,
                                  double * wi, double * vl, int * ldvl,
                                  double * vr, int * ldvr, double * work,
                                  int * lwork, int * info);
 
 /// LU decomposition of a general matrix
 void AKA_FC_GLOBAL(dgetrf, DGETRF)(int * m, int * n, double * a, int * lda,
                                    int * ipiv, int * info);
 
 /// generate inverse of a matrix given its LU decomposition
 void AKA_FC_GLOBAL(dgetri, DGETRI)(int * n, double * a, int * lda, int * ipiv,
                                    double * work, int * lwork, int * info);
 
 /// solving A x = b using a LU factorization
 void AKA_FC_GLOBAL(dgetrs, DGETRS)(char * trans, int * n, int * nrhs,
                                    double * A, int * lda, int * ipiv,
                                    double * b, int * ldb, int * info);
 
 /* ------------------------------------------------------------------------ */
 /* Simple general matrix                                                    */
 /* ------------------------------------------------------------------------ */
 /// compute the eigenvalues/vectors
 void AKA_FC_GLOBAL(sgeev, SGEEV)(char * jobvl, char * jobvr, int * n, float * a,
                                  int * lda, float * wr, float * wi, float * vl,
                                  int * ldvl, float * vr, int * ldvr,
                                  float * work, int * lwork, int * info);
 
 /// LU decomposition of a general matrix
 void AKA_FC_GLOBAL(sgetrf, SGETRF)(int * m, int * n, float * a, int * lda,
                                    int * ipiv, int * info);
 
 /// generate inverse of a matrix given its LU decomposition
 void AKA_FC_GLOBAL(sgetri, SGETRI)(int * n, float * a, int * lda, int * ipiv,
                                    float * work, int * lwork, int * info);
 
 /// solving A x = b using a LU factorization
 void AKA_FC_GLOBAL(sgetrs, SGETRS)(char * trans, int * n, int * nrhs, float * A,
                                    int * lda, int * ipiv, float * b, int * ldb,
                                    int * info);
 }
 #endif // AKANTU_USE_LAPACK
 
 namespace akantu {
 
 /// Wrapper around the S/DGEEV BLAS function that computes the eigenvalues and
 /// eigenvectors of a matrix
 template <typename T>
 inline void aka_geev(char * jobvl, char * jobvr, int * n, T * a, int * lda,
                      T * wr, T * wi, T * vl, int * ldvl, T * vr, int * ldvr,
                      T * work, int * lwork, int * info) {
-  AKANTU_DEBUG_ERROR(debug::demangle(typeid(T).name())
+  AKANTU_ERROR(debug::demangle(typeid(T).name())
                      << "is not a type recognized, or you didn't activated "
                      "LAPACK in the compilation options!");
 }
 
 /// Wrapper around the S/DGETRF BLAS function that computes the LU decomposition
 /// of a matrix
 template <typename T>
 inline void aka_getrf(int * m, int * n, T * a, int * lda, int * ipiv,
                       int * info) {
-  AKANTU_DEBUG_ERROR(debug::demangle(typeid(T).name())
+  AKANTU_ERROR(debug::demangle(typeid(T).name())
                      << "is not a type recognized, or you didn't activated "
                         "LAPACK in the compilation options!");
 }
 
 /// Wrapper around the S/DGETRI BLAS function that computes the inverse of a
 /// matrix given its LU decomposition
 template <typename T>
 inline void aka_getri(int * n, T * a, int * lda, int * ipiv, T * work,
                       int * lwork, int * info) {
-  AKANTU_DEBUG_ERROR(debug::demangle(typeid(T).name())
+  AKANTU_ERROR(debug::demangle(typeid(T).name())
                      << "is not a type recognized, or you didn't activated "
                         "LAPACK in the compilation options!");
 }
 
 /// Wrapper around the S/DGETRS BLAS function that solves \f$A^{(T)}x = b\f$
 /// using LU decomposition
 template <typename T>
 inline void aka_getrs(char * trans, int * n, int * nrhs, T * A, int * lda,
                       int * ipiv, T * b, int * ldb, int * info) {
-  AKANTU_DEBUG_ERROR(debug::demangle(typeid(T).name())
+  AKANTU_ERROR(debug::demangle(typeid(T).name())
                      << "is not a type recognized, or you didn't activated "
                         "LAPACK in the compilation options!");
 }
 
 #include "aka_warning_restore.hh"
 
 #ifdef AKANTU_USE_LAPACK
 template <>
 inline void aka_geev<double>(char * jobvl, char * jobvr, int * n, double * a,
                              int * lda, double * wr, double * wi, double * vl,
                              int * ldvl, double * vr, int * ldvr, double * work,
                              int * lwork, int * info) {
   AKA_FC_GLOBAL(dgeev, DGEEV)
   (jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info);
 }
 
 template <>
 inline void aka_getrf<double>(int * m, int * n, double * a, int * lda,
                               int * ipiv, int * info) {
   AKA_FC_GLOBAL(dgetrf, DGETRF)(m, n, a, lda, ipiv, info);
 }
 
 template <>
 inline void aka_getri<double>(int * n, double * a, int * lda, int * ipiv,
                               double * work, int * lwork, int * info) {
   AKA_FC_GLOBAL(dgetri, DGETRI)(n, a, lda, ipiv, work, lwork, info);
 }
 
 template <>
 inline void aka_getrs<double>(char * trans, int * n, int * nrhs, double * A,
                               int * lda, int * ipiv, double * b, int * ldb,
                               int * info) {
   AKA_FC_GLOBAL(dgetrs, DGETRS)(trans, n, nrhs, A, lda, ipiv, b, ldb, info);
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 template <>
 inline void aka_geev<float>(char * jobvl, char * jobvr, int * n, float * a,
                             int * lda, float * wr, float * wi, float * vl,
                             int * ldvl, float * vr, int * ldvr, float * work,
                             int * lwork, int * info) {
   AKA_FC_GLOBAL(sgeev, SGEEV)
   (jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info);
 }
 
 template <>
 inline void aka_getrf<float>(int * m, int * n, float * a, int * lda, int * ipiv,
                              int * info) {
   AKA_FC_GLOBAL(sgetrf, SGETRF)(m, n, a, lda, ipiv, info);
 }
 
 template <>
 inline void aka_getri<float>(int * n, float * a, int * lda, int * ipiv,
                              float * work, int * lwork, int * info) {
   AKA_FC_GLOBAL(sgetri, SGETRI)(n, a, lda, ipiv, work, lwork, info);
 }
 
 template <>
 inline void aka_getrs<float>(char * trans, int * n, int * nrhs, float * A,
                              int * lda, int * ipiv, float * b, int * ldb,
                              int * info) {
   AKA_FC_GLOBAL(sgetrs, SGETRS)(trans, n, nrhs, A, lda, ipiv, b, ldb, info);
 }
 #endif
 
 } // akantu
 
 #endif /* __AKANTU_AKA_BLAS_LAPACK_HH__ */
diff --git a/src/common/aka_common_inline_impl.cc b/src/common/aka_common_inline_impl.cc
index 9672a2036..acab4e2b1 100644
--- a/src/common/aka_common_inline_impl.cc
+++ b/src/common/aka_common_inline_impl.cc
@@ -1,459 +1,459 @@
 /**
  * @file   aka_common_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  inline implementations of common akantu type descriptions
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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/>.
  *
  * @section DESCRIPTION
  *
  * All common things to be included in the projects files
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <cctype>
 #include <iomanip>
 #include <iostream>
 #include "aka_common.hh"
 
 /* -------------------------------------------------------------------------- */
 #ifndef __AKANTU_AKA_COMMON_INLINE_IMPL_CC__
 #define __AKANTU_AKA_COMMON_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /// standard output stream operator for GhostType
 inline std::ostream & operator<<(std::ostream & stream, GhostType type) {
   switch (type) {
   case _not_ghost:
     stream << "not_ghost";
     break;
   case _ghost:
     stream << "ghost";
     break;
   case _casper:
     stream << "Casper the friendly ghost";
     break;
   }
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /// standard output stream operator for TimeStepSolverType
 inline std::ostream & operator<<(std::ostream & stream,
                                  const TimeStepSolverType & type) {
   switch (type) {
   case _tsst_static:
     stream << "static";
     break;
   case _tsst_dynamic:
     stream << "dynamic";
     break;
   case _tsst_dynamic_lumped:
     stream << "dynamic_lumped";
     break;
   case _tsst_not_defined:
     stream << "not defined time step solver";
     break;
   }
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /// standard input stream operator for TimeStepSolverType
 inline std::istream & operator>>(std::istream & stream,
                                  TimeStepSolverType & type) {
   std::string str;
   stream >> str;
   if (str == "static")
     type = _tsst_static;
   else if (str == "dynamic")
     type = _tsst_dynamic;
   else if (str == "dynamic_lumped")
     type = _tsst_dynamic_lumped;
   else {
-    AKANTU_DEBUG_ERROR("The type "
+    AKANTU_ERROR("The type "
                        << str << " is not a recognized TimeStepSolverType");
 
     stream.setstate(std::ios::failbit);
   }
 
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /// standard output stream operator for NonLinearSolverType
 inline std::ostream & operator<<(std::ostream & stream,
                                  const NonLinearSolverType & type) {
   switch (type) {
   case _nls_linear:
     stream << "linear";
     break;
   case _nls_newton_raphson:
     stream << "newton_raphson";
     break;
   case _nls_newton_raphson_modified:
     stream << "newton_raphson_modified";
     break;
   case _nls_lumped:
     stream << "lumped";
     break;
   case _nls_auto:
     stream << "auto";
     break;
   }
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /// standard input stream operator for NonLinearSolverType
 inline std::istream & operator>>(std::istream & stream,
                                  NonLinearSolverType & type) {
   std::string str;
   stream >> str;
   if (str == "linear")
     type = _nls_linear;
   else if (str == "newton_raphson")
     type = _nls_newton_raphson;
   else if (str == "newton_raphson_modified")
     type = _nls_newton_raphson_modified;
   else if (str == "lumped")
     type = _nls_lumped;
   else if (str == "auto")
     type = _nls_auto;
   else
     type = _nls_auto;
 
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /// standard output stream operator for IntegrationSchemeType
 inline std::ostream & operator<<(std::ostream & stream,
                                  const IntegrationSchemeType & type) {
   switch (type) {
   case _ist_pseudo_time:
     stream << "pseudo_time";
     break;
   case _ist_forward_euler:
     stream << "forward_euler";
     break;
   case _ist_trapezoidal_rule_1:
     stream << "trapezoidal_rule_1";
     break;
   case _ist_backward_euler:
     stream << "backward_euler";
     break;
   case _ist_central_difference:
     stream << "central_difference";
     break;
   case _ist_fox_goodwin:
     stream << "fox_goodwin";
     break;
   case _ist_trapezoidal_rule_2:
     stream << "trapezoidal_rule_2";
     break;
   case _ist_linear_acceleration:
     stream << "linear_acceleration";
     break;
   case _ist_newmark_beta:
     stream << "newmark_beta";
     break;
   case _ist_generalized_trapezoidal:
     stream << "generalized_trapezoidal";
     break;
   }
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /// standard input stream operator for IntegrationSchemeType
 inline std::istream & operator>>(std::istream & stream,
                                  IntegrationSchemeType & type) {
   std::string str;
   stream >> str;
 
   if (str == "pseudo_time")
     type = _ist_pseudo_time;
   else if (str == "forward_euler")
     type = _ist_forward_euler;
   else if (str == "trapezoidal_rule_1")
     type = _ist_trapezoidal_rule_1;
   else if (str == "backward_euler")
     type = _ist_backward_euler;
   else if (str == "central_difference")
     type = _ist_central_difference;
   else if (str == "fox_goodwin")
     type = _ist_fox_goodwin;
   else if (str == "trapezoidal_rule_2")
     type = _ist_trapezoidal_rule_2;
   else if (str == "linear_acceleration")
     type = _ist_linear_acceleration;
   else if (str == "newmark_beta")
     type = _ist_newmark_beta;
   else if (str == "generalized_trapezoidal")
     type = _ist_generalized_trapezoidal;
   else {
-    AKANTU_DEBUG_ERROR("The type "
+    AKANTU_ERROR("The type "
                        << str << " is not a recognized IntegrationSchemeType");
     stream.setstate(std::ios::failbit);
   }
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /// standard output stream operator for SynchronizationTag
 inline std::ostream & operator<<(std::ostream & stream,
                                  SynchronizationTag type) {
   switch (type) {
   case _gst_whatever:
     stream << "_gst_whatever";
     break;
   case _gst_update:
     stream << "_gst_update";
     break;
   case _gst_size:
     stream << "_gst_size";
     break;
   case _gst_smm_mass:
     stream << "_gst_smm_mass";
     break;
   case _gst_smm_for_gradu:
     stream << "_gst_smm_for_gradu";
     break;
   case _gst_smm_boundary:
     stream << "_gst_smm_boundary";
     break;
   case _gst_smm_uv:
     stream << "_gst_smm_uv";
     break;
   case _gst_smm_res:
     stream << "_gst_smm_res";
     break;
   case _gst_smm_init_mat:
     stream << "_gst_smm_init_mat";
     break;
   case _gst_smm_stress:
     stream << "_gst_smm_stress";
     break;
   case _gst_smmc_facets:
     stream << "_gst_smmc_facets";
     break;
   case _gst_smmc_facets_conn:
     stream << "_gst_smmc_facets_conn";
     break;
   case _gst_smmc_facets_stress:
     stream << "_gst_smmc_facets_stress";
     break;
   case _gst_smmc_damage:
     stream << "_gst_smmc_damage";
     break;
   case _gst_giu_global_conn:
     stream << "_gst_giu_global_conn";
     break;
   case _gst_ce_groups:
     stream << "_gst_ce_groups";
     break;
   case _gst_gm_clusters:
     stream << "_gst_gm_clusters";
     break;
   case _gst_htm_capacity:
     stream << "_gst_htm_capacity";
     break;
   case _gst_htm_temperature:
     stream << "_gst_htm_temperature";
     break;
   case _gst_htm_gradient_temperature:
     stream << "_gst_htm_gradient_temperature";
     break;
   case _gst_htm_phi:
     stream << "_gst_htm_phi";
     break;
   case _gst_htm_gradient_phi:
     stream << "_gst_htm_gradient_phi";
     break;
   case _gst_mnl_for_average:
     stream << "_gst_mnl_for_average";
     break;
   case _gst_mnl_weight:
     stream << "_gst_mnl_weight";
     break;
   case _gst_nh_criterion:
     stream << "_gst_nh_criterion";
     break;
   case _gst_test:
     stream << "_gst_test";
     break;
   case _gst_user_1:
     stream << "_gst_user_1";
     break;
   case _gst_user_2:
     stream << "_gst_user_2";
     break;
   case _gst_material_id:
     stream << "_gst_material_id";
     break;
   case _gst_for_dump:
     stream << "_gst_for_dump";
     break;
   case _gst_cf_nodal:
     stream << "_gst_cf_nodal";
     break;
   case _gst_cf_incr:
     stream << "_gst_cf_incr";
     break;
   case _gst_solver_solution:
     stream << "_gst_solver_solution";
     break;
   }
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /// standard output stream operator for SolveConvergenceCriteria
 inline std::ostream & operator<<(std::ostream & stream,
                                  const SolveConvergenceCriteria & criteria) {
   switch (criteria) {
   case _scc_residual:
     stream << "_scc_residual";
     break;
   case _scc_solution:
     stream << "_scc_solution";
     break;
   case _scc_residual_mass_wgh:
     stream << "_scc_residual_mass_wgh";
     break;
   }
   return stream;
 }
 
 inline std::istream & operator>>(std::istream & stream,
                                  SolveConvergenceCriteria & criteria) {
   std::string str;
   stream >> str;
   if (str == "residual")
     criteria = _scc_residual;
   else if (str == "solution")
     criteria = _scc_solution;
   else if (str == "residual_mass_wgh")
     criteria = _scc_residual_mass_wgh;
   else {
     stream.setstate(std::ios::failbit);
   }
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 inline std::string to_lower(const std::string & str) {
   std::string lstr = str;
   std::transform(lstr.begin(), lstr.end(), lstr.begin(), (int (*)(int))tolower);
   return lstr;
 }
 
 /* -------------------------------------------------------------------------- */
 inline std::string trim(const std::string & to_trim) {
   std::string trimed = to_trim;
   // left trim
   trimed.erase(trimed.begin(),
                std::find_if(trimed.begin(), trimed.end(),
                             std::not1(std::ptr_fun<int, int>(isspace))));
   // right trim
   trimed.erase(std::find_if(trimed.rbegin(), trimed.rend(),
                             std::not1(std::ptr_fun<int, int>(isspace)))
                    .base(),
                trimed.end());
   return trimed;
 }
 
 } // akantu
 
 #include <cmath>
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename T> std::string printMemorySize(UInt size) {
   Real real_size = size * sizeof(T);
 
   UInt mult = 0;
   if (real_size != 0)
     mult = (std::log(real_size) / std::log(2)) / 10;
 
   std::stringstream sstr;
 
   real_size /= Real(1 << (10 * mult));
   sstr << std::setprecision(2) << std::fixed << real_size;
 
   std::string size_prefix;
   switch (mult) {
   case 0:
     sstr << "";
     break;
   case 1:
     sstr << "Ki";
     break;
   case 2:
     sstr << "Mi";
     break;
   case 3:
     sstr << "Gi";
     break; // I started on this type of machines
            // (32bit computers) (Nicolas)
   case 4:
     sstr << "Ti";
     break;
   case 5:
     sstr << "Pi";
     break;
   case 6:
     sstr << "Ei";
     break; // theoritical limit of RAM of the current
            // computers in 2014 (64bit computers) (Nicolas)
   case 7:
     sstr << "Zi";
     break;
   case 8:
     sstr << "Yi";
     break;
   default:
-    AKANTU_DEBUG_ERROR(
+    AKANTU_ERROR(
         "The programmer in 2014 didn't thought so far (even wikipedia does not "
         "go further)."
         << " You have at least 1024 times more than a yobibit of RAM!!!"
         << " Just add the prefix corresponding in this switch case.");
   }
 
   sstr << "Byte";
 
   return sstr.str();
 }
 
 } // akantu
 
 #endif /* __AKANTU_AKA_COMMON_INLINE_IMPL_CC__ */
diff --git a/src/common/aka_element_classes_info.hh.in b/src/common/aka_element_classes_info.hh.in
index ca799d579..1fbdeadf1 100644
--- a/src/common/aka_element_classes_info.hh.in
+++ b/src/common/aka_element_classes_info.hh.in
@@ -1,217 +1,217 @@
 /**
  * @file   aka_element_classes_info.hh.in
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Jul 19 2015
  * @date last modification: Fri Oct 16 2015
  *
  * @brief  Declaration of the enums for the element classes
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 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 <boost/preprocessor.hpp>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_ELEMENT_CLASSES_INFO_HH__
 #define __AKANTU_AKA_ELEMENT_CLASSES_INFO_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* Element Types                                                              */
 /* -------------------------------------------------------------------------- */
 
 /// @enum ElementType type of elements
 enum ElementType {
   _not_defined,
   @AKANTU_ELEMENT_TYPES_ENUM@
   _max_element_type
 };
 
 @AKANTU_ELEMENT_TYPES_BOOST_SEQ@
 
 @AKANTU_ALL_ELEMENT_BOOST_SEQ@
 
 /* -------------------------------------------------------------------------- */
 /* Element Kinds                                                              */
 /* -------------------------------------------------------------------------- */
 @AKANTU_ELEMENT_KINDS_BOOST_SEQ@
 
 @AKANTU_ELEMENT_KIND_BOOST_SEQ@
 
 #ifndef SWIG
 enum ElementKind {
   BOOST_PP_SEQ_ENUM(AKANTU_ELEMENT_KIND),
   _ek_not_defined
 };
 
 
 /* -------------------------------------------------------------------------- */
 struct ElementKind_def {
   using type = ElementKind;
   static const type _begin_ = BOOST_PP_SEQ_HEAD(AKANTU_ELEMENT_KIND);
   static const type _end_   = _ek_not_defined;
 };
 
 using element_kind_t = safe_enum<ElementKind_def> ;
 #else
 enum ElementKind;
 #endif
 
 /* -------------------------------------------------------------------------- */
 /// @enum GeometricalType type of element potentially contained in a Mesh
 enum GeometricalType {
   @AKANTU_GEOMETRICAL_TYPES_ENUM@
   _gt_not_defined
 };
 
 /* -------------------------------------------------------------------------- */
 /* Interpolation Types                                                        */
 /* -------------------------------------------------------------------------- */
 @AKANTU_INTERPOLATION_TYPES_BOOST_SEQ@
 
 #ifndef SWIG
 /// @enum InterpolationType type of elements
 enum InterpolationType {
   BOOST_PP_SEQ_ENUM(AKANTU_INTERPOLATION_TYPES),
   _itp_not_defined
 };
 #else
 enum InterpolationType;
 #endif
 
 /* -------------------------------------------------------------------------- */
 /* Some sub types less probable to change                                     */
 /* -------------------------------------------------------------------------- */
 /// @enum GeometricalShapeType types of shapes to define the contains
 /// function in the element classes
 enum GeometricalShapeType {
   @AKANTU_GEOMETRICAL_SHAPES_ENUM@
   _gst_not_defined
 };
 
 /* -------------------------------------------------------------------------- */
 /// @enum GaussIntegrationType classes of types using common
 /// description of the gauss point position and weights
 enum GaussIntegrationType {
   @AKANTU_GAUSS_INTEGRATION_TYPES_ENUM@
   _git_not_defined
 };
 
 /* -------------------------------------------------------------------------- */
 /// @enum InterpolationKind the family of interpolation types
 enum InterpolationKind {
   @AKANTU_INTERPOLATION_KIND_ENUM@
   _itk_not_defined
 };
 
 /* -------------------------------------------------------------------------- */
 // BOOST PART: TOUCH ONLY IF YOU KNOW WHAT YOU ARE DOING
 #define AKANTU_BOOST_CASE_MACRO(r, macro, _type)                               \
   case _type: {                                                                \
     macro(_type);                                                              \
     break;                                                                     \
   }
 
 #define AKANTU_BOOST_LIST_SWITCH(macro1, list1, var)                           \
   do {                                                                         \
     switch (var) {                                                             \
       BOOST_PP_SEQ_FOR_EACH(AKANTU_BOOST_CASE_MACRO, macro1, list1)            \
     default: {                                                                 \
-      AKANTU_DEBUG_ERROR("Type (" << var << ") not handled by this function"); \
+      AKANTU_ERROR("Type (" << var << ") not handled by this function"); \
     }                                                                          \
     }                                                                          \
   } while (0)
 
 #define AKANTU_BOOST_LIST_SWITCH_NO_DEFAULT(macro1, list1, var)                \
   do {                                                                         \
     switch (var) {                                                             \
       BOOST_PP_SEQ_FOR_EACH(AKANTU_BOOST_CASE_MACRO, macro1, list1)            \
     case _not_defined:                                                         \
       break;                                                                   \
     case _max_element_type:                                                    \
       break;                                                                   \
     }                                                                          \
   } while (0)
 
 #define AKANTU_BOOST_ELEMENT_SWITCH(macro1, list1)                             \
   AKANTU_BOOST_LIST_SWITCH(macro1, list1, type)
 
 #define AKANTU_BOOST_ELEMENT_SWITCH_NO_DEFAULT(macro1, list1)                  \
   AKANTU_BOOST_LIST_SWITCH_NO_DEFAULT(macro1, list1, type)
 
 #define AKANTU_BOOST_ALL_ELEMENT_SWITCH(macro)                                 \
   AKANTU_BOOST_ELEMENT_SWITCH(macro, AKANTU_ALL_ELEMENT_TYPE)
 
 #define AKANTU_BOOST_ALL_ELEMENT_SWITCH_NO_DEFAULT(macro)                      \
   AKANTU_BOOST_ELEMENT_SWITCH_NO_DEFAULT(macro, AKANTU_ALL_ELEMENT_TYPE)
 
 #define AKANTU_BOOST_LIST_MACRO(r, macro, type) macro(type)
 
 #define AKANTU_BOOST_APPLY_ON_LIST(macro, list)                                \
   BOOST_PP_SEQ_FOR_EACH(AKANTU_BOOST_LIST_MACRO, macro, list)
 
 #define AKANTU_BOOST_ALL_ELEMENT_LIST(macro)                                   \
   AKANTU_BOOST_APPLY_ON_LIST(macro, AKANTU_ALL_ELEMENT_TYPE)
 
 #define AKANTU_GET_ELEMENT_LIST(kind) AKANTU##kind##_ELEMENT_TYPE
 
 #define AKANTU_BOOST_KIND_ELEMENT_SWITCH(macro, kind)                          \
   AKANTU_BOOST_ELEMENT_SWITCH(macro, AKANTU_GET_ELEMENT_LIST(kind))
 
 // BOOST_PP_SEQ_TO_LIST does not exists in Boost < 1.49
 #define AKANTU_GENERATE_KIND_LIST(seq)                                         \
   BOOST_PP_TUPLE_TO_LIST(BOOST_PP_SEQ_SIZE(seq), BOOST_PP_SEQ_TO_TUPLE(seq))
 
 #define AKANTU_ELEMENT_KIND_BOOST_LIST                                         \
   AKANTU_GENERATE_KIND_LIST(AKANTU_ELEMENT_KIND)
 
 #define AKANTU_BOOST_ALL_KIND_LIST(macro, list)                                \
   BOOST_PP_LIST_FOR_EACH(AKANTU_BOOST_LIST_MACRO, macro, list)
 
 #define AKANTU_BOOST_ALL_KIND(macro)                                           \
   AKANTU_BOOST_ALL_KIND_LIST(macro, AKANTU_ELEMENT_KIND_BOOST_LIST)
 
 #define AKANTU_BOOST_ALL_KIND_SWITCH(macro)                                    \
   AKANTU_BOOST_LIST_SWITCH(macro, AKANTU_ELEMENT_KIND, kind)
 
 @AKANTU_ELEMENT_KINDS_BOOST_MACROS@
 
 // /// define kept for compatibility reasons (they are most probably not needed
 // /// anymore) \todo check if they can be removed
 // #define AKANTU_REGULAR_ELEMENT_TYPE	AKANTU_ek_regular_ELEMENT_TYPE
 // #define AKANTU_COHESIVE_ELEMENT_TYPE	AKANTU_ek_cohesive_ELEMENT_TYPE
 // #define AKANTU_STRUCTURAL_ELEMENT_TYPE  AKANTU_ek_structural_ELEMENT_TYPE
 // #define AKANTU_IGFEM_ELEMENT_TYPE       AKANTU_ek_igfem_ELEMENT_TYPE
 
 /* -------------------------------------------------------------------------- */
 /* Lists of interests for FEEngineTemplate functions                          */
 /* -------------------------------------------------------------------------- */
 @AKANTU_FE_ENGINE_LISTS@
 
 } // akantu
 
 #endif /* __AKANTU_AKA_ELEMENT_CLASSES_INFO_HH__ */
 
 #include "aka_element_classes_info_inline_impl.cc"
diff --git a/src/common/aka_error.hh b/src/common/aka_error.hh
index ff2e2675f..b4024688a 100644
--- a/src/common/aka_error.hh
+++ b/src/common/aka_error.hh
@@ -1,338 +1,338 @@
 /**
  * @file   aka_error.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Jun 14 2010
  * @date last modification: Mon Jul 13 2015
  *
  * @brief  error management and internal exceptions
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 <sstream>
 #include <typeinfo>
 #include <utility>
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __AKANTU_ERROR_HH__
 #define __AKANTU_ERROR_HH__
 
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 enum DebugLevel {
   dbl0 = 0,
   dblError = 0,
   dblAssert = 0,
   dbl1 = 1,
   dblException = 1,
   dblCritical = 1,
   dbl2 = 2,
   dblMajor = 2,
   dbl3 = 3,
   dblCall = 3,
   dblSecondary = 3,
   dblHead = 3,
   dbl4 = 4,
   dblWarning = 4,
   dbl5 = 5,
   dblInfo = 5,
   dbl6 = 6,
   dblIn = 6,
   dblOut = 6,
   dbl7 = 7,
   dbl8 = 8,
   dblTrace = 8,
   dbl9 = 9,
   dblAccessory = 9,
   dbl10 = 10,
   dblDebug = 42,
   dbl100 = 100,
   dblDump = 100,
   dblTest = 1337
 };
 
 /* -------------------------------------------------------------------------- */
 #define AKANTU_LOCATION                                                        \
   "(" << __func__ << "(): " << __FILE__ << ":" << __LINE__ << ")"
 
 /* -------------------------------------------------------------------------- */
 namespace debug {
   void setDebugLevel(const DebugLevel & level);
   const DebugLevel & getDebugLevel();
 
   void initSignalHandler();
   std::string demangle(const char * symbol);
   std::string exec(const std::string & cmd);
 
   void printBacktrace(int sig);
 
   void exit(int status) __attribute__((noreturn));
   /* ------------------------------------------------------------------------ */
   /// exception class that can be thrown by akantu
   class Exception : public std::exception {
     /* ---------------------------------------------------------------------- */
     /* Constructors/Destructors                                               */
     /* ---------------------------------------------------------------------- */
   protected:
     explicit Exception(std::string info = "")
         : _info(std::move(info)), _file("") {}
 
   public:
     //! full constructor
     Exception(std::string info, std::string file, unsigned int line)
         : _info(std::move(info)), _file(std::move(file)), _line(line) {}
 
     //! destructor
     ~Exception() noexcept override = default;
 
     /* ---------------------------------------------------------------------- */
     /*  Methods */
     /* ---------------------------------------------------------------------- */
   public:
     const char * what() const noexcept override { return _info.c_str(); }
 
     virtual const std::string info() const noexcept {
       std::stringstream stream;
       stream << debug::demangle(typeid(*this).name()) << " : " << _info << " ["
              << _file << ":" << _line << "]";
       return stream.str();
     }
 
   public:
     void setInfo(const std::string & info) { _info = info; }
     void setFile(const std::string & file) { _file = file; }
     void setLine(unsigned int line) { _line = line; }
     /* ---------------------------------------------------------------------- */
     /* Class Members                                                          */
     /* ---------------------------------------------------------------------- */
   protected:
     /// exception description and additionals
     std::string _info;
 
   private:
     /// file it is thrown from
     std::string _file;
 
     /// ligne it is thrown from
     unsigned int _line{0};
   };
 
   class CriticalError : public Exception {};
   class AssertException : public Exception {};
+  class NotImplementedException : public Exception {};
 
   /// standard output stream operator
   inline std::ostream & operator<<(std::ostream & stream,
                                    const Exception & _this) {
     stream << _this.what();
     return stream;
   }
 
   /* --------------------------------------------------------------------------
    */
   class Debugger {
   public:
     Debugger();
     virtual ~Debugger();
     Debugger(const Debugger &) = default;
     Debugger & operator=(const Debugger &) = default;
 
     void exit(int status) __attribute__((noreturn));
 
     void throwException(const std::string & info, const std::string & file,
                         unsigned int line, bool, const std::string &) const
         noexcept(false) __attribute__((noreturn));
 
     /*----------------------------------------------------------------------- */
     template <class Except>
     void throwCustomException(const Except & ex, const std::string & info,
                               const std::string & file, unsigned int line) const
         noexcept(false) __attribute__((noreturn));
     /*----------------------------------------------------------------------- */
     template <class Except>
     void throwCustomException(const Except & ex, const std::string & file,
                               unsigned int line) const noexcept(false)
         __attribute__((noreturn));
 
     void printMessage(const std::string & prefix, const DebugLevel & level,
                       const std::string & info) const;
 
     void setOutStream(std::ostream & out) { cout = &out; }
     std::ostream & getOutStream() { return *cout; }
 
   public:
     void setParallelContext(int rank, int size);
 
     void setDebugLevel(const DebugLevel & level);
     const DebugLevel & getDebugLevel() const;
 
     void setLogFile(const std::string & filename);
     std::ostream & getOutputStream();
 
     inline bool testLevel(const DebugLevel & level) const {
       return (this->level >= (level));
     }
 
     void printBacktrace(bool on_off) { this->print_backtrace = on_off; }
     bool printBacktrace() { return this->print_backtrace; }
 
   private:
     std::string parallel_context;
     std::ostream * cout;
     bool file_open;
     DebugLevel level;
     bool print_backtrace;
   };
 
   extern Debugger debugger;
 } // namespace debug
 
 /* -------------------------------------------------------------------------- */
 #define AKANTU_STRINGSTREAM_IN(_str, _sstr)                                    \
   ;                                                                            \
   do {                                                                         \
     std::stringstream _dbg_s_info;                                             \
     _dbg_s_info << _sstr;                                                      \
     _str = _dbg_s_info.str();                                                  \
   } while (false)
 
 /* -------------------------------------------------------------------------- */
 #define AKANTU_EXCEPTION(info) AKANTU_EXCEPTION_(info, false)
 
 #define AKANTU_SILENT_EXCEPTION(info) AKANTU_EXCEPTION_(info, true)
 
 #define AKANTU_EXCEPTION_(info, silent)                                        \
   do {                                                                         \
     std::stringstream _dbg_str;                                                \
     _dbg_str << info;                                                          \
     std::stringstream _dbg_loc;                                                \
     _dbg_loc << AKANTU_LOCATION;                                               \
     ::akantu::debug::debugger.throwException(                                  \
         _dbg_str.str(), __FILE__, __LINE__, silent, _dbg_loc.str());           \
   } while (false)
 
 #define AKANTU_CUSTOM_EXCEPTION_INFO(ex, info)                                 \
   do {                                                                         \
     std::stringstream _dbg_str;                                                \
     _dbg_str << info;                                                          \
     ::akantu::debug::debugger.throwCustomException(ex, _dbg_str.str(),         \
                                                    __FILE__, __LINE__);        \
   } while (false)
 
 #define AKANTU_CUSTOM_EXCEPTION(ex)                                            \
   do {                                                                         \
     ::akantu::debug::debugger.throwCustomException(ex, __FILE__, __LINE__);    \
   } while (false)
 
 /* -------------------------------------------------------------------------- */
 #ifdef AKANTU_NDEBUG
 #define AKANTU_DEBUG_TEST(level) (false)
 #define AKANTU_DEBUG_LEVEL_IS_TEST()                                           \
   (::akantu::debug::debugger.testLevel(dblTest))
 #define AKANTU_DEBUG(level, info)
 #define AKANTU_DEBUG_(pref, level, info)
 #define AKANTU_DEBUG_IN()
 #define AKANTU_DEBUG_OUT()
 #define AKANTU_DEBUG_INFO(info)
 #define AKANTU_DEBUG_WARNING(info)
 #define AKANTU_DEBUG_TRACE(info)
 #define AKANTU_DEBUG_ASSERT(test, info)
-#define AKANTU_DEBUG_ERROR(info)                                               \
+#define AKANTU_ERROR(info)                                               \
   AKANTU_CUSTOM_EXCEPTION_INFO(::akantu::debug::CriticalError(), info)
-#define AKANTU_DEBUG_TO_IMPLEMENT() ::akantu::debug::debugger.exit(EXIT_FAILURE)
-
 /* -------------------------------------------------------------------------- */
 #else
 #define AKANTU_DEBUG(level, info) AKANTU_DEBUG_("   ", level, info)
 
 #define AKANTU_DEBUG_(pref, level, info)                                       \
   do {                                                                         \
     std::string _dbg_str;                                                      \
     AKANTU_STRINGSTREAM_IN(_dbg_str, info << " " << AKANTU_LOCATION);          \
     ::akantu::debug::debugger.printMessage(pref, level, _dbg_str);             \
   } while (false)
 
 #define AKANTU_DEBUG_TEST(level) (::akantu::debug::debugger.testLevel(level))
 
 #define AKANTU_DEBUG_LEVEL_IS_TEST()                                           \
   (::akantu::debug::debugger.testLevel(dblTest))
 
 #define AKANTU_DEBUG_IN()                                                      \
   AKANTU_DEBUG_("==>", ::akantu::dblIn, __func__ << "()")
 
 #define AKANTU_DEBUG_OUT()                                                     \
   AKANTU_DEBUG_("<==", ::akantu::dblOut, __func__ << "()")
 
 #define AKANTU_DEBUG_INFO(info) AKANTU_DEBUG_("---", ::akantu::dblInfo, info)
 
 #define AKANTU_DEBUG_WARNING(info)                                             \
   AKANTU_DEBUG_("/!\\", ::akantu::dblWarning, info)
 
 #define AKANTU_DEBUG_TRACE(info) AKANTU_DEBUG_(">>>", ::akantu::dblTrace, info)
 
 #define AKANTU_DEBUG_ASSERT(test, info)                                        \
   do {                                                                         \
-    if (not (test))                                                     \
+    if (not(test))                                                             \
       AKANTU_CUSTOM_EXCEPTION_INFO(::akantu::debug::AssertException(),         \
                                    "assert [" << #test << "] " << info);       \
   } while (false)
 
-#define AKANTU_DEBUG_ERROR(info)                                               \
+#define AKANTU_ERROR(info)                                               \
   do {                                                                         \
     AKANTU_DEBUG_("!!! ", ::akantu::dblError, info);                           \
-    std::terminate();                                                          \
+    AKANTU_CUSTOM_EXCEPTION_INFO(::akantu::debug::CriticalError(), info);      \
   } while (false)
-
-#define AKANTU_DEBUG_TO_IMPLEMENT()                                            \
-  AKANTU_DEBUG_ERROR(__func__ << " : not implemented yet !")
 #endif // AKANTU_NDEBUG
 
+#define AKANTU_TO_IMPLEMENT()                                           \
+  AKANTU_CUSTOM_EXCEPTION_INFO(::akantu::debug::NotImplementedException(),     \
+                               __func__ << " : not implemented yet !")
+
 /* -------------------------------------------------------------------------- */
 
 namespace debug {
   /* ------------------------------------------------------------------------ */
   template <class Except>
   void Debugger::throwCustomException(const Except & ex,
                                       const std::string & info,
                                       const std::string & file,
                                       unsigned int line) const noexcept(false) {
     auto & nc_ex = const_cast<Except &>(ex);
     nc_ex.setInfo(info);
     nc_ex.setFile(file);
     nc_ex.setLine(line);
     throw ex;
   }
   /* ------------------------------------------------------------------------ */
   template <class Except>
   void Debugger::throwCustomException(const Except & ex,
                                       const std::string & file,
                                       unsigned int line) const noexcept(false) {
     auto & nc_ex = const_cast<Except &>(ex);
     nc_ex.setFile(file);
     nc_ex.setLine(line);
     throw ex;
   }
 } // namespace debug
 } // namespace akantu
 
 #endif /* __AKANTU_ERROR_HH__ */
diff --git a/src/common/aka_math_tmpl.hh b/src/common/aka_math_tmpl.hh
index 1d89a8493..3c49bbdde 100644
--- a/src/common/aka_math_tmpl.hh
+++ b/src/common/aka_math_tmpl.hh
@@ -1,784 +1,784 @@
 /**
  * @file   aka_math_tmpl.hh
  *
  * @author Ramin Aghababaei <ramin.aghababaei@epfl.ch>
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Alejandro M. Aragón <alejandro.aragon@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Mathilde Radiguet <mathilde.radiguet@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Leonardo Snozzi <leonardo.snozzi@epfl.ch>
  * @author Peter Spijker <peter.spijker@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Aug 04 2010
  * @date last modification: Wed Oct 21 2015
  *
  * @brief  Implementation of the inline functions of the math toolkit
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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/>.
  *
  */
 
 } // akantu
 
 #include <cmath>
 #include <cstring>
 #include <typeinfo>
 
 #include "aka_blas_lapack.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline void Math::matrix_vector(UInt im, UInt in, Real * A, Real * x, Real * y,
                                 Real alpha) {
 #ifdef AKANTU_USE_BLAS
   /// y = alpha*op(A)*x + beta*y
   char tran_A = 'N';
   int incx = 1;
   int incy = 1;
   double beta = 0.;
   int m = im;
   int n = in;
 
   aka_gemv(&tran_A, &m, &n, &alpha, A, &m, x, &incx, &beta, y, &incy);
 
 #else
   memset(y, 0, im * sizeof(Real));
   for (UInt i = 0; i < im; ++i) {
     for (UInt j = 0; j < in; ++j) {
       y[i] += A[i + j * im] * x[j];
     }
     y[i] *= alpha;
   }
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::matrixt_vector(UInt im, UInt in, Real * A, Real * x, Real * y,
                                  Real alpha) {
 #ifdef AKANTU_USE_BLAS
   /// y = alpha*op(A)*x + beta*y
   char tran_A = 'T';
   int incx = 1;
   int incy = 1;
   double beta = 0.;
   int m = im;
   int n = in;
 
   aka_gemv(&tran_A, &m, &n, &alpha, A, &m, x, &incx, &beta, y, &incy);
 #else
   memset(y, 0, in * sizeof(Real));
   for (UInt i = 0; i < im; ++i) {
     for (UInt j = 0; j < in; ++j) {
       y[j] += A[j * im + i] * x[i];
     }
     y[i] *= alpha;
   }
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::matrix_matrix(UInt im, UInt in, UInt ik, Real * A, Real * B,
                                 Real * C, Real alpha) {
 #ifdef AKANTU_USE_BLAS
   ///  C := alpha*op(A)*op(B) + beta*C
   char trans_a = 'N';
   char trans_b = 'N';
   double beta = 0.;
   int m = im, n = in, k = ik;
 
   aka_gemm(&trans_a, &trans_b, &m, &n, &k, &alpha, A, &m, B, &k, &beta, C, &m);
 #else
   memset(C, 0, im * in * sizeof(Real));
   for (UInt j = 0; j < in; ++j) {
     UInt _jb = j * ik;
     UInt _jc = j * im;
     for (UInt i = 0; i < im; ++i) {
       for (UInt l = 0; l < ik; ++l) {
         UInt _la = l * im;
         C[i + _jc] += A[i + _la] * B[l + _jb];
       }
       C[i + _jc] *= alpha;
     }
   }
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::matrixt_matrix(UInt im, UInt in, UInt ik, Real * A, Real * B,
                                  Real * C, Real alpha) {
 #ifdef AKANTU_USE_BLAS
   ///  C := alpha*op(A)*op(B) + beta*C
   char trans_a = 'T';
   char trans_b = 'N';
   double beta = 0.;
   int m = im, n = in, k = ik;
 
   aka_gemm(&trans_a, &trans_b, &m, &n, &k, &alpha, A, &k, B, &k, &beta, C, &m);
 #else
   memset(C, 0, im * in * sizeof(Real));
   for (UInt j = 0; j < in; ++j) {
     UInt _jc = j * im;
     UInt _jb = j * ik;
     for (UInt i = 0; i < im; ++i) {
       UInt _ia = i * ik;
       for (UInt l = 0; l < ik; ++l) {
         C[i + _jc] += A[l + _ia] * B[l + _jb];
       }
       C[i + _jc] *= alpha;
     }
   }
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::matrix_matrixt(UInt im, UInt in, UInt ik, Real * A, Real * B,
                                  Real * C, Real alpha) {
 #ifdef AKANTU_USE_BLAS
   ///  C := alpha*op(A)*op(B) + beta*C
   char trans_a = 'N';
   char trans_b = 'T';
   double beta = 0.;
   int m = im, n = in, k = ik;
 
   aka_gemm(&trans_a, &trans_b, &m, &n, &k, &alpha, A, &m, B, &n, &beta, C, &m);
 #else
   memset(C, 0, im * in * sizeof(Real));
   for (UInt j = 0; j < in; ++j) {
     UInt _jc = j * im;
     for (UInt i = 0; i < im; ++i) {
       for (UInt l = 0; l < ik; ++l) {
         UInt _la = l * im;
         UInt _lb = l * in;
         C[i + _jc] += A[i + _la] * B[j + _lb];
       }
       C[i + _jc] *= alpha;
     }
   }
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::matrixt_matrixt(UInt im, UInt in, UInt ik, Real * A, Real * B,
                                   Real * C, Real alpha) {
 #ifdef AKANTU_USE_BLAS
   ///  C := alpha*op(A)*op(B) + beta*C
   char trans_a = 'T';
   char trans_b = 'T';
   double beta = 0.;
   int m = im, n = in, k = ik;
 
   aka_gemm(&trans_a, &trans_b, &m, &n, &k, &alpha, A, &k, B, &n, &beta, C, &m);
 #else
   memset(C, 0, im * in * sizeof(Real));
   for (UInt j = 0; j < in; ++j) {
     UInt _jc = j * im;
     for (UInt i = 0; i < im; ++i) {
       UInt _ia = i * ik;
       for (UInt l = 0; l < ik; ++l) {
         UInt _lb = l * in;
         C[i + _jc] += A[l + _ia] * B[j + _lb];
       }
       C[i + _jc] *= alpha;
     }
   }
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::aXplusY(UInt n, Real alpha, Real * x, Real * y) {
 #ifdef AKANTU_USE_BLAS
   ///  y := alpha x + y
   int incx = 1, incy = 1;
   aka_axpy(&n, &alpha, x, &incx, y, &incy);
 #else
   for (UInt i = 0; i < n; ++i)
     *(y++) += alpha * *(x++);
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Math::vectorDot(Real * v1, Real * v2, UInt in) {
 #ifdef AKANTU_USE_BLAS
   ///  d := v1 . v2
   int incx = 1, incy = 1, n = in;
   Real d = aka_dot(&n, v1, &incx, v2, &incy);
 #else
   Real d = 0;
   for (UInt i = 0; i < in; ++i) {
     d += v1[i] * v2[i];
   }
 #endif
   return d;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool tr_A, bool tr_B>
 inline void Math::matMul(UInt m, UInt n, UInt k, Real alpha, Real * A, Real * B,
                          __attribute__((unused)) Real beta, Real * C) {
   if (tr_A) {
     if (tr_B)
       matrixt_matrixt(m, n, k, A, B, C, alpha);
     else
       matrixt_matrix(m, n, k, A, B, C, alpha);
   } else {
     if (tr_B)
       matrix_matrixt(m, n, k, A, B, C, alpha);
     else
       matrix_matrix(m, n, k, A, B, C, alpha);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool tr_A>
 inline void Math::matVectMul(UInt m, UInt n, Real alpha, Real * A, Real * x,
                              __attribute__((unused)) Real beta, Real * y) {
   if (tr_A) {
     matrixt_vector(m, n, A, x, y, alpha);
   } else {
     matrix_vector(m, n, A, x, y, alpha);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> inline void Math::matrixEig(UInt n, T * A, T * d, T * V) {
 
   // Matrix  A is  row major,  so the  lapack function  in fortran  will process
   // A^t. Asking for the left eigenvectors of A^t will give the transposed right
   // eigenvectors of A so in the C++ code the right eigenvectors.
   char jobvr, jobvl;
   if (V != nullptr)
     jobvr = 'V'; // compute left  eigenvectors
   else
     jobvr = 'N'; // compute left  eigenvectors
 
   jobvl = 'N'; // compute right eigenvectors
 
   auto * di = new T[n]; // imaginary part of the eigenvalues
 
   int info;
   int N = n;
 
   T wkopt;
   int lwork = -1;
   // query and allocate the optimal workspace
   aka_geev<T>(&jobvl, &jobvr, &N, A, &N, d, di, nullptr, &N, V, &N, &wkopt,
               &lwork, &info);
 
   lwork = int(wkopt);
   auto * work = new T[lwork];
   // solve the eigenproblem
   aka_geev<T>(&jobvl, &jobvr, &N, A, &N, d, di, nullptr, &N, V, &N, work,
               &lwork, &info);
 
   AKANTU_DEBUG_ASSERT(
       info == 0,
       "Problem computing eigenvalues/vectors. DGEEV exited with the value "
           << info);
 
   delete[] work;
   delete[] di; // I hope for you that there was no complex eigenvalues !!!
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::matrix22_eigenvalues(Real * A, Real * Adiag) {
   /// d = determinant of Matrix A
   Real d = det2(A);
   /// b = trace of Matrix A
   Real b = A[0] + A[3];
 
   Real c = sqrt(b * b - 4 * d);
   Adiag[0] = .5 * (b + c);
   Adiag[1] = .5 * (b - c);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::matrix33_eigenvalues(Real * A, Real * Adiag) {
   matrixEig(3, A, Adiag);
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim> inline void Math::eigenvalues(Real * A, Real * d) {
   if (dim == 1) {
     d[0] = A[0];
   } else if (dim == 2) {
     matrix22_eigenvalues(A, d);
   }
   // else if(dim == 3) { matrix33_eigenvalues(A, d); }
   else
     matrixEig(dim, A, d);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Math::det2(const Real * mat) {
   return mat[0] * mat[3] - mat[1] * mat[2];
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Math::det3(const Real * mat) {
   return mat[0] * (mat[4] * mat[8] - mat[7] * mat[5]) -
          mat[3] * (mat[1] * mat[8] - mat[7] * mat[2]) +
          mat[6] * (mat[1] * mat[5] - mat[4] * mat[2]);
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt n> inline Real Math::det(const Real * mat) {
   if (n == 1)
     return *mat;
   else if (n == 2)
     return det2(mat);
   else if (n == 3)
     return det3(mat);
   else
     return det(n, mat);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> inline T Math::det(UInt n, const T * A) {
   int N = n;
   int info;
   auto * ipiv = new int[N + 1];
 
   auto * LU = new T[N * N];
   std::copy(A, A + N * N, LU);
 
   // LU factorization of A
   aka_getrf(&N, &N, LU, &N, ipiv, &info);
   if (info > 0) {
-    AKANTU_DEBUG_ERROR("Singular matrix - cannot factorize it (info: " << info
+    AKANTU_ERROR("Singular matrix - cannot factorize it (info: " << info
                                                                        << " )");
   }
 
   // det(A) = det(L) * det(U) = 1 * det(U) = product_i U_{ii}
   T det = 1.;
   for (int i = 0; i < N; ++i)
     det *= (2 * (ipiv[i] == i) - 1) * LU[i * n + i];
 
   delete[] ipiv;
   delete[] LU;
   return det;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::normal2(const Real * vec, Real * normal) {
   normal[0] = vec[1];
   normal[1] = -vec[0];
   Math::normalize2(normal);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::normal3(const Real * vec1, const Real * vec2, Real * normal) {
   Math::vectorProduct3(vec1, vec2, normal);
   Math::normalize3(normal);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::normalize2(Real * vec) {
   Real norm = Math::norm2(vec);
   vec[0] /= norm;
   vec[1] /= norm;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::normalize3(Real * vec) {
   Real norm = Math::norm3(vec);
   vec[0] /= norm;
   vec[1] /= norm;
   vec[2] /= norm;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Math::norm2(const Real * vec) {
   return sqrt(vec[0] * vec[0] + vec[1] * vec[1]);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Math::norm3(const Real * vec) {
   return sqrt(vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2]);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Math::norm(UInt n, const Real * vec) {
   Real norm = 0.;
   for (UInt i = 0; i < n; ++i) {
     norm += vec[i] * vec[i];
   }
   return sqrt(norm);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::inv2(const Real * mat, Real * inv) {
   Real det_mat = det2(mat);
 
   inv[0] = mat[3] / det_mat;
   inv[1] = -mat[1] / det_mat;
   inv[2] = -mat[2] / det_mat;
   inv[3] = mat[0] / det_mat;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::inv3(const Real * mat, Real * inv) {
   Real det_mat = det3(mat);
 
   inv[0] = (mat[4] * mat[8] - mat[7] * mat[5]) / det_mat;
   inv[1] = (mat[2] * mat[7] - mat[8] * mat[1]) / det_mat;
   inv[2] = (mat[1] * mat[5] - mat[4] * mat[2]) / det_mat;
   inv[3] = (mat[5] * mat[6] - mat[8] * mat[3]) / det_mat;
   inv[4] = (mat[0] * mat[8] - mat[6] * mat[2]) / det_mat;
   inv[5] = (mat[2] * mat[3] - mat[5] * mat[0]) / det_mat;
   inv[6] = (mat[3] * mat[7] - mat[6] * mat[4]) / det_mat;
   inv[7] = (mat[1] * mat[6] - mat[7] * mat[0]) / det_mat;
   inv[8] = (mat[0] * mat[4] - mat[3] * mat[1]) / det_mat;
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt n> inline void Math::inv(const Real * A, Real * Ainv) {
   if (n == 1)
     *Ainv = 1. / *A;
   else if (n == 2)
     inv2(A, Ainv);
   else if (n == 3)
     inv3(A, Ainv);
   else
     inv(n, A, Ainv);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> inline void Math::inv(UInt n, const T * A, T * invA) {
   int N = n;
   int info;
   auto * ipiv = new int[N + 1];
   int lwork = N * N;
   auto * work = new T[lwork];
 
   std::copy(A, A + n * n, invA);
 
   aka_getrf(&N, &N, invA, &N, ipiv, &info);
   if (info > 0) {
-    AKANTU_DEBUG_ERROR("Singular matrix - cannot factorize it (info: " << info
+    AKANTU_ERROR("Singular matrix - cannot factorize it (info: " << info
                                                                        << " )");
   }
 
   aka_getri(&N, invA, &N, ipiv, work, &lwork, &info);
   if (info != 0) {
-    AKANTU_DEBUG_ERROR("Cannot invert the matrix (info: " << info << " )");
+    AKANTU_ERROR("Cannot invert the matrix (info: " << info << " )");
   }
 
   delete[] ipiv;
   delete[] work;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Math::solve(UInt n, const T * A, T * x, const T * b) {
   int N = n;
   int info;
   auto * ipiv = new int[N];
   auto * lu_A = new T[N * N];
 
   std::copy(A, A + N * N, lu_A);
 
   aka_getrf(&N, &N, lu_A, &N, ipiv, &info);
   if (info > 0) {
-    AKANTU_DEBUG_ERROR("Singular matrix - cannot factorize it (info: " << info
+    AKANTU_ERROR("Singular matrix - cannot factorize it (info: " << info
                                                                        << " )");
   }
 
   char trans = 'N';
   int nrhs = 1;
 
   std::copy(b, b + N, x);
 
   aka_getrs(&trans, &N, &nrhs, lu_A, &N, ipiv, x, &N, &info);
   if (info != 0) {
-    AKANTU_DEBUG_ERROR("Cannot solve the system (info: " << info << " )");
+    AKANTU_ERROR("Cannot solve the system (info: " << info << " )");
   }
 
   delete[] ipiv;
   delete[] lu_A;
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 inline Real Math::matrixDoubleDot22(Real * A, Real * B) {
   Real d;
   d = A[0] * B[0] + A[1] * B[1] + A[2] * B[2] + A[3] * B[3];
   return d;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Math::matrixDoubleDot33(Real * A, Real * B) {
   Real d;
   d = A[0] * B[0] + A[1] * B[1] + A[2] * B[2] + A[3] * B[3] + A[4] * B[4] +
       A[5] * B[5] + A[6] * B[6] + A[7] * B[7] + A[8] * B[8];
   return d;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Math::matrixDoubleDot(UInt n, Real * A, Real * B) {
   Real d = 0.;
   for (UInt i = 0; i < n; ++i) {
     for (UInt j = 0; j < n; ++j) {
       d += A[i * n + j] * B[i * n + j];
     }
   }
   return d;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::vectorProduct3(const Real * v1, const Real * v2, Real * res) {
   res[0] = v1[1] * v2[2] - v1[2] * v2[1];
   res[1] = v1[2] * v2[0] - v1[0] * v2[2];
   res[2] = v1[0] * v2[1] - v1[1] * v2[0];
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Math::vectorDot2(const Real * v1, const Real * v2) {
   return (v1[0] * v2[0] + v1[1] * v2[1]);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Math::vectorDot3(const Real * v1, const Real * v2) {
   return (v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2]);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Math::distance_2d(const Real * x, const Real * y) {
   return sqrt((y[0] - x[0]) * (y[0] - x[0]) + (y[1] - x[1]) * (y[1] - x[1]));
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Math::triangle_inradius(const Real * coord1, const Real * coord2,
                                     const Real * coord3) {
   /**
    * @f{eqnarray*}{
    * r &=& A / s \\
    * A &=& 1/4 * \sqrt{(a + b + c) * (a - b + c) * (a + b - c) (-a + b + c)} \\
    * s &=& \frac{a + b + c}{2}
    * @f}
    */
 
   Real a, b, c;
   a = distance_2d(coord1, coord2);
   b = distance_2d(coord2, coord3);
   c = distance_2d(coord1, coord3);
 
   Real s;
   s = (a + b + c) * 0.5;
 
   return sqrt((s - a) * (s - b) * (s - c) / s);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Math::distance_3d(const Real * x, const Real * y) {
   return sqrt((y[0] - x[0]) * (y[0] - x[0]) + (y[1] - x[1]) * (y[1] - x[1]) +
               (y[2] - x[2]) * (y[2] - x[2]));
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Math::tetrahedron_volume(const Real * coord1, const Real * coord2,
                                      const Real * coord3, const Real * coord4) {
   Real xx[9], vol;
 
   xx[0] = coord2[0];
   xx[1] = coord2[1];
   xx[2] = coord2[2];
   xx[3] = coord3[0];
   xx[4] = coord3[1];
   xx[5] = coord3[2];
   xx[6] = coord4[0];
   xx[7] = coord4[1];
   xx[8] = coord4[2];
   vol = det3(xx);
 
   xx[0] = coord1[0];
   xx[1] = coord1[1];
   xx[2] = coord1[2];
   xx[3] = coord3[0];
   xx[4] = coord3[1];
   xx[5] = coord3[2];
   xx[6] = coord4[0];
   xx[7] = coord4[1];
   xx[8] = coord4[2];
   vol -= det3(xx);
 
   xx[0] = coord1[0];
   xx[1] = coord1[1];
   xx[2] = coord1[2];
   xx[3] = coord2[0];
   xx[4] = coord2[1];
   xx[5] = coord2[2];
   xx[6] = coord4[0];
   xx[7] = coord4[1];
   xx[8] = coord4[2];
   vol += det3(xx);
 
   xx[0] = coord1[0];
   xx[1] = coord1[1];
   xx[2] = coord1[2];
   xx[3] = coord2[0];
   xx[4] = coord2[1];
   xx[5] = coord2[2];
   xx[6] = coord3[0];
   xx[7] = coord3[1];
   xx[8] = coord3[2];
   vol -= det3(xx);
 
   vol /= 6;
 
   return vol;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Math::tetrahedron_inradius(const Real * coord1, const Real * coord2,
                                        const Real * coord3,
                                        const Real * coord4) {
 
   Real l12, l13, l14, l23, l24, l34;
   l12 = distance_3d(coord1, coord2);
   l13 = distance_3d(coord1, coord3);
   l14 = distance_3d(coord1, coord4);
   l23 = distance_3d(coord2, coord3);
   l24 = distance_3d(coord2, coord4);
   l34 = distance_3d(coord3, coord4);
 
   Real s1, s2, s3, s4;
 
   s1 = (l12 + l23 + l13) * 0.5;
   s1 = sqrt(s1 * (s1 - l12) * (s1 - l23) * (s1 - l13));
 
   s2 = (l12 + l24 + l14) * 0.5;
   s2 = sqrt(s2 * (s2 - l12) * (s2 - l24) * (s2 - l14));
 
   s3 = (l23 + l34 + l24) * 0.5;
   s3 = sqrt(s3 * (s3 - l23) * (s3 - l34) * (s3 - l24));
 
   s4 = (l13 + l34 + l14) * 0.5;
   s4 = sqrt(s4 * (s4 - l13) * (s4 - l34) * (s4 - l14));
 
   Real volume = Math::tetrahedron_volume(coord1, coord2, coord3, coord4);
 
   return 3 * volume / (s1 + s2 + s3 + s4);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::barycenter(const Real * coord, UInt nb_points,
                              UInt spatial_dimension, Real * barycenter) {
   memset(barycenter, 0, spatial_dimension * sizeof(Real));
   for (UInt n = 0; n < nb_points; ++n) {
     UInt offset = n * spatial_dimension;
     for (UInt i = 0; i < spatial_dimension; ++i) {
       barycenter[i] += coord[offset + i] / (Real)nb_points;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::vector_2d(const Real * x, const Real * y, Real * res) {
   res[0] = y[0] - x[0];
   res[1] = y[1] - x[1];
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Math::vector_3d(const Real * x, const Real * y, Real * res) {
   res[0] = y[0] - x[0];
   res[1] = y[1] - x[1];
   res[2] = y[2] - x[2];
 }
 
 /* -------------------------------------------------------------------------- */
 /// Combined absolute and relative tolerance test proposed in
 /// Real-time collision detection by C. Ericson (2004)
 inline bool Math::are_float_equal(const Real x, const Real y) {
   Real abs_max = std::max(std::abs(x), std::abs(y));
   abs_max = std::max(abs_max, Real(1.));
   return std::abs(x - y) <= (tolerance * abs_max);
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Math::isnan(Real x) {
 #if defined(__INTEL_COMPILER)
 #pragma warning(push)
 #pragma warning(disable : 1572)
 #endif // defined(__INTEL_COMPILER)
 
   // x = x return false means x = quiet_NaN
   return !(x == x);
 
 #if defined(__INTEL_COMPILER)
 #pragma warning(pop)
 #endif // defined(__INTEL_COMPILER)
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Math::are_vector_equal(UInt n, Real * x, Real * y) {
   bool test = true;
   for (UInt i = 0; i < n; ++i) {
     test &= are_float_equal(x[i], y[i]);
   }
 
   return test;
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Math::intersects(Real x_min, Real x_max, Real y_min, Real y_max) {
   return !((x_max <= y_min) || (x_min >= y_max));
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Math::is_in_range(Real a, Real x_min, Real x_max) {
   return ((a >= x_min) && (a <= x_max));
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt p, typename T> inline T Math::pow(T x) {
   return (pow<p - 1, T>(x) * x);
 }
 template <> inline UInt Math::pow<0, UInt>(__attribute__((unused)) UInt x) {
   return (1);
 }
 template <> inline Real Math::pow<0, Real>(__attribute__((unused)) Real x) {
   return (1.);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <class Functor>
 Real Math::NewtonRaphson::solve(const Functor & funct, Real x_0) {
   Real x = x_0;
   Real f_x = funct.f(x);
   UInt iter = 0;
   while (std::abs(f_x) > this->tolerance && iter < this->max_iteration) {
     x -= f_x / funct.f_prime(x);
     f_x = funct.f(x);
     iter++;
   }
 
   AKANTU_DEBUG_ASSERT(iter < this->max_iteration,
                       "Newton Raphson ("
                           << funct.name << ") solve did not converge in "
                           << this->max_iteration << " iterations (tolerance: "
                           << this->tolerance << ")");
 
   return x;
 }
diff --git a/src/common/aka_static_memory_tmpl.hh b/src/common/aka_static_memory_tmpl.hh
index 0f09c9c0f..0bf3003d1 100644
--- a/src/common/aka_static_memory_tmpl.hh
+++ b/src/common/aka_static_memory_tmpl.hh
@@ -1,87 +1,87 @@
 /**
  * @file   aka_static_memory_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Jul 15 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  template part of the StaticMemory
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 template<typename T>
 Array<T> & StaticMemory::smalloc(const MemoryID & memory_id,
                                   const ID & name,
                                   UInt size,
                                   UInt nb_component) {
   AKANTU_DEBUG_IN();
 
   MemoryMap::iterator memory_it;
   memory_it = memories.find(memory_id);
 
   if(memory_it == memories.end()){
     memories[memory_id] = ArrayMap();
     memory_it = memories.find(memory_id);
   }
 
   if((memory_it->second).find(name) != (memory_it->second).end()) {
-    AKANTU_DEBUG_ERROR("The vector \"" << name << "\" is already registred in the memory " << memory_id);
+    AKANTU_ERROR("The vector \"" << name << "\" is already registred in the memory " << memory_id);
   }
 
   auto * tmp_vect = new Array<T>(size, nb_component, name);
   (memory_it->second)[name] = tmp_vect;
 
   AKANTU_DEBUG_OUT();
   return *tmp_vect;
 }
 
 /* -------------------------------------------------------------------------- */
 template<typename T>
 Array<T> & StaticMemory::smalloc(const MemoryID & memory_id,
                                   const ID & name,
                                   UInt size,
                                   UInt nb_component,
                                   const T & init_value) {
   AKANTU_DEBUG_IN();
 
   MemoryMap::iterator memory_it;
   memory_it = memories.find(memory_id);
 
   if(memory_it == memories.end()){
     memories[memory_id] = ArrayMap();
     memory_it = memories.find(memory_id);
   }
 
   if((memory_it->second).find(name) != (memory_it->second).end()) {
-    AKANTU_DEBUG_ERROR("The vector \"" << name << "\" is already registred in the memory " << memory_id);
+    AKANTU_ERROR("The vector \"" << name << "\" is already registred in the memory " << memory_id);
   }
 
   auto * tmp_vect = new Array<T>(size, nb_component, init_value, name);
   (memory_it->second)[name] = tmp_vect;
 
   AKANTU_DEBUG_OUT();
   return *tmp_vect;
 }
 
 /* -------------------------------------------------------------------------- */
diff --git a/src/common/aka_types.hh b/src/common/aka_types.hh
index 203d4d318..7de980376 100644
--- a/src/common/aka_types.hh
+++ b/src/common/aka_types.hh
@@ -1,1302 +1,1302 @@
 /**
  * @file   aka_types.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Feb 17 2011
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  description of the "simple" types
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "aka_error.hh"
 #include "aka_fwd.hh"
 #include "aka_math.hh"
 /* -------------------------------------------------------------------------- */
 #include <initializer_list>
 #include <iomanip>
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_TYPES_HH__
 #define __AKANTU_AKA_TYPES_HH__
 
 namespace akantu {
 
 enum NormType { L_1 = 1, L_2 = 2, L_inf = UInt(-1) };
 
 /**
  * DimHelper is a class to generalize the setup of a dim array from 3
  * values. This gives a common interface in the TensorStorage class
  * independently of its derived inheritance (Vector, Matrix, Tensor3)
  * @tparam dim
  */
 template <UInt dim> struct DimHelper {
   static inline void setDims(UInt m, UInt n, UInt p, UInt dims[dim]);
 };
 
 /* -------------------------------------------------------------------------- */
 template <> struct DimHelper<1> {
   static inline void setDims(UInt m, __attribute__((unused)) UInt n,
                              __attribute__((unused)) UInt p, UInt dims[1]) {
     dims[0] = m;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <> struct DimHelper<2> {
   static inline void setDims(UInt m, UInt n, __attribute__((unused)) UInt p,
                              UInt dims[2]) {
     dims[0] = m;
     dims[1] = n;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <> struct DimHelper<3> {
   static inline void setDims(UInt m, UInt n, UInt p, UInt dims[3]) {
     dims[0] = m;
     dims[1] = n;
     dims[2] = p;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename T, UInt ndim, class RetType> class TensorStorage;
 
 /* -------------------------------------------------------------------------- */
 /* Proxy classes                                                              */
 /* -------------------------------------------------------------------------- */
 namespace tensors {
   template <class A, class B> struct is_copyable {
     enum : bool { value = false };
   };
 
   template <class A> struct is_copyable<A, A> {
     enum : bool { value = true };
   };
 
   template <class A> struct is_copyable<A, typename A::RetType> {
     enum : bool { value = true };
   };
 
   template <class A> struct is_copyable<A, typename A::RetType::proxy> {
     enum : bool { value = true };
   };
 
 } // namespace tensors
 
 /**
  * @class TensorProxy aka_types.hh
  * @desc The TensorProxy class is a proxy class to the TensorStorage it handles
  * the
  * wrapped case. That is to say if an accessor should give access to a Tensor
  * wrapped on some data, like the Array<T>::iterator they can return a
  * TensorProxy that will be automatically transformed as a TensorStorage wrapped
  * on the same data
  * @tparam T stored type
  * @tparam ndim order of the tensor
  * @tparam RetType real derived type
  */
 template <typename T, UInt ndim, class _RetType> class TensorProxy {
 protected:
   using RetTypeProxy = typename _RetType::proxy;
 
   constexpr TensorProxy(T * data, UInt m, UInt n, UInt p) {
     DimHelper<ndim>::setDims(m, n, p, this->n);
     this->values = data;
   }
 
 #ifndef SWIG
   template <class Other,
             typename = std::enable_if_t<
                 tensors::is_copyable<TensorProxy, Other>::value>>
   explicit TensorProxy(const Other & other) {
     this->values = other.storage();
     for (UInt i = 0; i < ndim; ++i)
       this->n[i] = other.size(i);
   }
 #endif
 public:
   using RetType = _RetType;
 
   UInt size(UInt i) const {
     AKANTU_DEBUG_ASSERT(i < ndim,
                         "This tensor has only " << ndim << " dimensions, not "
                                                 << (i + 1));
     return n[i];
   }
 
   inline UInt size() const {
     UInt _size = 1;
     for (UInt d = 0; d < ndim; ++d)
       _size *= this->n[d];
     return _size;
   }
 
   T * storage() const { return values; }
 
 #ifndef SWIG
   template <class Other,
             typename = std::enable_if_t<
                 tensors::is_copyable<TensorProxy, Other>::value>>
   inline TensorProxy & operator=(const Other & other) {
     AKANTU_DEBUG_ASSERT(
         other.size() == this->size(),
         "You are trying to copy two tensors with different sizes");
     memcpy(this->values, other.storage(), this->size() * sizeof(T));
     return *this;
   }
 #endif
   // template <class Other, typename = std::enable_if_t<
   //                          tensors::is_copyable<TensorProxy, Other>::value>>
   // inline TensorProxy & operator=(const Other && other) {
   //   AKANTU_DEBUG_ASSERT(
   //       other.size() == this->size(),
   //       "You are trying to copy two tensors with different sizes");
   //   memcpy(this->values, other.storage(), this->size() * sizeof(T));
   //   return *this;
   // }
 
   template <typename O> inline RetTypeProxy & operator*=(const O & o) {
     RetType(*this) *= o;
     return static_cast<RetTypeProxy &>(*this);
   }
 
   template <typename O> inline RetTypeProxy & operator/=(const O & o) {
     RetType(*this) /= o;
     return static_cast<RetTypeProxy &>(*this);
   }
 
 protected:
   T * values;
   UInt n[ndim];
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename T> class VectorProxy : public TensorProxy<T, 1, Vector<T>> {
   using parent = TensorProxy<T, 1, Vector<T>>;
   using type = Vector<T>;
 
 public:
   constexpr VectorProxy(T * data, UInt n) : parent(data, n, 0, 0) {}
   template <class Other> explicit VectorProxy(Other & src) : parent(src) {}
 
   /* ---------------------------------------------------------------------- */
   template <class Other>
   inline VectorProxy<T> & operator=(const Other & other) {
     parent::operator=(other);
     return *this;
   }
 
   // inline VectorProxy<T> & operator=(const VectorProxy && other) {
   //   parent::operator=(other);
   //   return *this;
   // }
 
   /* ------------------------------------------------------------------------ */
   T & operator()(UInt index) { return this->values[index]; };
   const T & operator()(UInt index) const { return this->values[index]; };
 };
 
 template <typename T> class MatrixProxy : public TensorProxy<T, 2, Matrix<T>> {
   using parent = TensorProxy<T, 2, Matrix<T>>;
   using type = Matrix<T>;
 
 public:
   MatrixProxy(T * data, UInt m, UInt n) : parent(data, m, n, 0) {}
   template <class Other> explicit MatrixProxy(Other & src) : parent(src) {}
 
   /* ---------------------------------------------------------------------- */
   template <class Other>
   inline MatrixProxy<T> & operator=(const Other & other) {
     parent::operator=(other);
     return *this;
   }
 };
 
 template <typename T>
 class Tensor3Proxy : public TensorProxy<T, 3, Tensor3<T>> {
   using parent = TensorProxy<T, 3, Tensor3<T>>;
   using type = Tensor3<T>;
 
 public:
   Tensor3Proxy(const T * data, UInt m, UInt n, UInt k)
       : parent(data, m, n, k) {}
   Tensor3Proxy(const Tensor3Proxy & src) : parent(src) {}
   Tensor3Proxy(const Tensor3<T> & src) : parent(src) {}
 
   /* ---------------------------------------------------------------------- */
   template <class Other>
   inline Tensor3Proxy<T> & operator=(const Other & other) {
     parent::operator=(other);
     return *this;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 /* Tensor base class                                                          */
 /* -------------------------------------------------------------------------- */
 template <typename T, UInt ndim, class RetType>
 class TensorStorage : public TensorTrait {
 public:
   using value_type = T;
 
   friend class Array<T>;
 
 protected:
   template <class TensorType> void copySize(const TensorType & src) {
     for (UInt d = 0; d < ndim; ++d)
       this->n[d] = src.size(d);
     this->_size = src.size();
   }
 
   TensorStorage() : values(nullptr) {
     for (UInt d = 0; d < ndim; ++d)
       this->n[d] = 0;
     _size = 0;
   }
 
   TensorStorage(const TensorProxy<T, ndim, RetType> & proxy) {
     this->copySize(proxy);
     this->values = proxy.storage();
     this->wrapped = true;
   }
 
 public:
   TensorStorage(const TensorStorage & src) = delete;
 
   TensorStorage(const TensorStorage & src, bool deep_copy) : values(nullptr) {
     if (deep_copy)
       this->deepCopy(src);
     else
       this->shallowCopy(src);
   }
 
 protected:
   TensorStorage(UInt m, UInt n, UInt p, const T & def) {
     static_assert(std::is_trivially_constructible<T>{},
                   "Cannot create a tensor on non trivial types");
     DimHelper<ndim>::setDims(m, n, p, this->n);
 
     this->computeSize();
     this->values = new T[this->_size];
     this->set(def);
     this->wrapped = false;
   }
 
   TensorStorage(T * data, UInt m, UInt n, UInt p) {
     DimHelper<ndim>::setDims(m, n, p, this->n);
 
     this->computeSize();
     this->values = data;
     this->wrapped = true;
   }
 
 public:
   /* ------------------------------------------------------------------------ */
   template <class TensorType> inline void shallowCopy(const TensorType & src) {
     this->copySize(src);
     if (!this->wrapped)
       delete[] this->values;
     this->values = src.storage();
     this->wrapped = true;
   }
 
   /* ------------------------------------------------------------------------ */
   template <class TensorType> inline void deepCopy(const TensorType & src) {
     this->copySize(src);
 
     if (!this->wrapped)
       delete[] this->values;
 
     static_assert(std::is_trivially_constructible<T>{},
                   "Cannot create a tensor on non trivial types");
     this->values = new T[this->_size];
 
     static_assert(std::is_trivially_copyable<T>{},
                   "Cannot copy a tensor on non trivial types");
     memcpy((void *)this->values, (void *)src.storage(),
            this->_size * sizeof(T));
 
     this->wrapped = false;
   }
 
   virtual ~TensorStorage() {
     if (!this->wrapped)
       delete[] this->values;
   }
 
   /* ------------------------------------------------------------------------ */
   inline TensorStorage & operator=(const TensorStorage & src) {
     return this->operator=(dynamic_cast<RetType &>(src));
   }
 
   /* ------------------------------------------------------------------------ */
   inline TensorStorage & operator=(const RetType & src) {
     if (this != &src) {
       if (this->wrapped) {
         static_assert(std::is_trivially_copyable<T>{},
                       "Cannot copy a tensor on non trivial types");
         // this test is not sufficient for Tensor of order higher than 1
         AKANTU_DEBUG_ASSERT(this->_size == src.size(),
                             "Tensors of different size");
         memcpy((void *)this->values, (void *)src.storage(),
                this->_size * sizeof(T));
       } else {
         deepCopy(src);
       }
     }
     return *this;
   }
 
   /* ------------------------------------------------------------------------ */
   template <class R>
   inline RetType & operator+=(const TensorStorage<T, ndim, R> & other) {
     T * a = this->storage();
     T * b = other.storage();
     AKANTU_DEBUG_ASSERT(
         _size == other.size(),
         "The two tensors do not have the same size, they cannot be subtracted");
     for (UInt i = 0; i < _size; ++i)
       *(a++) += *(b++);
     return *(static_cast<RetType *>(this));
   }
 
   /* ------------------------------------------------------------------------ */
   template <class R>
   inline RetType & operator-=(const TensorStorage<T, ndim, R> & other) {
     T * a = this->storage();
     T * b = other.storage();
     AKANTU_DEBUG_ASSERT(
         _size == other.size(),
         "The two tensors do not have the same size, they cannot be subtracted");
     for (UInt i = 0; i < _size; ++i)
       *(a++) -= *(b++);
     return *(static_cast<RetType *>(this));
   }
 
   /* ------------------------------------------------------------------------ */
   inline RetType & operator+=(const T & x) {
     T * a = this->values;
     for (UInt i = 0; i < _size; ++i)
       *(a++) += x;
     return *(static_cast<RetType *>(this));
   }
 
   /* ------------------------------------------------------------------------ */
   inline RetType & operator-=(const T & x) {
     T * a = this->values;
     for (UInt i = 0; i < _size; ++i)
       *(a++) -= x;
     return *(static_cast<RetType *>(this));
   }
 
   /* ------------------------------------------------------------------------ */
   inline RetType & operator*=(const T & x) {
     T * a = this->storage();
     for (UInt i = 0; i < _size; ++i)
       *(a++) *= x;
     return *(static_cast<RetType *>(this));
   }
 
   /* ---------------------------------------------------------------------- */
   inline RetType & operator/=(const T & x) {
     T * a = this->values;
     for (UInt i = 0; i < _size; ++i)
       *(a++) /= x;
     return *(static_cast<RetType *>(this));
   }
 
   /// Y = \alpha X + Y
   inline RetType & aXplusY(const TensorStorage & other, const T & alpha = 1.) {
     AKANTU_DEBUG_ASSERT(
         _size == other.size(),
         "The two tensors do not have the same size, they cannot be subtracted");
 
     Math::aXplusY(this->_size, alpha, other.storage(), this->storage());
     return *(static_cast<RetType *>(this));
   }
 
   /* ------------------------------------------------------------------------ */
   T * storage() const { return values; }
   UInt size() const { return _size; }
   UInt size(UInt i) const {
     AKANTU_DEBUG_ASSERT(i < ndim,
                         "This tensor has only " << ndim << " dimensions, not "
                                                 << (i + 1));
     return n[i];
   };
   /* ------------------------------------------------------------------------ */
   inline void clear() { memset(values, 0, _size * sizeof(T)); };
   inline void set(const T & t) { std::fill_n(values, _size, t); };
 
   template <class TensorType> inline void copy(const TensorType & other) {
     AKANTU_DEBUG_ASSERT(
         _size == other.size(),
         "The two tensors do not have the same size, they cannot be copied");
     memcpy(values, other.storage(), _size * sizeof(T));
   }
 
   bool isWrapped() const { return this->wrapped; }
 
 protected:
   inline void computeSize() {
     _size = 1;
     for (UInt d = 0; d < ndim; ++d)
       _size *= this->n[d];
   }
 
 protected:
   template <typename R, NormType norm_type> struct NormHelper {
     template <class Ten> static R norm(const Ten & ten) {
       R _norm = 0.;
       R * it = ten.storage();
       R * end = ten.storage() + ten.size();
       for (; it < end; ++it)
         _norm += std::pow(std::abs(*it), norm_type);
       return std::pow(_norm, 1. / norm_type);
     }
   };
 
   template <typename R> struct NormHelper<R, L_1> {
     template <class Ten> static R norm(const Ten & ten) {
       R _norm = 0.;
       R * it = ten.storage();
       R * end = ten.storage() + ten.size();
       for (; it < end; ++it)
         _norm += std::abs(*it);
       return _norm;
     }
   };
 
   template <typename R> struct NormHelper<R, L_2> {
     template <class Ten> static R norm(const Ten & ten) {
       R _norm = 0.;
       R * it = ten.storage();
       R * end = ten.storage() + ten.size();
       for (; it < end; ++it)
         _norm += *it * *it;
       return sqrt(_norm);
     }
   };
 
   template <typename R> struct NormHelper<R, L_inf> {
     template <class Ten> static R norm(const Ten & ten) {
       R _norm = 0.;
       R * it = ten.storage();
       R * end = ten.storage() + ten.size();
       for (; it < end; ++it)
         _norm = std::max(std::abs(*it), _norm);
       return _norm;
     }
   };
 
 public:
   /*----------------------------------------------------------------------- */
   /// "Entrywise" norm norm<L_p> @f[ \|\boldsymbol{T}\|_p = \left(
   /// \sum_i^{n[0]}\sum_j^{n[1]}\sum_k^{n[2]} |T_{ijk}|^p \right)^{\frac{1}{p}}
   /// @f]
   template <NormType norm_type> inline T norm() const {
     return NormHelper<T, norm_type>::norm(*this);
   }
 
 protected:
   UInt n[ndim];
   UInt _size;
   T * values;
   bool wrapped{false};
 };
 
 /* -------------------------------------------------------------------------- */
 /* Vector                                                                     */
 /* -------------------------------------------------------------------------- */
 template <typename T> class Vector : public TensorStorage<T, 1, Vector<T>> {
   using parent = TensorStorage<T, 1, Vector<T>>;
 
 public:
   using value_type = typename parent::value_type;
   using proxy = VectorProxy<T>;
 
 public:
   Vector() : parent() {}
   explicit Vector(UInt n, const T & def = T()) : parent(n, 0, 0, def) {}
   Vector(T * data, UInt n) : parent(data, n, 0, 0) {}
   Vector(const Vector & src, bool deep_copy = true) : parent(src, deep_copy) {}
   Vector(const TensorProxy<T, 1, Vector> & src) : parent(src) {}
 
   Vector(std::initializer_list<T> list) : parent(list.size(), 0, 0, T()) {
     UInt i = 0;
     for (auto val : list) {
       operator()(i++) = val;
     }
   }
 
 public:
   ~Vector() override = default;
 
   /* ------------------------------------------------------------------------ */
   inline Vector & operator=(const Vector & src) {
     parent::operator=(src);
     return *this;
   }
 
   /* ------------------------------------------------------------------------ */
   inline T & operator()(UInt i) {
     AKANTU_DEBUG_ASSERT((i < this->n[0]),
                         "Access out of the vector! "
                             << "Index (" << i
                             << ") is out of the vector of size (" << this->n[0]
                             << ")");
     return *(this->values + i);
   }
 
   inline const T & operator()(UInt i) const {
     AKANTU_DEBUG_ASSERT((i < this->n[0]),
                         "Access out of the vector! "
                             << "Index (" << i
                             << ") is out of the vector of size (" << this->n[0]
                             << ")");
     return *(this->values + i);
   }
 
   inline T & operator[](UInt i) { return this->operator()(i); }
   inline const T & operator[](UInt i) const { return this->operator()(i); }
 
   /* ------------------------------------------------------------------------ */
   inline Vector<T> & operator*=(Real x) { return parent::operator*=(x); }
   inline Vector<T> & operator/=(Real x) { return parent::operator/=(x); }
   /* ------------------------------------------------------------------------ */
   inline Vector<T> & operator*=(const Vector<T> & vect) {
     T * a = this->storage();
     T * b = vect.storage();
     for (UInt i = 0; i < this->_size; ++i)
       *(a++) *= *(b++);
     return *this;
   }
 
   /* ------------------------------------------------------------------------ */
   inline Real dot(const Vector<T> & vect) const {
     return Math::vectorDot(this->values, vect.storage(), this->_size);
   }
 
   /* ------------------------------------------------------------------------ */
   inline Real mean() const {
     Real mean = 0;
     T * a = this->storage();
     for (UInt i = 0; i < this->_size; ++i)
       mean += *(a++);
     return mean / this->_size;
   }
 
   /* ------------------------------------------------------------------------ */
   inline Vector & crossProduct(const Vector<T> & v1, const Vector<T> & v2) {
     AKANTU_DEBUG_ASSERT(this->size() == 3,
                         "crossProduct is only defined in 3D (n=" << this->size()
                                                                  << ")");
     AKANTU_DEBUG_ASSERT(
         this->size() == v1.size() && this->size() == v2.size(),
         "crossProduct is not a valid operation non matching size vectors");
     Math::vectorProduct3(v1.storage(), v2.storage(), this->values);
     return *this;
   }
 
   inline Vector crossProduct(const Vector<T> & v) {
     Vector<T> tmp(this->size());
     tmp.crossProduct(*this, v);
     return tmp;
   }
 
   /* ------------------------------------------------------------------------ */
   inline void solve(const Matrix<T> & A, const Vector<T> & b) {
     AKANTU_DEBUG_ASSERT(
         this->size() == A.rows() && this->_size == A.cols(),
         "The size of the solution vector mismatches the size of the matrix");
     AKANTU_DEBUG_ASSERT(
         this->_size == b._size,
         "The rhs vector has a mismatch in size with the matrix");
     Math::solve(this->_size, A.storage(), this->values, b.storage());
   }
 
   /* ------------------------------------------------------------------------ */
   template <bool tr_A>
   inline void mul(const Matrix<T> & A, const Vector<T> & x, Real alpha = 1.0);
   /* ------------------------------------------------------------------------ */
   inline Real norm() const { return parent::template norm<L_2>(); }
 
   template <NormType nt> inline Real norm() const {
     return parent::template norm<nt>();
   }
 
   /* ------------------------------------------------------------------------ */
   inline Vector<Real> & normalize() {
     Real n = norm();
     operator/=(n);
     return *this;
   }
 
   /* ------------------------------------------------------------------------ */
   /// norm of (*this - x)
   inline Real distance(const Vector<T> & y) const {
     Real * vx = this->values;
     Real * vy = y.storage();
     Real sum_2 = 0;
     for (UInt i = 0; i < this->_size; ++i, ++vx, ++vy)
       sum_2 += (*vx - *vy) * (*vx - *vy);
     return sqrt(sum_2);
   }
 
   /* ------------------------------------------------------------------------ */
   inline bool equal(const Vector<T> & v,
                     Real tolerance = Math::getTolerance()) const {
     T * a = this->storage();
     T * b = v.storage();
     UInt i = 0;
     while (i < this->_size && (std::abs(*(a++) - *(b++)) < tolerance))
       ++i;
     return i == this->_size;
   }
 
   /* ------------------------------------------------------------------------ */
   inline short compare(const Vector<T> & v,
                        Real tolerance = Math::getTolerance()) const {
     T * a = this->storage();
     T * b = v.storage();
     for (UInt i(0); i < this->_size; ++i, ++a, ++b) {
       if (std::abs(*a - *b) > tolerance)
         return (((*a - *b) > tolerance) ? 1 : -1);
     }
     return 0;
   }
 
   /* ------------------------------------------------------------------------ */
   inline bool operator==(const Vector<T> & v) const { return equal(v); }
   inline bool operator!=(const Vector<T> & v) const { return !operator==(v); }
   inline bool operator<(const Vector<T> & v) const { return compare(v) == -1; }
   inline bool operator>(const Vector<T> & v) const { return compare(v) == 1; }
 
   /* ------------------------------------------------------------------------ */
   /// function to print the containt of the class
   virtual void printself(std::ostream & stream, int indent = 0) const {
     std::string space;
     for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
       ;
 
     stream << "[";
     for (UInt i = 0; i < this->_size; ++i) {
       if (i != 0)
         stream << ", ";
       stream << this->values[i];
     }
     stream << "]";
   }
 
   //  friend class ::akantu::Array<T>;
 };
 
 using RVector = Vector<Real>;
 
 /* ------------------------------------------------------------------------ */
 template <>
 inline bool Vector<UInt>::equal(const Vector<UInt> & v,
                                 __attribute__((unused)) Real tolerance) const {
   UInt * a = this->storage();
   UInt * b = v.storage();
   UInt i = 0;
   while (i < this->_size && (*(a++) == *(b++)))
     ++i;
   return i == this->_size;
 }
 
 /* ------------------------------------------------------------------------ */
 /* Matrix                                                                   */
 /* ------------------------------------------------------------------------ */
 template <typename T> class Matrix : public TensorStorage<T, 2, Matrix<T>> {
   using parent = TensorStorage<T, 2, Matrix<T>>;
 
 public:
   using value_type = typename parent::value_type;
   using proxy = MatrixProxy<T>;
 
 public:
   Matrix() : parent() {}
   Matrix(UInt m, UInt n, const T & def = T()) : parent(m, n, 0, def) {}
   Matrix(T * data, UInt m, UInt n) : parent(data, m, n, 0) {}
   Matrix(const Matrix & src, bool deep_copy = true) : parent(src, deep_copy) {}
   Matrix(const MatrixProxy<T> & src) : parent(src) {}
   Matrix(std::initializer_list<std::initializer_list<T>> list) {
     static_assert(std::is_trivially_copyable<T>{},
                   "Cannot create a tensor on non trivial types");
     std::size_t n = 0;
     std::size_t m = list.size();
     for (auto row : list) {
       n = std::max(n, row.size());
     }
 
     DimHelper<2>::setDims(m, n, 0, this->n);
     this->computeSize();
     this->values = new T[this->_size];
     this->set(0);
 
     UInt i = 0, j = 0;
     for (auto & row : list) {
       for (auto & val : row) {
         at(i, j++) = val;
       }
       ++i;
       j = 0;
     }
   }
 
   ~Matrix() override = default;
   /* ------------------------------------------------------------------------ */
   inline Matrix & operator=(const Matrix & src) {
     parent::operator=(src);
     return *this;
   }
 
 public:
   /* ---------------------------------------------------------------------- */
   UInt rows() const { return this->n[0]; }
   UInt cols() const { return this->n[1]; }
 
   /* ---------------------------------------------------------------------- */
   inline T & at(UInt i, UInt j) {
     AKANTU_DEBUG_ASSERT(((i < this->n[0]) && (j < this->n[1])),
                         "Access out of the matrix! "
                             << "Index (" << i << ", " << j
                             << ") is out of the matrix of size (" << this->n[0]
                             << ", " << this->n[1] << ")");
     return *(this->values + i + j * this->n[0]);
   }
 
   inline const T & at(UInt i, UInt j) const {
     AKANTU_DEBUG_ASSERT(((i < this->n[0]) && (j < this->n[1])),
                         "Access out of the matrix! "
                             << "Index (" << i << ", " << j
                             << ") is out of the matrix of size (" << this->n[0]
                             << ", " << this->n[1] << ")");
     return *(this->values + i + j * this->n[0]);
   }
 
   /* ------------------------------------------------------------------------ */
   inline T & operator()(UInt i, UInt j) { return this->at(i, j); }
   inline const T & operator()(UInt i, UInt j) const { return this->at(i, j); }
 
   /// give a line vector wrapped on the column i
   inline VectorProxy<T> operator()(UInt j) {
     AKANTU_DEBUG_ASSERT(j < this->n[1],
                         "Access out of the matrix! "
                             << "You are trying to access the column vector "
                             << j << " in a matrix of size (" << this->n[0]
                             << ", " << this->n[1] << ")");
     return VectorProxy<T>(this->values + j * this->n[0], this->n[0]);
   }
 
   inline const VectorProxy<T> operator()(UInt j) const {
     AKANTU_DEBUG_ASSERT(j < this->n[1],
                         "Access out of the matrix! "
                             << "You are trying to access the column vector "
                             << j << " in a matrix of size (" << this->n[0]
                             << ", " << this->n[1] << ")");
     return VectorProxy<T>(this->values + j * this->n[0], this->n[0]);
   }
 
   inline void block(const Matrix & block, UInt pos_i, UInt pos_j) {
     AKANTU_DEBUG_ASSERT(pos_i + block.rows() <= rows(),
                         "The block size or position are not correct");
     AKANTU_DEBUG_ASSERT(pos_i + block.cols() <= cols(),
                         "The block size or position are not correct");
     for (UInt i = 0; i < block.rows(); ++i)
       for (UInt j = 0; j < block.cols(); ++j)
         this->at(i + pos_i, j + pos_j) = block(i, j);
   }
 
   inline Matrix block(UInt pos_i, UInt pos_j, UInt block_rows,
                       UInt block_cols) const {
     AKANTU_DEBUG_ASSERT(pos_i + block_rows <= rows(),
                         "The block size or position are not correct");
     AKANTU_DEBUG_ASSERT(pos_i + block_cols <= cols(),
                         "The block size or position are not correct");
     Matrix block(block_rows, block_cols);
     for (UInt i = 0; i < block_rows; ++i)
       for (UInt j = 0; j < block_cols; ++j)
         block(i, j) = this->at(i + pos_i, j + pos_j);
     return block;
   }
 
   inline T & operator[](UInt idx) { return *(this->values + idx); };
   inline const T & operator[](UInt idx) const { return *(this->values + idx); };
 
   /* ---------------------------------------------------------------------- */
   inline Matrix operator*(const Matrix & B) {
     Matrix C(this->rows(), B.cols());
     C.mul<false, false>(*this, B);
     return C;
   }
 
   /* ----------------------------------------------------------------------- */
   inline Matrix & operator*=(const T & x) { return parent::operator*=(x); }
 
   inline Matrix & operator*=(const Matrix & B) {
     Matrix C(*this);
     this->mul<false, false>(C, B);
     return *this;
   }
 
   /* ---------------------------------------------------------------------- */
   template <bool tr_A, bool tr_B>
   inline void mul(const Matrix & A, const Matrix & B, T alpha = 1.0) {
     UInt k = A.cols();
     if (tr_A)
       k = A.rows();
 
 #ifndef AKANTU_NDEBUG
     if (tr_B) {
       AKANTU_DEBUG_ASSERT(k == B.cols(),
                           "matrices to multiply have no fit dimensions");
       AKANTU_DEBUG_ASSERT(this->cols() == B.rows(),
                           "matrices to multiply have no fit dimensions");
     } else {
       AKANTU_DEBUG_ASSERT(k == B.rows(),
                           "matrices to multiply have no fit dimensions");
       AKANTU_DEBUG_ASSERT(this->cols() == B.cols(),
                           "matrices to multiply have no fit dimensions");
     }
     if (tr_A) {
       AKANTU_DEBUG_ASSERT(this->rows() == A.cols(),
                           "matrices to multiply have no fit dimensions");
     } else {
       AKANTU_DEBUG_ASSERT(this->rows() == A.rows(),
                           "matrices to multiply have no fit dimensions");
     }
 #endif // AKANTU_NDEBUG
 
     Math::matMul<tr_A, tr_B>(this->rows(), this->cols(), k, alpha, A.storage(),
                              B.storage(), 0., this->storage());
   }
 
   /* ---------------------------------------------------------------------- */
   inline void outerProduct(const Vector<T> & A, const Vector<T> & B) {
     AKANTU_DEBUG_ASSERT(
         A.size() == this->rows() && B.size() == this->cols(),
         "A and B are not compatible with the size of the matrix");
     for (UInt i = 0; i < this->rows(); ++i) {
       for (UInt j = 0; j < this->cols(); ++j) {
         this->values[i + j * this->rows()] += A[i] * B[j];
       }
     }
   }
 
 private:
   class EigenSorter {
   public:
     EigenSorter(const Vector<T> & eigs) : eigs(eigs) {}
 
     bool operator()(const UInt & a, const UInt & b) const {
       return (eigs(a) > eigs(b));
     }
 
   private:
     const Vector<T> & eigs;
   };
 
 public:
   /* ---------------------------------------------------------------------- */
   inline void eig(Vector<T> & eigenvalues, Matrix<T> & eigenvectors) const {
     AKANTU_DEBUG_ASSERT(this->cols() == this->rows(),
                         "eig is not a valid operation on a rectangular matrix");
     AKANTU_DEBUG_ASSERT(eigenvalues.size() == this->cols(),
                         "eigenvalues should be of size " << this->cols()
                                                          << ".");
 #ifndef AKANTU_NDEBUG
     if (eigenvectors.storage() != nullptr)
       AKANTU_DEBUG_ASSERT((eigenvectors.rows() == eigenvectors.cols()) &&
                               (eigenvectors.rows() == this->cols()),
                           "Eigenvectors needs to be a square matrix of size "
                               << this->cols() << " x " << this->cols() << ".");
 #endif
 
     Matrix<T> tmp = *this;
     Vector<T> tmp_eigs(eigenvalues.size());
     Matrix<T> tmp_eig_vects(eigenvectors.rows(), eigenvectors.cols());
 
     if (tmp_eig_vects.rows() == 0 || tmp_eig_vects.cols() == 0)
       Math::matrixEig(tmp.cols(), tmp.storage(), tmp_eigs.storage());
     else
       Math::matrixEig(tmp.cols(), tmp.storage(), tmp_eigs.storage(),
                       tmp_eig_vects.storage());
 
     Vector<UInt> perm(eigenvalues.size());
     for (UInt i = 0; i < perm.size(); ++i)
       perm(i) = i;
 
     std::sort(perm.storage(), perm.storage() + perm.size(),
               EigenSorter(tmp_eigs));
 
     for (UInt i = 0; i < perm.size(); ++i)
       eigenvalues(i) = tmp_eigs(perm(i));
 
     if (tmp_eig_vects.rows() != 0 && tmp_eig_vects.cols() != 0)
       for (UInt i = 0; i < perm.size(); ++i) {
         for (UInt j = 0; j < eigenvectors.rows(); ++j) {
           eigenvectors(j, i) = tmp_eig_vects(j, perm(i));
         }
       }
   }
 
   /* ---------------------------------------------------------------------- */
   inline void eig(Vector<T> & eigenvalues) const {
     Matrix<T> empty;
     eig(eigenvalues, empty);
   }
 
   /* ---------------------------------------------------------------------- */
   inline void eye(T alpha = 1.) {
     AKANTU_DEBUG_ASSERT(this->cols() == this->rows(),
                         "eye is not a valid operation on a rectangular matrix");
     this->clear();
     for (UInt i = 0; i < this->cols(); ++i) {
       this->values[i + i * this->rows()] = alpha;
     }
   }
 
   /* ---------------------------------------------------------------------- */
   static inline Matrix<T> eye(UInt m, T alpha = 1.) {
     Matrix<T> tmp(m, m);
     tmp.eye(alpha);
     return tmp;
   }
 
   /* ---------------------------------------------------------------------- */
   inline T trace() const {
     AKANTU_DEBUG_ASSERT(
         this->cols() == this->rows(),
         "trace is not a valid operation on a rectangular matrix");
     T trace = 0.;
     for (UInt i = 0; i < this->rows(); ++i) {
       trace += this->values[i + i * this->rows()];
     }
     return trace;
   }
 
   /* ---------------------------------------------------------------------- */
   inline Matrix transpose() const {
     Matrix tmp(this->cols(), this->rows());
     for (UInt i = 0; i < this->rows(); ++i) {
       for (UInt j = 0; j < this->cols(); ++j) {
         tmp(j, i) = operator()(i, j);
       }
     }
     return tmp;
   }
 
   /* ---------------------------------------------------------------------- */
   inline void inverse(const Matrix & A) {
     AKANTU_DEBUG_ASSERT(A.cols() == A.rows(),
                         "inv is not a valid operation on a rectangular matrix");
     AKANTU_DEBUG_ASSERT(this->cols() == A.cols(),
                         "the matrix should have the same size as its inverse");
 
     if (this->cols() == 1)
       *this->values = 1. / *A.storage();
     else if (this->cols() == 2)
       Math::inv2(A.storage(), this->values);
     else if (this->cols() == 3)
       Math::inv3(A.storage(), this->values);
     else
       Math::inv(this->cols(), A.storage(), this->values);
   }
 
   inline Matrix inverse() {
     Matrix inv(this->rows(), this->cols());
     inv.inverse(*this);
     return inv;
   }
 
   /* --------------------------------------------------------------------- */
   inline T det() const {
     AKANTU_DEBUG_ASSERT(this->cols() == this->rows(),
                         "inv is not a valid operation on a rectangular matrix");
     if (this->cols() == 1)
       return *(this->values);
     else if (this->cols() == 2)
       return Math::det2(this->values);
     else if (this->cols() == 3)
       return Math::det3(this->values);
     else
       return Math::det(this->cols(), this->values);
   }
 
   /* --------------------------------------------------------------------- */
   inline T doubleDot(const Matrix<T> & other) const {
     AKANTU_DEBUG_ASSERT(
         this->cols() == this->rows(),
         "doubleDot is not a valid operation on a rectangular matrix");
     if (this->cols() == 1)
       return *(this->values) * *(other.storage());
     else if (this->cols() == 2)
       return Math::matrixDoubleDot22(this->values, other.storage());
     else if (this->cols() == 3)
       return Math::matrixDoubleDot33(this->values, other.storage());
     else
-      AKANTU_DEBUG_ERROR("doubleDot is not defined for other spatial dimensions"
+      AKANTU_ERROR("doubleDot is not defined for other spatial dimensions"
                          << " than 1, 2 or 3.");
     return T();
   }
 
   /* ---------------------------------------------------------------------- */
   /// function to print the containt of the class
   virtual void printself(std::ostream & stream, int indent = 0) const {
     std::string space;
     for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
       ;
 
     stream << "[";
     for (UInt i = 0; i < this->n[0]; ++i) {
       if (i != 0)
         stream << ", ";
       stream << "[";
       for (UInt j = 0; j < this->n[1]; ++j) {
         if (j != 0)
           stream << ", ";
         stream << operator()(i, j);
       }
       stream << "]";
     }
     stream << "]";
   };
 };
 
 /* ------------------------------------------------------------------------ */
 template <typename T>
 template <bool tr_A>
 inline void Vector<T>::mul(const Matrix<T> & A, const Vector<T> & x,
                            Real alpha) {
 #ifndef AKANTU_NDEBUG
   UInt n = x.size();
   if (tr_A) {
     AKANTU_DEBUG_ASSERT(n == A.rows(),
                         "matrix and vector to multiply have no fit dimensions");
     AKANTU_DEBUG_ASSERT(this->size() == A.cols(),
                         "matrix and vector to multiply have no fit dimensions");
   } else {
     AKANTU_DEBUG_ASSERT(n == A.cols(),
                         "matrix and vector to multiply have no fit dimensions");
     AKANTU_DEBUG_ASSERT(this->size() == A.rows(),
                         "matrix and vector to multiply have no fit dimensions");
   }
 #endif
   Math::matVectMul<tr_A>(A.rows(), A.cols(), alpha, A.storage(), x.storage(),
                          0., this->storage());
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline std::ostream & operator<<(std::ostream & stream,
                                  const Matrix<T> & _this) {
   _this.printself(stream);
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline std::ostream & operator<<(std::ostream & stream,
                                  const Vector<T> & _this) {
   _this.printself(stream);
   return stream;
 }
 
 /* ------------------------------------------------------------------------ */
 /* Tensor3                                                                  */
 /* ------------------------------------------------------------------------ */
 template <typename T> class Tensor3 : public TensorStorage<T, 3, Tensor3<T>> {
   using parent = TensorStorage<T, 3, Tensor3<T>>;
 
 public:
   using value_type = typename parent::value_type;
   using proxy = Tensor3Proxy<T>;
 
 public:
   Tensor3() : parent(){};
 
   Tensor3(UInt m, UInt n, UInt p, const T & def = T()) : parent(m, n, p, def) {}
 
   Tensor3(T * data, UInt m, UInt n, UInt p) : parent(data, m, n, p) {}
 
   Tensor3(const Tensor3 & src, bool deep_copy = true)
       : parent(src, deep_copy) {}
 
   Tensor3(const proxy & src) : parent(src) {}
 
 public:
   /* ------------------------------------------------------------------------ */
   inline Tensor3 & operator=(const Tensor3 & src) {
     parent::operator=(src);
     return *this;
   }
 
   /* ---------------------------------------------------------------------- */
   inline T & operator()(UInt i, UInt j, UInt k) {
     AKANTU_DEBUG_ASSERT(
         (i < this->n[0]) && (j < this->n[1]) && (k < this->n[2]),
         "Access out of the tensor3! "
             << "You are trying to access the element "
             << "(" << i << ", " << j << ", " << k << ") in a tensor of size ("
             << this->n[0] << ", " << this->n[1] << ", " << this->n[2] << ")");
     return *(this->values + (k * this->n[0] + i) * this->n[1] + j);
   }
 
   inline const T & operator()(UInt i, UInt j, UInt k) const {
     AKANTU_DEBUG_ASSERT(
         (i < this->n[0]) && (j < this->n[1]) && (k < this->n[2]),
         "Access out of the tensor3! "
             << "You are trying to access the element "
             << "(" << i << ", " << j << ", " << k << ") in a tensor of size ("
             << this->n[0] << ", " << this->n[1] << ", " << this->n[2] << ")");
     return *(this->values + (k * this->n[0] + i) * this->n[1] + j);
   }
 
   inline MatrixProxy<T> operator()(UInt k) {
     AKANTU_DEBUG_ASSERT((k < this->n[2]),
                         "Access out of the tensor3! "
                             << "You are trying to access the slice " << k
                             << " in a tensor3 of size (" << this->n[0] << ", "
                             << this->n[1] << ", " << this->n[2] << ")");
     return MatrixProxy<T>(this->values + k * this->n[0] * this->n[1],
                           this->n[0], this->n[1]);
   }
 
   inline const MatrixProxy<T> operator()(UInt k) const {
     AKANTU_DEBUG_ASSERT((k < this->n[2]),
                         "Access out of the tensor3! "
                             << "You are trying to access the slice " << k
                             << " in a tensor3 of size (" << this->n[0] << ", "
                             << this->n[1] << ", " << this->n[2] << ")");
     return MatrixProxy<T>(this->values + k * this->n[0] * this->n[1],
                           this->n[0], this->n[1]);
   }
 
   inline MatrixProxy<T> operator[](UInt k) {
     return MatrixProxy<T>(this->values + k * this->n[0] * this->n[1],
                           this->n[0], this->n[1]);
   }
 
   inline const MatrixProxy<T> operator[](UInt k) const {
     return MatrixProxy<T>(this->values + k * this->n[0] * this->n[1],
                           this->n[0], this->n[1]);
   }
 };
 
 /* -------------------------------------------------------------------------- */
 // support operations for the creation of other vectors
 /* -------------------------------------------------------------------------- */
 template <typename T>
 Vector<T> operator*(const T & scalar, const Vector<T> & a) {
   Vector<T> r(a);
   r *= scalar;
   return r;
 }
 
 template <typename T>
 Vector<T> operator*(const Vector<T> & a, const T & scalar) {
   Vector<T> r(a);
   r *= scalar;
   return r;
 }
 
 template <typename T>
 Vector<T> operator/(const Vector<T> & a, const T & scalar) {
   Vector<T> r(a);
   r /= scalar;
   return r;
 }
 
 template <typename T>
 Vector<T> operator*(const Vector<T> & a, const Vector<T> & b) {
   Vector<T> r(a);
   r *= b;
   return r;
 }
 
 template <typename T>
 Vector<T> operator+(const Vector<T> & a, const Vector<T> & b) {
   Vector<T> r(a);
   r += b;
   return r;
 }
 
 template <typename T>
 Vector<T> operator-(const Vector<T> & a, const Vector<T> & b) {
   Vector<T> r(a);
   r -= b;
   return r;
 }
 
 template <typename T>
 Vector<T> operator*(const Matrix<T> & A, const Vector<T> & b) {
   Vector<T> r(b.size());
   r.template mul<false>(A, b);
   return r;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 Matrix<T> operator*(const T & scalar, const Matrix<T> & a) {
   Matrix<T> r(a);
   r *= scalar;
   return r;
 }
 
 template <typename T>
 Matrix<T> operator*(const Matrix<T> & a, const T & scalar) {
   Matrix<T> r(a);
   r *= scalar;
   return r;
 }
 
 template <typename T>
 Matrix<T> operator/(const Matrix<T> & a, const T & scalar) {
   Matrix<T> r(a);
   r /= scalar;
   return r;
 }
 
 template <typename T>
 Matrix<T> operator+(const Matrix<T> & a, const Matrix<T> & b) {
   Matrix<T> r(a);
   r += b;
   return r;
 }
 
 template <typename T>
 Matrix<T> operator-(const Matrix<T> & a, const Matrix<T> & b) {
   Matrix<T> r(a);
   r -= b;
   return r;
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_AKA_TYPES_HH__ */
diff --git a/src/fe_engine/element_class.hh b/src/fe_engine/element_class.hh
index 42bf80eed..fb89b5709 100644
--- a/src/fe_engine/element_class.hh
+++ b/src/fe_engine/element_class.hh
@@ -1,401 +1,401 @@
 /**
  * @file   element_class.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Jan 21 2016
  *
  * @brief  Declaration of the ElementClass main class and the
  * Integration and Interpolation elements
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "aka_common.hh"
 #include "aka_types.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_ELEMENT_CLASS_HH__
 #define __AKANTU_ELEMENT_CLASS_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /// default element class structure
 template <ElementType element_type> struct ElementClassProperty {
   static const GeometricalType geometrical_type{_gt_not_defined};
   static const InterpolationType interpolation_type{_itp_not_defined};
   static const ElementKind element_kind{_ek_regular};
   static const UInt spatial_dimension{0};
   static const GaussIntegrationType gauss_integration_type{_git_not_defined};
   static const UInt polynomial_degree{0};
 };
 
 /// Macro to generate the element class structures for different element types
 #define AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(elem_type, geom_type,             \
                                              interp_type, elem_kind, sp,       \
                                              gauss_int_type, min_int_order)    \
   template <> struct ElementClassProperty<elem_type> {                         \
     static const GeometricalType geometrical_type{geom_type};                  \
     static const InterpolationType interpolation_type{interp_type};            \
     static const ElementKind element_kind{elem_kind};                          \
     static const UInt spatial_dimension{sp};                                   \
     static const GaussIntegrationType gauss_integration_type{gauss_int_type};  \
     static const UInt polynomial_degree{min_int_order};                        \
   }
 
 /* -------------------------------------------------------------------------- */
 /* Geometry                                                                   */
 /* -------------------------------------------------------------------------- */
 /// Default GeometricalShape structure
 template <GeometricalType geometrical_type> struct GeometricalShape {
   static const GeometricalShapeType shape{_gst_point};
 };
 
 /// Templated GeometricalShape with function contains
 template <GeometricalShapeType shape> struct GeometricalShapeContains {
   /// Check if the point (vector in 2 and 3D) at natural coordinate coor
   template <class vector_type>
   static inline bool contains(const vector_type & coord);
 };
 
 /// Macro to generate the GeometricalShape structures for different geometrical
 /// types
 #define AKANTU_DEFINE_SHAPE(geom_type, geom_shape)                             \
   template <> struct GeometricalShape<geom_type> {                             \
     static const GeometricalShapeType shape{geom_shape};                       \
   }
 
 AKANTU_DEFINE_SHAPE(_gt_hexahedron_20, _gst_square);
 AKANTU_DEFINE_SHAPE(_gt_hexahedron_8, _gst_square);
 AKANTU_DEFINE_SHAPE(_gt_pentahedron_15, _gst_prism);
 AKANTU_DEFINE_SHAPE(_gt_pentahedron_6, _gst_prism);
 AKANTU_DEFINE_SHAPE(_gt_point, _gst_point);
 AKANTU_DEFINE_SHAPE(_gt_quadrangle_4, _gst_square);
 AKANTU_DEFINE_SHAPE(_gt_quadrangle_8, _gst_square);
 AKANTU_DEFINE_SHAPE(_gt_segment_2, _gst_square);
 AKANTU_DEFINE_SHAPE(_gt_segment_3, _gst_square);
 AKANTU_DEFINE_SHAPE(_gt_tetrahedron_10, _gst_triangle);
 AKANTU_DEFINE_SHAPE(_gt_tetrahedron_4, _gst_triangle);
 AKANTU_DEFINE_SHAPE(_gt_triangle_3, _gst_triangle);
 AKANTU_DEFINE_SHAPE(_gt_triangle_6, _gst_triangle);
 
 /* -------------------------------------------------------------------------- */
 template <GeometricalType geometrical_type>
 struct GeometricalElementProperty {};
 
 template <ElementType element_type>
 struct ElementClassExtraGeometryProperties {};
 
 /* -------------------------------------------------------------------------- */
 /// Templated GeometricalElement with function getInradius
 template <GeometricalType geometrical_type,
           GeometricalShapeType shape =
               GeometricalShape<geometrical_type>::shape>
 class GeometricalElement {
   using geometrical_property = GeometricalElementProperty<geometrical_type>;
 
 public:
   /// compute the in-radius
   static inline Real getInradius(__attribute__((unused))
                                  const Matrix<Real> & coord) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// true if the natural coordinates are in the element
   template <class vector_type>
   static inline bool contains(const vector_type & coord);
 
 public:
   static AKANTU_GET_MACRO_NOT_CONST(SpatialDimension,
                                     geometrical_property::spatial_dimension,
                                     UInt);
   static AKANTU_GET_MACRO_NOT_CONST(NbNodesPerElement,
                                     geometrical_property::nb_nodes_per_element,
                                     UInt);
   static inline constexpr auto getNbFacetTypes() {
     return geometrical_property::nb_facet_types;
   };
   static inline UInt getNbFacetsPerElement(UInt t);
   static inline UInt getNbFacetsPerElement();
   static inline constexpr auto getFacetLocalConnectivityPerElement(UInt t = 0);
 };
 
 /* -------------------------------------------------------------------------- */
 /* Interpolation                                                              */
 /* -------------------------------------------------------------------------- */
 /// default InterpolationProperty structure
 template <InterpolationType interpolation_type> struct InterpolationProperty {};
 
 /// Macro to generate the InterpolationProperty structures for different
 /// interpolation types
 #define AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(itp_type, itp_kind,          \
                                                   nb_nodes, ndim)              \
   template <> struct InterpolationProperty<itp_type> {                         \
     static constexpr InterpolationKind kind{itp_kind};                         \
     static constexpr UInt nb_nodes_per_element{nb_nodes};                      \
     static constexpr UInt natural_space_dimension{ndim};                       \
   }
 
 /* -------------------------------------------------------------------------- */
 /// Generic (templated by the enum InterpolationType which specifies the order
 /// and the dimension of the interpolation) class handling the elemental
 /// interpolation
 template <InterpolationType interpolation_type,
           InterpolationKind kind =
               InterpolationProperty<interpolation_type>::kind>
 class InterpolationElement {
 public:
   using interpolation_property = InterpolationProperty<interpolation_type>;
 
   /// compute the shape values for a given set of points in natural coordinates
   static inline void computeShapes(const Matrix<Real> & natural_coord,
                                    Matrix<Real> & N);
 
   /// compute the shape values for a given point in natural coordinates
   template <class vector_type>
   static inline void computeShapes(const vector_type &, vector_type &) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /**
    * compute @f$ B_{ij} = \frac{\partial N_j}{\partial S_i} @f$ the variation of
    * shape functions along with variation of natural coordinates on a given set
    * of points in natural coordinates
    */
   static inline void computeDNDS(const Matrix<Real> & natural_coord,
                                  Tensor3<Real> & dnds);
   /**
    * compute @f$ B_{ij} = \frac{\partial N_j}{\partial S_i} @f$ the variation of
    * shape functions along with
    * variation of natural coordinates on a given point in natural
    * coordinates
    */
   template <class vector_type, class matrix_type>
   static inline void computeDNDS(const vector_type &, matrix_type &) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// compute jacobian (or integration variable change factor) for a given point
   /// in the case of spatial_dimension != natural_space_dimension
   static inline void computeSpecialJacobian(const Matrix<Real> &, Real &) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// interpolate a field given (arbitrary) natural coordinates
   static inline void
   interpolateOnNaturalCoordinates(const Vector<Real> & natural_coords,
                                   const Matrix<Real> & nodal_values,
                                   Vector<Real> & interpolated);
 
   /// interpolate a field given the shape functions on the interpolation point
   static inline void interpolate(const Matrix<Real> & nodal_values,
                                  const Vector<Real> & shapes,
                                  Vector<Real> & interpolated);
 
   /// interpolate a field given the shape functions on the interpolations points
   static inline void interpolate(const Matrix<Real> & nodal_values,
                                  const Matrix<Real> & shapes,
                                  Matrix<Real> & interpolated);
 
   /// compute the gradient of a given field on the given natural coordinates
   static inline void
   gradientOnNaturalCoordinates(const Vector<Real> & natural_coords,
                                const Matrix<Real> & f, Matrix<Real> & gradient);
 
 public:
   static AKANTU_GET_MACRO_NOT_CONST(
       ShapeSize,
       InterpolationProperty<interpolation_type>::nb_nodes_per_element, UInt);
   static AKANTU_GET_MACRO_NOT_CONST(
       ShapeDerivativesSize,
       (InterpolationProperty<interpolation_type>::nb_nodes_per_element *
        InterpolationProperty<interpolation_type>::natural_space_dimension),
       UInt);
   static AKANTU_GET_MACRO_NOT_CONST(
       NaturalSpaceDimension,
       InterpolationProperty<interpolation_type>::natural_space_dimension, UInt);
   static AKANTU_GET_MACRO_NOT_CONST(
       NbNodesPerInterpolationElement,
       InterpolationProperty<interpolation_type>::nb_nodes_per_element, UInt);
 };
 
 /* -------------------------------------------------------------------------- */
 /* Integration                                                                */
 /* -------------------------------------------------------------------------- */
 template <GaussIntegrationType git_class, UInt nb_points>
 struct GaussIntegrationTypeData {
   /// quadrature points in natural coordinates
   static Real quad_positions[];
   /// weights for the Gauss integration
   static Real quad_weights[];
 };
 
 template <ElementType type,
           UInt n = ElementClassProperty<type>::polynomial_degree>
 class GaussIntegrationElement {
 public:
   static UInt getNbQuadraturePoints();
   static const Matrix<Real> getQuadraturePoints();
   static const Vector<Real> getWeights();
 };
 
 /* -------------------------------------------------------------------------- */
 /* ElementClass                                                               */
 /* -------------------------------------------------------------------------- */
 template <ElementType element_type,
           ElementKind element_kind =
               ElementClassProperty<element_type>::element_kind>
 class ElementClass
     : public GeometricalElement<
           ElementClassProperty<element_type>::geometrical_type>,
       public InterpolationElement<
           ElementClassProperty<element_type>::interpolation_type> {
 protected:
   using geometrical_element =
       GeometricalElement<ElementClassProperty<element_type>::geometrical_type>;
   using interpolation_element = InterpolationElement<
       ElementClassProperty<element_type>::interpolation_type>;
 
   using element_property = ElementClassProperty<element_type>;
   using interpolation_property =
       typename interpolation_element::interpolation_property;
 
 public:
   /**
    * compute @f$ J = \frac{\partial x_j}{\partial s_i} @f$ the variation of real
    * coordinates along with variation of natural coordinates on a given point in
    * natural coordinates
    */
   static inline void computeJMat(const Matrix<Real> & dnds,
                                  const Matrix<Real> & node_coords,
                                  Matrix<Real> & J);
 
   /**
    * compute the Jacobian matrix by computing the variation of real coordinates
    * along with variation of natural coordinates on a given set of points in
    * natural coordinates
    */
   static inline void computeJMat(const Tensor3<Real> & dnds,
                                  const Matrix<Real> & node_coords,
                                  Tensor3<Real> & J);
 
   /// compute the jacobians of a serie of natural coordinates
   static inline void computeJacobian(const Matrix<Real> & natural_coords,
                                      const Matrix<Real> & node_coords,
                                      Vector<Real> & jacobians);
 
   /// compute jacobian (or integration variable change factor) for a set of
   /// points
   static inline void computeJacobian(const Tensor3<Real> & J,
                                      Vector<Real> & jacobians);
 
   /// compute jacobian (or integration variable change factor) for a given point
   static inline void computeJacobian(const Matrix<Real> & J, Real & jacobians);
 
   /// compute shape derivatives (input is dxds) for a set of points
   static inline void computeShapeDerivatives(const Tensor3<Real> & J,
                                              const Tensor3<Real> & dnds,
                                              Tensor3<Real> & shape_deriv);
 
   /// compute shape derivatives (input is dxds) for a given point
   static inline void computeShapeDerivatives(const Matrix<Real> & J,
                                              const Matrix<Real> & dnds,
                                              Matrix<Real> & shape_deriv);
 
   /// compute the normal of a surface defined by the function f
   static inline void
   computeNormalsOnNaturalCoordinates(const Matrix<Real> & coord,
                                      Matrix<Real> & f, Matrix<Real> & normals);
 
   /// get natural coordinates from real coordinates
   static inline void inverseMap(const Vector<Real> & real_coords,
                                 const Matrix<Real> & node_coords,
                                 Vector<Real> & natural_coords,
                                 Real tolerance = 1e-10);
 
   /// get natural coordinates from real coordinates
   static inline void inverseMap(const Matrix<Real> & real_coords,
                                 const Matrix<Real> & node_coords,
                                 Matrix<Real> & natural_coords,
                                 Real tolerance = 1e-10);
 
 public:
   static AKANTU_GET_MACRO_NOT_CONST(Kind, element_kind, ElementKind);
   static constexpr AKANTU_GET_MACRO_NOT_CONST(
       SpatialDimension, ElementClassProperty<element_type>::spatial_dimension,
       UInt);
 
   using element_class_extra_geom_property =
       ElementClassExtraGeometryProperties<element_type>;
 
   static constexpr auto getP1ElementType() {
     return element_class_extra_geom_property::p1_type;
   }
   static constexpr auto getFacetType(UInt t = 0) {
     return element_class_extra_geom_property::facet_type[t];
   }
   static constexpr auto getFacetTypes();
 };
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 #include "geometrical_element_property.hh"
 #include "interpolation_element_tmpl.hh"
 /* -------------------------------------------------------------------------- */
 #include "element_class_tmpl.hh"
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 #include "element_class_pentahedron_6_inline_impl.cc"
 /* keep order */
 #include "element_class_hexahedron_20_inline_impl.cc"
 #include "element_class_hexahedron_8_inline_impl.cc"
 #include "element_class_pentahedron_15_inline_impl.cc"
 #include "element_class_point_1_inline_impl.cc"
 #include "element_class_quadrangle_4_inline_impl.cc"
 #include "element_class_quadrangle_8_inline_impl.cc"
 #include "element_class_segment_2_inline_impl.cc"
 #include "element_class_segment_3_inline_impl.cc"
 #include "element_class_tetrahedron_10_inline_impl.cc"
 #include "element_class_tetrahedron_4_inline_impl.cc"
 #include "element_class_triangle_3_inline_impl.cc"
 #include "element_class_triangle_6_inline_impl.cc"
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
 #include "element_class_structural.hh"
 #endif
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
 #include "cohesive_element.hh"
 #endif
 
 #if defined(AKANTU_IGFEM)
 #include "element_class_igfem.hh"
 #endif
 
 #endif /* __AKANTU_ELEMENT_CLASS_HH__ */
diff --git a/src/fe_engine/element_class_structural.hh b/src/fe_engine/element_class_structural.hh
index 3dbefe93d..6a04fc723 100644
--- a/src/fe_engine/element_class_structural.hh
+++ b/src/fe_engine/element_class_structural.hh
@@ -1,250 +1,250 @@
 /**
  * @file   element_class_structural.hh
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Damien Spielmann <damien.spielmann@epfl.ch>
  *
  * @date creation: Thu Feb 21 2013
  * @date last modification: Thu Oct 22 2015
  *
  * @brief  Specialization of the element classes for structural elements
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 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"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_ELEMENT_CLASS_STRUCTURAL_HH__
 #define __AKANTU_ELEMENT_CLASS_STRUCTURAL_HH__
 
 namespace akantu {
 
 /// Macro to generate the InterpolationProperty structures for different
 /// interpolation types
 #define AKANTU_DEFINE_STRUCTURAL_INTERPOLATION_TYPE_PROPERTY(                  \
     itp_type, itp_geom_type, ndof, nb_stress, nb_dnds_cols)                    \
   template <> struct InterpolationProperty<itp_type> {                         \
     static const InterpolationKind kind{_itk_structural};                      \
     static const UInt nb_nodes_per_element{                                    \
         InterpolationProperty<itp_geom_type>::nb_nodes_per_element};           \
     static const InterpolationType itp_geometry_type{itp_geom_type};           \
     static const UInt natural_space_dimension{                                 \
         InterpolationProperty<itp_geom_type>::natural_space_dimension};        \
     static const UInt nb_degree_of_freedom{ndof};                              \
     static const UInt nb_stress_components{nb_stress};                         \
     static const UInt dnds_columns{nb_dnds_cols};                              \
   }
 
 /* -------------------------------------------------------------------------- */
 template <InterpolationType interpolation_type>
 class InterpolationElement<interpolation_type, _itk_structural> {
 public:
   using interpolation_property = InterpolationProperty<interpolation_type>;
 
   /// compute the shape values for a given set of points in natural coordinates
   static inline void computeShapes(const Matrix<Real> & natural_coord,
 				   const Matrix<Real> & real_coord,
                                    Tensor3<Real> & N) {
     for (UInt i = 0; i < natural_coord.cols(); ++i) {
       Matrix<Real> n_t = N(i);
       computeShapes(natural_coord(i), real_coord, n_t);
     }
   }
 
   /// compute the shape values for a given point in natural coordinates
   static inline void computeShapes(const Vector<Real> & natural_coord,
 				   const Matrix<Real> & real_coord,
                                    Matrix<Real> & N);
 
   /// compute shape derivatives (input is dxds) for a set of points
   static inline void computeShapeDerivatives(const Tensor3<Real> & Js,
                                              const Tensor3<Real> & DNDSs,
 					     const Matrix<Real> & R,
                                              Tensor3<Real> & Bs) {
     for (UInt i = 0; i < Js.size(2); ++i) {
       Matrix<Real> J = Js(i);
       Matrix<Real> DNDS = DNDSs(i);
       Matrix<Real> DNDX(DNDS.rows(), DNDS.cols());
       auto inv_J = J.inverse();
       DNDX.mul<false, false>(inv_J, DNDS);
       Matrix<Real> B_R = Bs(i);
       Matrix<Real> B(B_R.rows(), B_R.cols());
       arrangeInVoigt(DNDX, B);
       B_R.mul<false, false>(B, R);
     }
   }
 
   /**
    * compute @f$ B_{ij} = \frac{\partial N_j}{\partial S_i} @f$ the variation of
    * shape functions along with variation of natural coordinates on a given set
    * of points in natural coordinates
    */
   static inline void computeDNDS(const Matrix<Real> & natural_coord,
 				 const Matrix<Real> & real_coord,
                                  Tensor3<Real> & dnds) {
     for (UInt i = 0; i < natural_coord.cols(); ++i) {
       Matrix<Real> dnds_t = dnds(i);
       computeDNDS(natural_coord(i), real_coord, dnds_t);
     }
   }
 
   /**
    * compute @f$ B_{ij} = \frac{\partial N_j}{\partial S_i} @f$ the variation of
    * shape functions along with
    * variation of natural coordinates on a given point in natural
    * coordinates
    */
   static inline void computeDNDS(const Vector<Real> & natural_coord,
 				 const Matrix<Real> & real_coord,
                                  Matrix<Real> & dnds);
 
   /**
    * arrange B in Voigt notation from DNDS
    */
   static inline void arrangeInVoigt(const Matrix<Real> & dnds,
 				    Matrix<Real> & B) {
     // Default implementation assumes dnds is already in Voigt notation
     B.deepCopy(dnds);
   }
 
 public:
   static AKANTU_GET_MACRO_NOT_CONST(
       NbNodesPerInterpolationElement,
       interpolation_property::nb_nodes_per_element, UInt);
 
   static AKANTU_GET_MACRO_NOT_CONST(
       ShapeSize, (interpolation_property::nb_nodes_per_element *
                   interpolation_property::nb_degree_of_freedom *
                   interpolation_property::nb_degree_of_freedom),
       UInt);
   static AKANTU_GET_MACRO_NOT_CONST(
       ShapeDerivativesSize, (interpolation_property::nb_nodes_per_element *
                              interpolation_property::nb_degree_of_freedom *
                              interpolation_property::nb_stress_components),
       UInt);
   static AKANTU_GET_MACRO_NOT_CONST(
       NaturalSpaceDimension, interpolation_property::natural_space_dimension,
       UInt);
   static AKANTU_GET_MACRO_NOT_CONST(
       NbDegreeOfFreedom, interpolation_property::nb_degree_of_freedom, UInt);
   static AKANTU_GET_MACRO_NOT_CONST(
       NbStressComponents, interpolation_property::nb_stress_components, UInt);
 };
 
 /// Macro to generate the element class structures for different structural
 /// element types
 /* -------------------------------------------------------------------------- */
 #define AKANTU_DEFINE_STRUCTURAL_ELEMENT_CLASS_PROPERTY(                       \
     elem_type, geom_type, interp_type, parent_el_type, elem_kind, sp,          \
     gauss_int_type, min_int_order)                                             \
   template <> struct ElementClassProperty<elem_type> {                         \
     static const GeometricalType geometrical_type{geom_type};                  \
     static const InterpolationType interpolation_type{interp_type};            \
     static const ElementType parent_element_type{parent_el_type};              \
     static const ElementKind element_kind{elem_kind};                          \
     static const UInt spatial_dimension{sp};                                   \
     static const GaussIntegrationType gauss_integration_type{gauss_int_type};  \
     static const UInt polynomial_degree{min_int_order};                        \
   }
 
 /* -------------------------------------------------------------------------- */
 /* ElementClass for structural elements                                       */
 /* -------------------------------------------------------------------------- */
 template <ElementType element_type>
 class ElementClass<element_type, _ek_structural>
     : public GeometricalElement<
           ElementClassProperty<element_type>::geometrical_type>,
       public InterpolationElement<
           ElementClassProperty<element_type>::interpolation_type> {
 protected:
   using geometrical_element =
       GeometricalElement<ElementClassProperty<element_type>::geometrical_type>;
   using interpolation_element = InterpolationElement<
       ElementClassProperty<element_type>::interpolation_type>;
   using parent_element =
       ElementClass<ElementClassProperty<element_type>::parent_element_type>;
 
 public:
   static inline void
   computeRotationMatrix(Matrix<Real> & /*R*/, const Matrix<Real> & /*X*/,
                         const Vector<Real> & /*extra_normal*/) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// compute jacobian (or integration variable change factor) for a given point
   static inline void computeJMat(const Vector<Real> & natural_coords,
                                  const Matrix<Real> & Xs, Matrix<Real> & J) {
     Matrix<Real> dnds(Xs.rows(), Xs.cols());
     parent_element::computeDNDS(natural_coords, dnds);
     J.mul<false, true>(dnds, Xs);
   }
 
   static inline void computeJMat(const Matrix<Real> & natural_coords,
                                  const Matrix<Real> & Xs, Tensor3<Real> & Js) {
     for (UInt i = 0 ; i < natural_coords.cols(); ++i) {
       // because non-const l-value reference does not bind to r-value
       Matrix<Real> J = Js(i);
       computeJMat(Vector<Real>(natural_coords(i)), Xs, J);
     }
   }
 
   static inline void computeJacobian(const Matrix<Real> & natural_coords,
                                      const Matrix<Real> & node_coords,
                                      Vector<Real> & jacobians) {
     using itp = typename interpolation_element::interpolation_property;
     Tensor3<Real> Js(itp::natural_space_dimension, itp::natural_space_dimension,
                      natural_coords.cols());
     computeJMat(natural_coords, node_coords, Js);
     for (UInt i = 0; i < natural_coords.cols(); ++i) {
       Matrix<Real> J = Js(i);
       jacobians(i) = J.det();
     }
   }
 
   static inline void computeRotation(const Matrix<Real> & node_coords,
                                      Matrix<Real> & rotation);
 
 public:
   static AKANTU_GET_MACRO_NOT_CONST(Kind, _ek_structural, ElementKind);
   static AKANTU_GET_MACRO_NOT_CONST(P1ElementType, _not_defined, ElementType);
   static AKANTU_GET_MACRO_NOT_CONST(FacetType, _not_defined, ElementType);
   static constexpr auto getFacetType(__attribute__((unused)) UInt t = 0) {
     return _not_defined;
   }
   static constexpr AKANTU_GET_MACRO_NOT_CONST(
       SpatialDimension, ElementClassProperty<element_type>::spatial_dimension,
       UInt);
   static constexpr auto getFacetTypes() {
     return ElementClass<_not_defined>::getFacetTypes();
   }
 };
 
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 #include "element_classes/element_class_hermite_inline_impl.cc"
 /* keep order */
 #include "element_classes/element_class_bernoulli_beam_inline_impl.cc"
 #include "element_classes/element_class_kirchhoff_shell_inline_impl.cc"
 /* -------------------------------------------------------------------------- */
 
 #endif /* __AKANTU_ELEMENT_CLASS_STRUCTURAL_HH__ */
diff --git a/src/fe_engine/fe_engine.hh b/src/fe_engine/fe_engine.hh
index 479d24fd7..4decb1828 100644
--- a/src/fe_engine/fe_engine.hh
+++ b/src/fe_engine/fe_engine.hh
@@ -1,393 +1,393 @@
 /**
  * @file   fe_engine.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Oct 22 2015
  *
  * @brief  FEM class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "aka_memory.hh"
 #include "element_type_map.hh"
 #include "mesh_events.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_FE_ENGINE_HH__
 #define __AKANTU_FE_ENGINE_HH__
 
 namespace akantu {
 class Mesh;
 class Integrator;
 class ShapeFunctions;
 class DOFManager;
 class Element;
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 
 /**
  * The  generic  FEEngine class  derived  in  a  FEEngineTemplate class
  * containing  the
  * shape functions and the integration method
  */
 class FEEngine : protected Memory, public MeshEventHandler {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   FEEngine(Mesh & mesh, UInt spatial_dimension = _all_dimensions,
            const ID & id = "fem", MemoryID memory_id = 0);
 
   ~FEEngine() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// pre-compute all the shape functions, their derivatives and the jacobians
   virtual void
   initShapeFunctions(const GhostType & ghost_type = _not_ghost) = 0;
 
   /// extract the nodal values and store them per element
   template <typename T>
   static void extractNodalToElementField(
       const Mesh & mesh, const Array<T> & nodal_f, Array<T> & elemental_f,
       const ElementType & type, const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter);
 
   /// filter a field
   template <typename T>
   static void
   filterElementalData(const Mesh & mesh, const Array<T> & quad_f,
                       Array<T> & filtered_f, const ElementType & type,
                       const GhostType & ghost_type = _not_ghost,
                       const Array<UInt> & filter_elements = empty_filter);
 
   /* ------------------------------------------------------------------------ */
   /* Integration method bridges                                               */
   /* ------------------------------------------------------------------------ */
   /// integrate f for all elements of type "type"
   virtual void
   integrate(const Array<Real> & f, Array<Real> & intf,
             UInt nb_degree_of_freedom, const ElementType & type,
             const GhostType & ghost_type = _not_ghost,
             const Array<UInt> & filter_elements = empty_filter) const = 0;
 
   /// integrate a scalar value f on all elements of type "type"
   virtual Real
   integrate(const Array<Real> & f, const ElementType & type,
             const GhostType & ghost_type = _not_ghost,
             const Array<UInt> & filter_elements = empty_filter) const = 0;
 
   /// integrate f for all integration points of type "type" but don't sum over
   /// all integration points
   virtual void integrateOnIntegrationPoints(
       const Array<Real> & f, Array<Real> & intf, UInt nb_degree_of_freedom,
       const ElementType & type, const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const = 0;
 
   /// integrate one element scalar value on all elements of type "type"
   virtual Real integrate(const Vector<Real> & f, const ElementType & type,
                          UInt index,
                          const GhostType & ghost_type = _not_ghost) const = 0;
 
 /* ------------------------------------------------------------------------ */
 /* compatibility with old FEEngine fashion */
 /* ------------------------------------------------------------------------ */
 #ifndef SWIG
   /// get the number of integration points
   virtual UInt
   getNbIntegrationPoints(const ElementType & type,
                          const GhostType & ghost_type = _not_ghost) const = 0;
   /// get the precomputed shapes
   const virtual Array<Real> &
   getShapes(const ElementType & type, const GhostType & ghost_type = _not_ghost,
             UInt id = 0) const = 0;
 
   /// get the derivatives of shapes
   const virtual Array<Real> &
   getShapesDerivatives(const ElementType & type,
                        const GhostType & ghost_type = _not_ghost,
                        UInt id = 0) const = 0;
 
   /// get integration points
   const virtual Matrix<Real> &
   getIntegrationPoints(const ElementType & type,
                        const GhostType & ghost_type = _not_ghost) const = 0;
 #endif
   /* ------------------------------------------------------------------------ */
   /* Shape method bridges                                                     */
   /* ------------------------------------------------------------------------ */
   /// Compute the gradient nablauq on the integration points of an element type
   /// from nodal values u
   virtual void gradientOnIntegrationPoints(
       const Array<Real> & u, Array<Real> & nablauq,
       const UInt nb_degree_of_freedom, const ElementType & type,
       const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const = 0;
 
   /// Interpolate a nodal field u at the integration points of an element type
   /// -> uq
   virtual void interpolateOnIntegrationPoints(
       const Array<Real> & u, Array<Real> & uq, UInt nb_degree_of_freedom,
       const ElementType & type, const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const = 0;
 
   /// Interpolate a nodal field u at the integration points of many element
   /// types -> uq
   virtual void interpolateOnIntegrationPoints(
       const Array<Real> & u, ElementTypeMapArray<Real> & uq,
       const ElementTypeMapArray<UInt> * filter_elements = nullptr) const = 0;
 
   /// pre multiplies a tensor by the shapes derivaties
   virtual void
   computeBtD(const Array<Real> & Ds, Array<Real> & BtDs,
              const ElementType & type, const GhostType & ghost_type,
              const Array<UInt> & filter_elements = empty_filter) const = 0;
 
   /// left and right  multiplies a tensor by the shapes derivaties
   virtual void
   computeBtDB(const Array<Real> & Ds, Array<Real> & BtDBs, UInt order_d,
               const ElementType & type, const GhostType & ghost_type,
               const Array<UInt> & filter_elements = empty_filter) const = 0;
 
   /// Compute the interpolation point position in the global coordinates for
   /// many element types
   virtual void computeIntegrationPointsCoordinates(
       ElementTypeMapArray<Real> & integration_points_coordinates,
       const ElementTypeMapArray<UInt> * filter_elements = nullptr) const = 0;
 
   /// Compute the interpolation point position in the global coordinates for an
   /// element type
   virtual void computeIntegrationPointsCoordinates(
       Array<Real> & integration_points_coordinates, const ElementType & type,
       const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const = 0;
 
   /// Build pre-computed matrices for interpolation of field form integration
   /// points at other given positions (interpolation_points)
   virtual void initElementalFieldInterpolationFromIntegrationPoints(
       const ElementTypeMapArray<Real> & interpolation_points_coordinates,
       ElementTypeMapArray<Real> & interpolation_points_coordinates_matrices,
       ElementTypeMapArray<Real> & integration_points_coordinates_inv_matrices,
       const ElementTypeMapArray<UInt> * element_filter) const = 0;
 
   /// interpolate field at given position (interpolation_points) from given
   /// values of this field at integration points (field)
   virtual void interpolateElementalFieldFromIntegrationPoints(
       const ElementTypeMapArray<Real> & field,
       const ElementTypeMapArray<Real> & interpolation_points_coordinates,
       ElementTypeMapArray<Real> & result, const GhostType ghost_type,
       const ElementTypeMapArray<UInt> * element_filter) const = 0;
 
   /// Interpolate field at given position from given values of this field at
   /// integration points (field)
   /// using matrices precomputed with
   /// initElementalFieldInterplationFromIntegrationPoints
   virtual void interpolateElementalFieldFromIntegrationPoints(
       const ElementTypeMapArray<Real> & field,
       const ElementTypeMapArray<Real> &
           interpolation_points_coordinates_matrices,
       const ElementTypeMapArray<Real> &
           integration_points_coordinates_inv_matrices,
       ElementTypeMapArray<Real> & result, const GhostType ghost_type,
       const ElementTypeMapArray<UInt> * element_filter) const = 0;
 
   /// interpolate on a phyiscal point inside an element
   virtual void interpolate(const Vector<Real> & real_coords,
                            const Matrix<Real> & nodal_values,
                            Vector<Real> & interpolated,
                            const Element & element) const = 0;
 
   /// compute the shape on a provided point
   virtual void
   computeShapes(const Vector<Real> & real_coords, UInt elem,
                 const ElementType & type, Vector<Real> & shapes,
                 const GhostType & ghost_type = _not_ghost) const = 0;
 
   /// compute the shape derivatives on a provided point
   virtual void
   computeShapeDerivatives(const Vector<Real> & real__coords, UInt element,
                           const ElementType & type,
                           Matrix<Real> & shape_derivatives,
                           const GhostType & ghost_type = _not_ghost) const = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Other methods                                                            */
   /* ------------------------------------------------------------------------ */
 
   /// pre-compute normals on integration points
   virtual void computeNormalsOnIntegrationPoints(
       const GhostType & ghost_type = _not_ghost) = 0;
 
   /// pre-compute normals on integration points
   virtual void computeNormalsOnIntegrationPoints(
       __attribute__((unused)) const Array<Real> & field,
       __attribute__((unused)) const GhostType & ghost_type = _not_ghost) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// pre-compute normals on integration points
   virtual void computeNormalsOnIntegrationPoints(
       __attribute__((unused)) const Array<Real> & field,
       __attribute__((unused)) Array<Real> & normal,
       __attribute__((unused)) const ElementType & type,
       __attribute__((unused)) const GhostType & ghost_type = _not_ghost) const {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
 #ifdef AKANTU_STRUCTURAL_MECHANICS
 
   /// assemble a field as a matrix for structural elements (ex. rho to mass
   /// matrix)
   virtual void assembleFieldMatrix(
       __attribute__((unused)) const Array<Real> & field_1,
       __attribute__((unused)) UInt nb_degree_of_freedom,
       __attribute__((unused)) SparseMatrix & M,
       __attribute__((unused)) Array<Real> * n,
       __attribute__((unused)) ElementTypeMapArray<Real> & rotation_mat,
       __attribute__((unused)) ElementType type,
       __attribute__((unused)) const GhostType & ghost_type) const {
 
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
   /// compute shapes function in a matrix for structural elements
   virtual void computeShapesMatrix(
       __attribute__((unused)) const ElementType & type,
       __attribute__((unused)) UInt nb_degree_of_freedom,
       __attribute__((unused)) UInt nb_nodes_per_element,
       __attribute__((unused)) Array<Real> * n, __attribute__((unused)) UInt id,
       __attribute__((unused)) UInt degree_to_interpolate,
       __attribute__((unused)) UInt degree_interpolated,
       __attribute__((unused)) const bool sign,
       __attribute__((unused)) const GhostType & ghost_type) const {
 
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
 #endif
 
   /// function to print the containt of the class
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
 private:
   /// initialise the class
   void init();
 
   /* ------------------------------------------------------------------------ */
   /* Mesh Event Handler interface                                             */
   /* ------------------------------------------------------------------------ */
 public:
   void onNodesAdded(const Array<UInt> &, const NewNodesEvent &) final {}
   void onNodesRemoved(const Array<UInt> &, const Array<UInt> &,
                       const RemovedNodesEvent &) final {}
   void onElementsAdded(const Array<Element> &,
                        const NewElementsEvent &) override{};
   void onElementsRemoved(const Array<Element> &,
                          const ElementTypeMapArray<UInt> &,
                          const RemovedElementsEvent &) override {}
   void onElementsChanged(const Array<Element> &, const Array<Element> &,
                          const ElementTypeMapArray<UInt> &,
                          const ChangedElementsEvent &) override {}
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   using ElementTypesIteratorHelper =
       ElementTypeMapArray<Real, ElementType>::ElementTypesIteratorHelper;
 
   ElementTypesIteratorHelper elementTypes(UInt dim = _all_dimensions,
                                           GhostType ghost_type = _not_ghost,
                                           ElementKind kind = _ek_regular) const;
 
   /// get the dimension of the element handeled by this fe_engine object
   AKANTU_GET_MACRO(ElementDimension, element_dimension, UInt);
 
   /// get the mesh contained in the fem object
   AKANTU_GET_MACRO(Mesh, mesh, const Mesh &);
   /// get the mesh contained in the fem object
   AKANTU_GET_MACRO_NOT_CONST(Mesh, mesh, Mesh &);
 
   /// get the in-radius of an element
   static inline Real getElementInradius(const Matrix<Real> & coord,
                                         const ElementType & type);
 
   /// get the normals on integration points
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(NormalsOnIntegrationPoints,
                                          normals_on_integration_points, Real);
 
   /// get cohesive element type for a given facet type
   static inline ElementType
   getCohesiveElementType(const ElementType & type_facet);
 
   /// get igfem element type for a given regular type
   static inline Vector<ElementType>
   getIGFEMElementTypes(const ElementType & type);
 
   /// get the interpolation element associated to an element type
   static inline InterpolationType
   getInterpolationType(const ElementType & el_type);
 
   /// get the shape function class (probably useless: see getShapeFunction in
   /// fe_engine_template.hh)
   virtual const ShapeFunctions & getShapeFunctionsInterface() const = 0;
   /// get the integrator class (probably useless: see getIntegrator in
   /// fe_engine_template.hh)
   virtual const Integrator & getIntegratorInterface() const = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// spatial dimension of the problem
   UInt element_dimension;
 
   /// the mesh on which all computation are made
   Mesh & mesh;
 
   /// normals at integration points
   ElementTypeMapArray<Real> normals_on_integration_points;
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream,
                                  const FEEngine & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #include "fe_engine_inline_impl.cc"
 #include "fe_engine_template.hh"
 
 #endif /* __AKANTU_FE_ENGINE_HH__ */
diff --git a/src/fe_engine/fe_engine_template_cohesive.cc b/src/fe_engine/fe_engine_template_cohesive.cc
index d247ac9d5..2f1482353 100644
--- a/src/fe_engine/fe_engine_template_cohesive.cc
+++ b/src/fe_engine/fe_engine_template_cohesive.cc
@@ -1,133 +1,133 @@
 /**
  * @file   fe_engine_template_cohesive.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Oct 31 2012
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Specialization of the FEEngineTemplate for cohesive element
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "fe_engine_template.hh"
 #include "shape_cohesive.hh"
 #include "integrator_gauss.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* compatibility functions */
 /* -------------------------------------------------------------------------- */
 template <>
 Real FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_cohesive,
                       DefaultIntegrationOrderFunctor>::
     integrate(const Array<Real> & f, const ElementType & type,
               const GhostType & ghost_type,
               const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
 #ifndef AKANTU_NDEBUG
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
     nb_element = filter_elements.size();
 
   UInt nb_quadrature_points = getNbIntegrationPoints(type);
 
   AKANTU_DEBUG_ASSERT(f.size() == nb_element * nb_quadrature_points,
                       "The vector f(" << f.getID()
                                       << ") has not the good size.");
   AKANTU_DEBUG_ASSERT(f.getNbComponent() == 1,
                       "The vector f("
                           << f.getID()
                           << ") has not the good number of component.");
 #endif
 
   Real integral = 0.;
 
 #define INTEGRATE(type)                                                        \
   integral = integrator.integrate<type>(f, ghost_type, filter_elements);
 
   AKANTU_BOOST_COHESIVE_ELEMENT_SWITCH(INTEGRATE);
 #undef INTEGRATE
 
   AKANTU_DEBUG_OUT();
   return integral;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_cohesive,
                       DefaultIntegrationOrderFunctor>::
     integrate(const Array<Real> & f, Array<Real> & intf,
               UInt nb_degree_of_freedom, const ElementType & type,
               const GhostType & ghost_type,
               const Array<UInt> & filter_elements) const {
 
 #ifndef AKANTU_NDEBUG
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements == filter_elements)
     nb_element = filter_elements.size();
 
   UInt nb_quadrature_points = getNbIntegrationPoints(type);
 
   AKANTU_DEBUG_ASSERT(f.size() == nb_element * nb_quadrature_points,
                       "The vector f(" << f.getID() << " size " << f.size()
                                       << ") has not the good size ("
                                       << nb_element << ").");
   AKANTU_DEBUG_ASSERT(f.getNbComponent() == nb_degree_of_freedom,
                       "The vector f("
                           << f.getID()
                           << ") has not the good number of component.");
   AKANTU_DEBUG_ASSERT(intf.getNbComponent() == nb_degree_of_freedom,
                       "The vector intf("
                           << intf.getID()
                           << ") has not the good number of component.");
   AKANTU_DEBUG_ASSERT(intf.size() == nb_element,
                       "The vector intf(" << intf.getID()
                                          << ") has not the good size.");
 #endif
 
 #define INTEGRATE(type)                                                        \
   integrator.integrate<type>(f, intf, nb_degree_of_freedom, ghost_type,        \
                              filter_elements);
 
   AKANTU_BOOST_COHESIVE_ELEMENT_SWITCH(INTEGRATE);
 #undef INTEGRATE
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_cohesive,
                       DefaultIntegrationOrderFunctor>::
     gradientOnIntegrationPoints(const Array<Real> &, Array<Real> &, const UInt,
                                 const ElementType &, const GhostType &,
                                 const Array<UInt> &) const {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/fe_engine/fe_engine_template_tmpl.hh b/src/fe_engine/fe_engine_template_tmpl.hh
index cf51dad72..1d5c54b00 100644
--- a/src/fe_engine/fe_engine_template_tmpl.hh
+++ b/src/fe_engine/fe_engine_template_tmpl.hh
@@ -1,1374 +1,1374 @@
 /**
  * @file   fe_engine_template_tmpl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue Feb 15 2011
  * @date last modification: Thu Nov 19 2015
  *
  * @brief  Template implementation of FEEngineTemplate
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "aka_common.hh"
 #include "dof_manager.hh"
 #include "fe_engine_template.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::FEEngineTemplate(
     Mesh & mesh, UInt spatial_dimension, ID id, MemoryID memory_id)
     : FEEngine(mesh, spatial_dimension, id, memory_id),
       integrator(mesh, id, memory_id), shape_functions(mesh, id, memory_id) {}
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::~FEEngineTemplate() =
     default;
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct GradientOnIntegrationPointsHelper {
       template <class S>
       static void call(const S &, Mesh &, const Array<Real> &, Array<Real> &,
                        const UInt, const ElementType &, const GhostType &,
                        const Array<UInt> &) {
-        AKANTU_DEBUG_TO_IMPLEMENT();
+        AKANTU_TO_IMPLEMENT();
       }
     };
 
 #define COMPUTE_GRADIENT(type)                                                 \
   if (element_dimension == ElementClass<type>::getSpatialDimension())          \
     shape_functions.template gradientOnIntegrationPoints<type>(                \
         u, nablauq, nb_degree_of_freedom, ghost_type, filter_elements);
 
 #define AKANTU_SPECIALIZE_GRADIENT_ON_INTEGRATION_POINTS_HELPER(kind)          \
   template <> struct GradientOnIntegrationPointsHelper<kind> {                 \
     template <class S>                                                         \
     static void call(const S & shape_functions, Mesh & mesh,                   \
                      const Array<Real> & u, Array<Real> & nablauq,             \
                      const UInt nb_degree_of_freedom,                          \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<UInt> & filter_elements) {                    \
       UInt element_dimension = mesh.getSpatialDimension(type);                 \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(COMPUTE_GRADIENT, kind);                \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(
         AKANTU_SPECIALIZE_GRADIENT_ON_INTEGRATION_POINTS_HELPER,
         AKANTU_FE_ENGINE_LIST_GRADIENT_ON_INTEGRATION_POINTS)
 
 #undef AKANTU_SPECIALIZE_GRADIENT_ON_INTEGRATION_POINTS_HELPER
 #undef COMPUTE_GRADIENT
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     gradientOnIntegrationPoints(const Array<Real> & u, Array<Real> & nablauq,
                                 const UInt nb_degree_of_freedom,
                                 const ElementType & type,
                                 const GhostType & ghost_type,
                                 const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
     nb_element = filter_elements.size();
   UInt nb_points =
       shape_functions.getIntegrationPoints(type, ghost_type).cols();
 
 #ifndef AKANTU_NDEBUG
 
   UInt element_dimension = mesh.getSpatialDimension(type);
 
   AKANTU_DEBUG_ASSERT(u.size() == mesh.getNbNodes(),
                       "The vector u(" << u.getID()
                                       << ") has not the good size.");
   AKANTU_DEBUG_ASSERT(u.getNbComponent() == nb_degree_of_freedom,
                       "The vector u("
                           << u.getID()
                           << ") has not the good number of component.");
 
   AKANTU_DEBUG_ASSERT(
       nablauq.getNbComponent() == nb_degree_of_freedom * element_dimension,
       "The vector nablauq(" << nablauq.getID()
                             << ") has not the good number of component.");
 
 // AKANTU_DEBUG_ASSERT(nablauq.size() == nb_element * nb_points,
 //                  "The vector nablauq(" << nablauq.getID()
 //                  << ") has not the good size.");
 #endif
 
   nablauq.resize(nb_element * nb_points);
 
   fe_engine::details::GradientOnIntegrationPointsHelper<kind>::call(
       shape_functions, mesh, u, nablauq, nb_degree_of_freedom, type, ghost_type,
       filter_elements);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::initShapeFunctions(
     const GhostType & ghost_type) {
   initShapeFunctions(mesh.getNodes(), ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::initShapeFunctions(
     const Array<Real> & nodes, const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   for (auto & type : mesh.elementTypes(element_dimension, ghost_type, kind)) {
     integrator.initIntegrator(nodes, type, ghost_type);
     const auto & control_points = getIntegrationPoints(type, ghost_type);
     shape_functions.initShapeFunctions(nodes, control_points, type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct IntegrateHelper {};
 
 #define INTEGRATE(type)                                                        \
   integrator.template integrate<type>(f, intf, nb_degree_of_freedom,           \
                                       ghost_type, filter_elements);
 
 #define AKANTU_SPECIALIZE_INTEGRATE_HELPER(kind)                               \
   template <> struct IntegrateHelper<kind> {                                   \
     template <class I>                                                         \
     static void call(const I & integrator, const Array<Real> & f,              \
                      Array<Real> & intf, UInt nb_degree_of_freedom,            \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<UInt> & filter_elements) {                    \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTEGRATE, kind);                       \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_INTEGRATE_HELPER)
 
 #undef AKANTU_SPECIALIZE_INTEGRATE_HELPER
 #undef INTEGRATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::integrate(
     const Array<Real> & f, Array<Real> & intf, UInt nb_degree_of_freedom,
     const ElementType & type, const GhostType & ghost_type,
     const Array<UInt> & filter_elements) const {
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
     nb_element = filter_elements.size();
 #ifndef AKANTU_NDEBUG
 
   UInt nb_quadrature_points = getNbIntegrationPoints(type);
 
   AKANTU_DEBUG_ASSERT(f.size() == nb_element * nb_quadrature_points,
                       "The vector f(" << f.getID() << " size " << f.size()
                                       << ") has not the good size ("
                                       << nb_element << ").");
   AKANTU_DEBUG_ASSERT(f.getNbComponent() == nb_degree_of_freedom,
                       "The vector f("
                           << f.getID()
                           << ") has not the good number of component.");
   AKANTU_DEBUG_ASSERT(intf.getNbComponent() == nb_degree_of_freedom,
                       "The vector intf("
                           << intf.getID()
                           << ") has not the good number of component.");
 #endif
 
   intf.resize(nb_element);
 
   fe_engine::details::IntegrateHelper<kind>::call(integrator, f, intf,
                                                   nb_degree_of_freedom, type,
                                                   ghost_type, filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct IntegrateScalarHelper {};
 
 #define INTEGRATE(type)                                                        \
   integral =                                                                   \
       integrator.template integrate<type>(f, ghost_type, filter_elements);
 
 #define AKANTU_SPECIALIZE_INTEGRATE_SCALAR_HELPER(kind)                        \
   template <> struct IntegrateScalarHelper<kind> {                             \
     template <class I>                                                         \
     static Real call(const I & integrator, const Array<Real> & f,              \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<UInt> & filter_elements) {                    \
       Real integral = 0.;                                                      \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTEGRATE, kind);                       \
       return integral;                                                         \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_INTEGRATE_SCALAR_HELPER)
 
 #undef AKANTU_SPECIALIZE_INTEGRATE_SCALAR_HELPER
 #undef INTEGRATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 Real FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::integrate(
     const Array<Real> & f, const ElementType & type,
     const GhostType & ghost_type, const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
 #ifndef AKANTU_NDEBUG
   //   std::stringstream sstr; sstr << ghost_type;
   //   AKANTU_DEBUG_ASSERT(sstr.str() == nablauq.getTag(),
   //                  "The vector " << nablauq.getID() << " is not taged " <<
   //                  ghost_type);
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
     nb_element = filter_elements.size();
 
   UInt nb_quadrature_points = getNbIntegrationPoints(type, ghost_type);
 
   AKANTU_DEBUG_ASSERT(
       f.size() == nb_element * nb_quadrature_points,
       "The vector f(" << f.getID() << ") has not the good size. (" << f.size()
                       << "!=" << nb_quadrature_points * nb_element << ")");
   AKANTU_DEBUG_ASSERT(f.getNbComponent() == 1,
                       "The vector f("
                           << f.getID()
                           << ") has not the good number of component.");
 #endif
 
   Real integral = fe_engine::details::IntegrateScalarHelper<kind>::call(
       integrator, f, type, ghost_type, filter_elements);
   AKANTU_DEBUG_OUT();
   return integral;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct IntegrateScalarOnOneElementHelper {};
 
 #define INTEGRATE(type)                                                        \
   res = integrator.template integrate<type>(f, index, ghost_type);
 
 #define AKANTU_SPECIALIZE_INTEGRATE_SCALAR_ON_ONE_ELEMENT_HELPER(kind)         \
   template <> struct IntegrateScalarOnOneElementHelper<kind> {                 \
     template <class I>                                                         \
     static Real call(const I & integrator, const Vector<Real> & f,             \
                      const ElementType & type, UInt index,                     \
                      const GhostType & ghost_type) {                           \
       Real res = 0.;                                                           \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTEGRATE, kind);                       \
       return res;                                                              \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(
         AKANTU_SPECIALIZE_INTEGRATE_SCALAR_ON_ONE_ELEMENT_HELPER)
 
 #undef AKANTU_SPECIALIZE_INTEGRATE_SCALAR_ON_ONE_ELEMENT_HELPER
 #undef INTEGRATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 Real FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::integrate(
     const Vector<Real> & f, const ElementType & type, UInt index,
     const GhostType & ghost_type) const {
 
   Real res = fe_engine::details::IntegrateScalarOnOneElementHelper<kind>::call(
       integrator, f, type, index, ghost_type);
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct IntegrateOnIntegrationPointsHelper {};
 
 #define INTEGRATE(type)                                                        \
   integrator.template integrateOnIntegrationPoints<type>(                      \
       f, intf, nb_degree_of_freedom, ghost_type, filter_elements);
 
 #define AKANTU_SPECIALIZE_INTEGRATE_ON_INTEGRATION_POINTS_HELPER(kind)         \
   template <> struct IntegrateOnIntegrationPointsHelper<kind> {                \
     template <class I>                                                         \
     static void call(const I & integrator, const Array<Real> & f,              \
                      Array<Real> & intf, UInt nb_degree_of_freedom,            \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<UInt> & filter_elements) {                    \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTEGRATE, kind);                       \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(
         AKANTU_SPECIALIZE_INTEGRATE_ON_INTEGRATION_POINTS_HELPER)
 
 #undef AKANTU_SPECIALIZE_INTEGRATE_ON_INTEGRATION_POINTS_HELPER
 #undef INTEGRATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     integrateOnIntegrationPoints(const Array<Real> & f, Array<Real> & intf,
                                  UInt nb_degree_of_freedom,
                                  const ElementType & type,
                                  const GhostType & ghost_type,
                                  const Array<UInt> & filter_elements) const {
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
     nb_element = filter_elements.size();
   UInt nb_quadrature_points = getNbIntegrationPoints(type);
 #ifndef AKANTU_NDEBUG
   //   std::stringstream sstr; sstr << ghost_type;
   //   AKANTU_DEBUG_ASSERT(sstr.str() == nablauq.getTag(),
   //                  "The vector " << nablauq.getID() << " is not taged " <<
   //                  ghost_type);
 
   AKANTU_DEBUG_ASSERT(f.size() == nb_element * nb_quadrature_points,
                       "The vector f(" << f.getID() << " size " << f.size()
                                       << ") has not the good size ("
                                       << nb_element << ").");
   AKANTU_DEBUG_ASSERT(f.getNbComponent() == nb_degree_of_freedom,
                       "The vector f("
                           << f.getID()
                           << ") has not the good number of component.");
   AKANTU_DEBUG_ASSERT(intf.getNbComponent() == nb_degree_of_freedom,
                       "The vector intf("
                           << intf.getID()
                           << ") has not the good number of component.");
 #endif
 
   intf.resize(nb_element * nb_quadrature_points);
   fe_engine::details::IntegrateOnIntegrationPointsHelper<kind>::call(
       integrator, f, intf, nb_degree_of_freedom, type, ghost_type,
       filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct InterpolateOnIntegrationPointsHelper {
       template <class S>
       static void call(const S &, const Array<Real> &, Array<Real> &,
                        const UInt, const ElementType &, const GhostType &,
                        const Array<UInt> &) {
-        AKANTU_DEBUG_TO_IMPLEMENT();
+        AKANTU_TO_IMPLEMENT();
       }
     };
 
 #define INTERPOLATE(type)                                                      \
   shape_functions.template interpolateOnIntegrationPoints<type>(               \
       u, uq, nb_degree_of_freedom, ghost_type, filter_elements);
 
 #define AKANTU_SPECIALIZE_INTERPOLATE_ON_INTEGRATION_POINTS_HELPER(kind)       \
   template <> struct InterpolateOnIntegrationPointsHelper<kind> {              \
     template <class S>                                                         \
     static void call(const S & shape_functions, const Array<Real> & u,         \
                      Array<Real> & uq, const UInt nb_degree_of_freedom,        \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<UInt> & filter_elements) {                    \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTERPOLATE, kind);                     \
     }                                                                          \
   };
     AKANTU_BOOST_ALL_KIND_LIST(
         AKANTU_SPECIALIZE_INTERPOLATE_ON_INTEGRATION_POINTS_HELPER,
         AKANTU_FE_ENGINE_LIST_INTERPOLATE_ON_INTEGRATION_POINTS)
 
 #undef AKANTU_SPECIALIZE_INTERPOLATE_ON_INTEGRATION_POINTS_HELPER
 #undef INTERPOLATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     interpolateOnIntegrationPoints(const Array<Real> & u, Array<Real> & uq,
                                    const UInt nb_degree_of_freedom,
                                    const ElementType & type,
                                    const GhostType & ghost_type,
                                    const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_points =
       shape_functions.getIntegrationPoints(type, ghost_type).cols();
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
     nb_element = filter_elements.size();
 #ifndef AKANTU_NDEBUG
 
   AKANTU_DEBUG_ASSERT(u.size() == mesh.getNbNodes(),
                       "The vector u(" << u.getID()
                                       << ") has not the good size.");
   AKANTU_DEBUG_ASSERT(u.getNbComponent() == nb_degree_of_freedom,
                       "The vector u("
                           << u.getID()
                           << ") has not the good number of component.");
   AKANTU_DEBUG_ASSERT(uq.getNbComponent() == nb_degree_of_freedom,
                       "The vector uq("
                           << uq.getID()
                           << ") has not the good number of component.");
 #endif
 
   uq.resize(nb_element * nb_points);
 
   fe_engine::details::InterpolateOnIntegrationPointsHelper<kind>::call(
       shape_functions, u, uq, nb_degree_of_freedom, type, ghost_type,
       filter_elements);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     interpolateOnIntegrationPoints(
         const Array<Real> & u, ElementTypeMapArray<Real> & uq,
         const ElementTypeMapArray<UInt> * filter_elements) const {
   AKANTU_DEBUG_IN();
 
   const Array<UInt> * filter = nullptr;
 
   for (auto ghost_type : ghost_types) {
     for (auto & type : uq.elementTypes(_all_dimensions, ghost_type, kind)) {
       UInt nb_quad_per_element = getNbIntegrationPoints(type, ghost_type);
 
       UInt nb_element = 0;
 
       if (filter_elements) {
         filter = &((*filter_elements)(type, ghost_type));
         nb_element = filter->size();
       } else {
         filter = &empty_filter;
         nb_element = mesh.getNbElement(type, ghost_type);
       }
 
       UInt nb_tot_quad = nb_quad_per_element * nb_element;
 
       Array<Real> & quad = uq(type, ghost_type);
       quad.resize(nb_tot_quad);
 
       interpolateOnIntegrationPoints(u, quad, quad.getNbComponent(), type,
                                      ghost_type, *filter);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ComputeBtDHelper {};
 
 #define COMPUTE_BTD(type)                                                      \
   shape_functions.template computeBtD<type>(Ds, BtDs, ghost_type,              \
                                             filter_elements);
 
 #define AKANTU_SPECIALIZE_COMPUTE_BtD_HELPER(kind)                             \
   template <> struct ComputeBtDHelper<kind> {                                  \
     template <class S>                                                         \
     static void call(const S & shape_functions, const Array<Real> & Ds,        \
                      Array<Real> & BtDs, const ElementType & type,             \
                      const GhostType & ghost_type,                             \
                      const Array<UInt> & filter_elements) {                    \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(COMPUTE_BTD, kind);                     \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_COMPUTE_BtD_HELPER)
 
 #undef AKANTU_SPECIALIZE_COMPUTE_BtD_HELPER
 #undef COMPUTE_BTD
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::computeBtD(
     const Array<Real> & Ds, Array<Real> & BtDs, const ElementType & type,
     const GhostType & ghost_type, const Array<UInt> & filter_elements) const {
   fe_engine::details::ComputeBtDHelper<kind>::call(
       shape_functions, Ds, BtDs, type, ghost_type, filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ComputeBtDBHelper {};
 
 #define COMPUTE_BTDB(type)                                                     \
   shape_functions.template computeBtDB<type>(Ds, BtDBs, order_d, ghost_type,   \
                                              filter_elements);
 
 #define AKANTU_SPECIALIZE_COMPUTE_BtDB_HELPER(kind)                            \
   template <> struct ComputeBtDBHelper<kind> {                                 \
     template <class S>                                                         \
     static void call(const S & shape_functions, const Array<Real> & Ds,        \
                      Array<Real> & BtDBs, UInt order_d,                        \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<UInt> & filter_elements) {                    \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(COMPUTE_BTDB, kind);                    \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_COMPUTE_BtDB_HELPER)
 
 #undef AKANTU_SPECIALIZE_COMPUTE_BtDB_HELPER
 #undef COMPUTE_BTDB
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::computeBtDB(
     const Array<Real> & Ds, Array<Real> & BtDBs, UInt order_d,
     const ElementType & type, const GhostType & ghost_type,
     const Array<UInt> & filter_elements) const {
   fe_engine::details::ComputeBtDBHelper<kind>::call(
       shape_functions, Ds, BtDBs, order_d, type, ghost_type, filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeIntegrationPointsCoordinates(
         ElementTypeMapArray<Real> & quadrature_points_coordinates,
         const ElementTypeMapArray<UInt> * filter_elements) const {
 
   const Array<Real> & nodes_coordinates = mesh.getNodes();
 
   interpolateOnIntegrationPoints(
       nodes_coordinates, quadrature_points_coordinates, filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeIntegrationPointsCoordinates(
         Array<Real> & quadrature_points_coordinates, const ElementType & type,
         const GhostType & ghost_type,
         const Array<UInt> & filter_elements) const {
 
   const Array<Real> & nodes_coordinates = mesh.getNodes();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   interpolateOnIntegrationPoints(
       nodes_coordinates, quadrature_points_coordinates, spatial_dimension, type,
       ghost_type, filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     initElementalFieldInterpolationFromIntegrationPoints(
         const ElementTypeMapArray<Real> & interpolation_points_coordinates,
         ElementTypeMapArray<Real> & interpolation_points_coordinates_matrices,
         ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
         const ElementTypeMapArray<UInt> * element_filter) const {
 
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = this->mesh.getSpatialDimension();
 
   ElementTypeMapArray<Real> quadrature_points_coordinates(
       "quadrature_points_coordinates_for_interpolation", getID(),
       getMemoryID());
 
   quadrature_points_coordinates.initialize(*this,
                                            _nb_component = spatial_dimension);
 
   computeIntegrationPointsCoordinates(quadrature_points_coordinates,
                                       element_filter);
   shape_functions.initElementalFieldInterpolationFromIntegrationPoints(
       interpolation_points_coordinates,
       interpolation_points_coordinates_matrices,
       quad_points_coordinates_inv_matrices, quadrature_points_coordinates,
       element_filter);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     interpolateElementalFieldFromIntegrationPoints(
         const ElementTypeMapArray<Real> & field,
         const ElementTypeMapArray<Real> & interpolation_points_coordinates,
         ElementTypeMapArray<Real> & result, const GhostType ghost_type,
         const ElementTypeMapArray<UInt> * element_filter) const {
 
   ElementTypeMapArray<Real> interpolation_points_coordinates_matrices(
       "interpolation_points_coordinates_matrices", id, memory_id);
   ElementTypeMapArray<Real> quad_points_coordinates_inv_matrices(
       "quad_points_coordinates_inv_matrices", id, memory_id);
 
   initElementalFieldInterpolationFromIntegrationPoints(
       interpolation_points_coordinates,
       interpolation_points_coordinates_matrices,
       quad_points_coordinates_inv_matrices, element_filter);
 
   interpolateElementalFieldFromIntegrationPoints(
       field, interpolation_points_coordinates_matrices,
       quad_points_coordinates_inv_matrices, result, ghost_type, element_filter);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     interpolateElementalFieldFromIntegrationPoints(
         const ElementTypeMapArray<Real> & field,
         const ElementTypeMapArray<Real> &
             interpolation_points_coordinates_matrices,
         const ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
         ElementTypeMapArray<Real> & result, const GhostType ghost_type,
         const ElementTypeMapArray<UInt> * element_filter) const {
 
   shape_functions.interpolateElementalFieldFromIntegrationPoints(
       field, interpolation_points_coordinates_matrices,
       quad_points_coordinates_inv_matrices, result, ghost_type, element_filter);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct InterpolateHelper {
       template <class S>
       static void call(const S &, const Vector<Real> &, UInt,
                        const Matrix<Real> &, Vector<Real> &,
                        const ElementType &, const GhostType &) {
-        AKANTU_DEBUG_TO_IMPLEMENT();
+        AKANTU_TO_IMPLEMENT();
       }
     };
 
 #define INTERPOLATE(type)                                                      \
   shape_functions.template interpolate<type>(                                  \
       real_coords, element, nodal_values, interpolated, ghost_type);
 
 #define AKANTU_SPECIALIZE_INTERPOLATE_HELPER(kind)                             \
   template <> struct InterpolateHelper<kind> {                                 \
     template <class S>                                                         \
     static void call(const S & shape_functions,                                \
                      const Vector<Real> & real_coords, UInt element,           \
                      const Matrix<Real> & nodal_values,                        \
                      Vector<Real> & interpolated, const ElementType & type,    \
                      const GhostType & ghost_type) {                           \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTERPOLATE, kind);                     \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_INTERPOLATE_HELPER,
                                AKANTU_FE_ENGINE_LIST_INTERPOLATE)
 
 #undef AKANTU_SPECIALIZE_INTERPOLATE_HELPER
 #undef INTERPOLATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::interpolate(
     const Vector<Real> & real_coords, const Matrix<Real> & nodal_values,
     Vector<Real> & interpolated, const Element & element) const {
 
   AKANTU_DEBUG_IN();
 
   fe_engine::details::InterpolateHelper<kind>::call(
       shape_functions, real_coords, element.element, nodal_values, interpolated,
       element.type, element.ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeNormalsOnIntegrationPoints(const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   computeNormalsOnIntegrationPoints(mesh.getNodes(), ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeNormalsOnIntegrationPoints(const Array<Real> & field,
                                       const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   //  Real * coord = mesh.getNodes().storage();
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   // allocate the normal arrays
   for (auto & type : mesh.elementTypes(element_dimension, ghost_type, kind)) {
     UInt size = mesh.getNbElement(type, ghost_type);
     if (normals_on_integration_points.exists(type, ghost_type)) {
       normals_on_integration_points(type, ghost_type).resize(size);
     } else {
       normals_on_integration_points.alloc(size, spatial_dimension, type,
                                           ghost_type);
     }
   }
 
   // loop over the type to build the normals
   for (auto & type : mesh.elementTypes(element_dimension, ghost_type, kind)) {
     Array<Real> & normals_on_quad =
         normals_on_integration_points(type, ghost_type);
     computeNormalsOnIntegrationPoints(field, normals_on_quad, type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ComputeNormalsOnIntegrationPoints {
       template <template <ElementKind, class> class I,
                 template <ElementKind> class S, ElementKind k, class IOF>
       static void call(const FEEngineTemplate<I, S, k, IOF> &,
                        const Array<Real> &, Array<Real> &, const ElementType &,
                        const GhostType &) {
-        AKANTU_DEBUG_TO_IMPLEMENT();
+        AKANTU_TO_IMPLEMENT();
       }
     };
 
 #define COMPUTE_NORMALS_ON_INTEGRATION_POINTS(type)                            \
   fem.template computeNormalsOnIntegrationPoints<type>(field, normal,          \
                                                        ghost_type);
 
 #define AKANTU_SPECIALIZE_COMPUTE_NORMALS_ON_INTEGRATION_POINTS(kind)          \
   template <> struct ComputeNormalsOnIntegrationPoints<kind> {                 \
     template <template <ElementKind, class> class I,                           \
               template <ElementKind> class S, ElementKind k, class IOF>        \
     static void call(const FEEngineTemplate<I, S, k, IOF> & fem,               \
                      const Array<Real> & field, Array<Real> & normal,          \
                      const ElementType & type, const GhostType & ghost_type) { \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(COMPUTE_NORMALS_ON_INTEGRATION_POINTS,  \
                                        kind);                                  \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(
         AKANTU_SPECIALIZE_COMPUTE_NORMALS_ON_INTEGRATION_POINTS,
         AKANTU_FE_ENGINE_LIST_COMPUTE_NORMALS_ON_INTEGRATION_POINTS)
 
 #undef AKANTU_SPECIALIZE_COMPUTE_NORMALS_ON_INTEGRATION_POINTS
 #undef COMPUTE_NORMALS_ON_INTEGRATION_POINTS
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeNormalsOnIntegrationPoints(const Array<Real> & field,
                                       Array<Real> & normal,
                                       const ElementType & type,
                                       const GhostType & ghost_type) const {
   fe_engine::details::ComputeNormalsOnIntegrationPoints<kind>::call(
       *this, field, normal, type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeNormalsOnIntegrationPoints(const Array<Real> & field,
                                       Array<Real> & normal,
                                       const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   if (type == _point_1) {
     computeNormalsOnIntegrationPointsPoint1(field, normal, ghost_type);
     return;
   }
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_points = getNbIntegrationPoints(type, ghost_type);
 
   UInt nb_element = mesh.getConnectivity(type, ghost_type).size();
   normal.resize(nb_element * nb_points);
   Array<Real>::matrix_iterator normals_on_quad =
       normal.begin_reinterpret(spatial_dimension, nb_points, nb_element);
   Array<Real> f_el(0, spatial_dimension * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, field, f_el, type, ghost_type);
 
   const Matrix<Real> & quads =
       integrator.template getIntegrationPoints<type>(ghost_type);
 
   Array<Real>::matrix_iterator f_it =
       f_el.begin(spatial_dimension, nb_nodes_per_element);
 
   for (UInt elem = 0; elem < nb_element; ++elem) {
     ElementClass<type>::computeNormalsOnNaturalCoordinates(quads, *f_it,
                                                            *normals_on_quad);
     ++normals_on_quad;
     ++f_it;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 template <ElementKind kind> struct InverseMapHelper {
   template <class S>
   static void
   call(const S & /*shape_functions*/, const Vector<Real> & /*real_coords*/,
        UInt /*element*/, const ElementType & /*type*/,
        Vector<Real> & /*natural_coords*/, const GhostType & /*ghost_type*/) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 };
 
 #define INVERSE_MAP(type)                                                      \
   shape_functions.template inverseMap<type>(real_coords, element,              \
                                             natural_coords, ghost_type);
 
 #define AKANTU_SPECIALIZE_INVERSE_MAP_HELPER(kind)                             \
   template <> struct InverseMapHelper<kind> {                                  \
     template <class S>                                                         \
     static void call(const S & shape_functions,                                \
                      const Vector<Real> & real_coords, UInt element,           \
                      const ElementType & type, Vector<Real> & natural_coords,  \
                      const GhostType & ghost_type) {                           \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INVERSE_MAP, kind);                     \
     }                                                                          \
   };
 
 AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_INVERSE_MAP_HELPER,
                            AKANTU_FE_ENGINE_LIST_INVERSE_MAP)
 
 #undef AKANTU_SPECIALIZE_INVERSE_MAP_HELPER
 #undef INVERSE_MAP
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::inverseMap(
     const Vector<Real> & real_coords, UInt element, const ElementType & type,
     Vector<Real> & natural_coords, const GhostType & ghost_type) const {
 
   AKANTU_DEBUG_IN();
 
   InverseMapHelper<kind>::call(shape_functions, real_coords, element, type,
                                natural_coords, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ContainsHelper {
       template <class S>
       static void call(const S &, const Vector<Real> &, UInt,
                        const ElementType &, const GhostType &) {
-        AKANTU_DEBUG_TO_IMPLEMENT();
+        AKANTU_TO_IMPLEMENT();
       }
     };
 
 #define CONTAINS(type)                                                         \
   contain = shape_functions.template contains<type>(real_coords, element,      \
                                                     ghost_type);
 
 #define AKANTU_SPECIALIZE_CONTAINS_HELPER(kind)                                \
   template <> struct ContainsHelper<kind> {                                    \
     template <template <ElementKind> class S, ElementKind k>                   \
     static bool call(const S<k> & shape_functions,                             \
                      const Vector<Real> & real_coords, UInt element,           \
                      const ElementType & type, const GhostType & ghost_type) { \
       bool contain = false;                                                    \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(CONTAINS, kind);                        \
       return contain;                                                          \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_CONTAINS_HELPER,
                                AKANTU_FE_ENGINE_LIST_CONTAINS)
 
 #undef AKANTU_SPECIALIZE_CONTAINS_HELPER
 #undef CONTAINS
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline bool FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::contains(
     const Vector<Real> & real_coords, UInt element, const ElementType & type,
     const GhostType & ghost_type) const {
   return fe_engine::details::ContainsHelper<kind>::call(
       shape_functions, real_coords, element, type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ComputeShapesHelper {
       template <class S>
       static void call(const S &, const Vector<Real> &, UInt, const ElementType,
                        Vector<Real> &, const GhostType &) {
-        AKANTU_DEBUG_TO_IMPLEMENT();
+        AKANTU_TO_IMPLEMENT();
       }
     };
 
 #define COMPUTE_SHAPES(type)                                                   \
   shape_functions.template computeShapes<type>(real_coords, element, shapes,   \
                                                ghost_type);
 
 #define AKANTU_SPECIALIZE_COMPUTE_SHAPES_HELPER(kind)                          \
   template <> struct ComputeShapesHelper<kind> {                               \
     template <class S>                                                         \
     static void call(const S & shape_functions,                                \
                      const Vector<Real> & real_coords, UInt element,           \
                      const ElementType type, Vector<Real> & shapes,            \
                      const GhostType & ghost_type) {                           \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(COMPUTE_SHAPES, kind);                  \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_COMPUTE_SHAPES_HELPER,
                                AKANTU_FE_ENGINE_LIST_COMPUTE_SHAPES)
 
 #undef AKANTU_SPECIALIZE_COMPUTE_SHAPES_HELPER
 #undef COMPUTE_SHAPES
   } // namespace details
 } // namespace fe_engine
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::computeShapes(
     const Vector<Real> & real_coords, UInt element, const ElementType & type,
     Vector<Real> & shapes, const GhostType & ghost_type) const {
 
   AKANTU_DEBUG_IN();
 
   fe_engine::details::ComputeShapesHelper<kind>::call(
       shape_functions, real_coords, element, type, shapes, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ComputeShapeDerivativesHelper {
       template <class S>
       static void call(__attribute__((unused)) const S & shape_functions,
                        __attribute__((unused)) const Vector<Real> & real_coords,
                        __attribute__((unused)) UInt element,
                        __attribute__((unused)) const ElementType type,
                        __attribute__((unused)) Matrix<Real> & shape_derivatives,
                        __attribute__((unused)) const GhostType & ghost_type) {
-        AKANTU_DEBUG_TO_IMPLEMENT();
+        AKANTU_TO_IMPLEMENT();
       }
     };
 
 #define COMPUTE_SHAPE_DERIVATIVES(type)                                        \
   Matrix<Real> coords_mat(real_coords.storage(), shape_derivatives.rows(), 1); \
   Tensor3<Real> shapesd_tensor(shape_derivatives.storage(),                    \
                                shape_derivatives.rows(),                       \
                                shape_derivatives.cols(), 1);                   \
   shape_functions.template computeShapeDerivatives<type>(                      \
       coords_mat, element, shapesd_tensor, ghost_type);
 
 #define AKANTU_SPECIALIZE_COMPUTE_SHAPE_DERIVATIVES_HELPER(kind)               \
   template <> struct ComputeShapeDerivativesHelper<kind> {                     \
     template <class S>                                                         \
     static void call(const S & shape_functions,                                \
                      const Vector<Real> & real_coords, UInt element,           \
                      const ElementType type, Matrix<Real> & shape_derivatives, \
                      const GhostType & ghost_type) {                           \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(COMPUTE_SHAPE_DERIVATIVES, kind);       \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(
         AKANTU_SPECIALIZE_COMPUTE_SHAPE_DERIVATIVES_HELPER,
         AKANTU_FE_ENGINE_LIST_COMPUTE_SHAPES_DERIVATIVES)
 
 #undef AKANTU_SPECIALIZE_COMPUTE_SHAPE_DERIVATIVES_HELPER
 #undef COMPUTE_SHAPE_DERIVATIVES
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::computeShapeDerivatives(
     const Vector<Real> & real_coords, UInt element, const ElementType & type,
     Matrix<Real> & shape_derivatives, const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   fe_engine::details::ComputeShapeDerivativesHelper<kind>::call(
       shape_functions, real_coords, element, type, shape_derivatives,
       ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct GetNbIntegrationPointsHelper {};
 
 #define GET_NB_INTEGRATION_POINTS(type)                                        \
   nb_quad_points = integrator.template getNbIntegrationPoints<type>(ghost_type);
 
 #define AKANTU_SPECIALIZE_GET_NB_INTEGRATION_POINTS_HELPER(kind)               \
   template <> struct GetNbIntegrationPointsHelper<kind> {                      \
     template <template <ElementKind, class> class I, ElementKind k, class IOF> \
     static UInt call(const I<k, IOF> & integrator, const ElementType type,     \
                      const GhostType & ghost_type) {                           \
       UInt nb_quad_points = 0;                                                 \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(GET_NB_INTEGRATION_POINTS, kind);       \
       return nb_quad_points;                                                   \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_GET_NB_INTEGRATION_POINTS_HELPER)
 
 #undef AKANTU_SPECIALIZE_GET_NB_INTEGRATION_POINTS_HELPER
 #undef GET_NB_INTEGRATION
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline UInt
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::getNbIntegrationPoints(
     const ElementType & type, const GhostType & ghost_type) const {
   return fe_engine::details::GetNbIntegrationPointsHelper<kind>::call(
       integrator, type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct GetShapesHelper {};
 
 #define GET_SHAPES(type) ret = &(shape_functions.getShapes(type, ghost_type));
 
 #define AKANTU_SPECIALIZE_GET_SHAPES_HELPER(kind)                              \
   template <> struct GetShapesHelper<kind> {                                   \
     template <class S>                                                         \
     static const Array<Real> & call(const S & shape_functions,                 \
                                     const ElementType type,                    \
                                     const GhostType & ghost_type) {            \
       const Array<Real> * ret = NULL;                                          \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(GET_SHAPES, kind);                      \
       return *ret;                                                             \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_GET_SHAPES_HELPER)
 
 #undef AKANTU_SPECIALIZE_GET_SHAPES_HELPER
 #undef GET_SHAPES
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline const Array<Real> &
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::getShapes(
     const ElementType & type, const GhostType & ghost_type,
     __attribute__((unused)) UInt id) const {
   return fe_engine::details::GetShapesHelper<kind>::call(shape_functions, type,
                                                          ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct GetShapesDerivativesHelper {
       template <template <ElementKind> class S, ElementKind k>
       static const Array<Real> & call(const S<k> &, const ElementType &,
                                       const GhostType &, UInt) {
-        AKANTU_DEBUG_TO_IMPLEMENT();
+        AKANTU_TO_IMPLEMENT();
       }
     };
 
 #define GET_SHAPES_DERIVATIVES(type)                                           \
   ret = &(shape_functions.getShapesDerivatives(type, ghost_type));
 
 #define AKANTU_SPECIALIZE_GET_SHAPES_DERIVATIVES_HELPER(kind)                  \
   template <> struct GetShapesDerivativesHelper<kind> {                        \
     template <template <ElementKind> class S, ElementKind k>                   \
     static const Array<Real> &                                                 \
     call(const S<k> & shape_functions, const ElementType type,                 \
          const GhostType & ghost_type, __attribute__((unused)) UInt id) {      \
       const Array<Real> * ret = NULL;                                          \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(GET_SHAPES_DERIVATIVES, kind);          \
       return *ret;                                                             \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_GET_SHAPES_DERIVATIVES_HELPER,
                                AKANTU_FE_ENGINE_LIST_GET_SHAPES_DERIVATIVES)
 
 #undef AKANTU_SPECIALIZE_GET_SHAPE_DERIVATIVES_HELPER
 #undef GET_SHAPES_DERIVATIVES
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline const Array<Real> &
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::getShapesDerivatives(
     const ElementType & type, const GhostType & ghost_type,
     __attribute__((unused)) UInt id) const {
   return fe_engine::details::GetShapesDerivativesHelper<kind>::call(
       shape_functions, type, ghost_type, id);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct GetIntegrationPointsHelper {};
 
 #define GET_INTEGRATION_POINTS(type)                                           \
   ret = &(integrator.template getIntegrationPoints<type>(ghost_type));
 
 #define AKANTU_SPECIALIZE_GET_INTEGRATION_POINTS_HELPER(kind)                  \
   template <> struct GetIntegrationPointsHelper<kind> {                        \
     template <template <ElementKind, class> class I, ElementKind k, class IOF> \
     static const Matrix<Real> & call(const I<k, IOF> & integrator,             \
                                      const ElementType type,                   \
                                      const GhostType & ghost_type) {           \
       const Matrix<Real> * ret = NULL;                                         \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(GET_INTEGRATION_POINTS, kind);          \
       return *ret;                                                             \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_GET_INTEGRATION_POINTS_HELPER)
 
 #undef AKANTU_SPECIALIZE_GET_INTEGRATION_POINTS_HELPER
 #undef GET_INTEGRATION_POINTS
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline const Matrix<Real> &
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::getIntegrationPoints(
     const ElementType & type, const GhostType & ghost_type) const {
   return fe_engine::details::GetIntegrationPointsHelper<kind>::call(
       integrator, type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::printself(
     std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "FEEngineTemplate [" << std::endl;
   stream << space << " + parent [" << std::endl;
   FEEngine::printself(stream, indent + 3);
   stream << space << "   ]" << std::endl;
   stream << space << " + shape functions [" << std::endl;
   shape_functions.printself(stream, indent + 3);
   stream << space << "   ]" << std::endl;
   stream << space << " + integrator [" << std::endl;
   integrator.printself(stream, indent + 3);
   stream << space << "   ]" << std::endl;
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::onElementsAdded(
     const Array<Element> & new_elements, const NewElementsEvent &) {
   integrator.onElementsAdded(new_elements);
   shape_functions.onElementsAdded(new_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::onElementsRemoved(
     const Array<Element> &, const ElementTypeMapArray<UInt> &,
     const RemovedElementsEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::onElementsChanged(
     const Array<Element> &, const Array<Element> &,
     const ElementTypeMapArray<UInt> &, const ChangedElementsEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeNormalsOnIntegrationPointsPoint1(
         const Array<Real> &, Array<Real> & normal,
         const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(mesh.getSpatialDimension() == 1,
                       "Mesh dimension must be 1 to compute normals on points!");
   const ElementType type = _point_1;
   UInt spatial_dimension = mesh.getSpatialDimension();
   // UInt nb_nodes_per_element  = Mesh::getNbNodesPerElement(type);
   UInt nb_points = getNbIntegrationPoints(type, ghost_type);
 
   UInt nb_element = mesh.getConnectivity(type, ghost_type).size();
   normal.resize(nb_element * nb_points);
   Array<Real>::matrix_iterator normals_on_quad =
       normal.begin_reinterpret(spatial_dimension, nb_points, nb_element);
   const Array<std::vector<Element>> & segments =
       mesh.getElementToSubelement(type, ghost_type);
   const Array<Real> & coords = mesh.getNodes();
 
   const Mesh * mesh_segment;
   if (mesh.isMeshFacets())
     mesh_segment = &(mesh.getMeshParent());
   else
     mesh_segment = &mesh;
 
   for (UInt elem = 0; elem < nb_element; ++elem) {
     UInt nb_segment = segments(elem).size();
 
     AKANTU_DEBUG_ASSERT(
         nb_segment > 0,
         "Impossible to compute a normal on a point connected to 0 segments");
 
     Real normal_value = 1;
     if (nb_segment == 1) {
       const Element & segment = segments(elem)[0];
       const Array<UInt> & segment_connectivity =
           mesh_segment->getConnectivity(segment.type, segment.ghost_type);
       // const Vector<UInt> & segment_points =
       // segment_connectivity.begin(Mesh::getNbNodesPerElement(segment.type))[segment.element];
       Real difference;
       if (segment_connectivity(0) == elem) {
         difference = coords(elem) - coords(segment_connectivity(1));
       } else {
         difference = coords(elem) - coords(segment_connectivity(0));
       }
       normal_value = difference / std::abs(difference);
     }
 
     for (UInt n(0); n < nb_points; ++n) {
       (*normals_on_quad)(0, n) = normal_value;
     }
     ++normals_on_quad;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/src/fe_engine/fe_engine_template_tmpl_struct.hh b/src/fe_engine/fe_engine_template_tmpl_struct.hh
index 8ffdd516f..2c1046745 100644
--- a/src/fe_engine/fe_engine_template_tmpl_struct.hh
+++ b/src/fe_engine/fe_engine_template_tmpl_struct.hh
@@ -1,101 +1,101 @@
 /**
  * @file   fe_engine_template_tmpl_struct.hh
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Sébastien Hartmann <sebastien.hartmann@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Jul 07 2014
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Template implementation of FEEngineTemplate for Structural Element
  * Kinds
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 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 "shape_structural.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, typename = void>
 struct AssembleFieldMatrixStructHelper {};
 
 template <ElementKind kind>
 struct AssembleFieldMatrixStructHelper<
     kind, typename std::enable_if<kind == _ek_structural>::type> {
   template <template <ElementKind, class> class I,
             template <ElementKind> class S, ElementKind k, class IOF>
   static void call(const FEEngineTemplate<I, S, k, IOF> & fem,
                    const Array<Real> & field_1, UInt nb_degree_of_freedom,
                    SparseMatrix & M, Array<Real> * n,
                    ElementTypeMapArray<Real> & rotation_mat,
                    const ElementType & type, const GhostType & ghost_type) {
 #define ASSEMBLE_MATRIX(type)                                                  \
   fem.template assembleFieldMatrix<type>(field_1, nb_degree_of_freedom, M, n,  \
                                          rotation_mat, ghost_type)
 
     AKANTU_BOOST_KIND_ELEMENT_SWITCH(ASSEMBLE_MATRIX, _ek_structural);
 #undef ASSEMBLE_MATRIX
   }
 };
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::assembleFieldMatrix(
     const Array<Real> & field_1, UInt nb_degree_of_freedom, SparseMatrix & M,
     Array<Real> * n, ElementTypeMapArray<Real> & rotation_mat,
     const ElementType & type, const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   AssembleFieldMatrixStructHelper<kind>::template call(
       *this, field_1, nb_degree_of_freedom, M, n, rotation_mat, type,
       ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::computeShapesMatrix(
     const ElementType &, UInt, UInt, Array<Real> *,
     UInt, UInt, UInt, const bool,
     const GhostType &) const {
 
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 inline void
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::assembleFieldMatrix(
     const Array<Real> & , UInt , SparseMatrix &,
     Array<Real> * , ElementTypeMapArray<Real> & ,
     const GhostType & ) const {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
 }
 
 } // akantu
diff --git a/src/fe_engine/shape_cohesive.hh b/src/fe_engine/shape_cohesive.hh
index 5e61e7e2f..96e0867e9 100644
--- a/src/fe_engine/shape_cohesive.hh
+++ b/src/fe_engine/shape_cohesive.hh
@@ -1,183 +1,183 @@
 /**
  * @file   shape_cohesive.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue Feb 15 2011
  * @date last modification: Thu Oct 22 2015
  *
  * @brief  shape functions for cohesive elements description
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "aka_array.hh"
 #include "shape_lagrange.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SHAPE_COHESIVE_HH__
 #define __AKANTU_SHAPE_COHESIVE_HH__
 
 namespace akantu {
 
 struct CohesiveReduceFunctionMean {
   inline Real operator()(Real u_plus, Real u_minus) {
     return .5 * (u_plus + u_minus);
   }
 };
 
 struct CohesiveReduceFunctionOpening {
   inline Real operator()(Real u_plus, Real u_minus) {
     return (u_plus - u_minus);
   }
 };
 
 template <> class ShapeLagrange<_ek_cohesive> : public ShapeLagrangeBase {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   ShapeLagrange(const Mesh & mesh, const ID & id = "shape_cohesive",
                 const MemoryID & memory_id = 0);
 
   ~ShapeLagrange() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   inline void initShapeFunctions(const Array<Real> & nodes,
                                  const Matrix<Real> & integration_points,
                                  const ElementType & type,
                                  const GhostType & ghost_type);
 
   /// extract the nodal values and store them per element
   template <ElementType type, class ReduceFunction>
   void extractNodalToElementField(
       const Array<Real> & nodal_f, Array<Real> & elemental_f,
       const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const;
 
   /// computes the shape functions derivatives for given interpolation points
   template <ElementType type>
   void computeShapeDerivativesOnIntegrationPoints(
       const Array<Real> & nodes, const Matrix<Real> & integration_points,
       Array<Real> & shape_derivatives, const GhostType & ghost_type,
       const Array<UInt> & filter_elements = empty_filter) const;
 
   void computeShapeDerivativesOnIntegrationPoints(
       const Array<Real> & nodes, const Matrix<Real> & integration_points,
       Array<Real> & shape_derivatives, const ElementType & type,
       const GhostType & ghost_type,
       const Array<UInt> & filter_elements) const override;
 
   /// pre compute all shapes on the element integration points from natural
   /// coordinates
   template <ElementType type>
   void precomputeShapesOnIntegrationPoints(const Array<Real> & nodes,
                                            GhostType ghost_type);
 
   /// pre compute all shape derivatives on the element integration points from
   /// natural coordinates
   template <ElementType type>
   void precomputeShapeDerivativesOnIntegrationPoints(const Array<Real> & nodes,
                                                      GhostType ghost_type);
 
   /// interpolate nodal values on the integration points
   template <ElementType type, class ReduceFunction>
   void interpolateOnIntegrationPoints(
       const Array<Real> & u, Array<Real> & uq, UInt nb_degree_of_freedom,
       const GhostType ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const;
 
   template <ElementType type>
   void interpolateOnIntegrationPoints(
       const Array<Real> & u, Array<Real> & uq, UInt nb_degree_of_freedom,
       const GhostType ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const {
     interpolateOnIntegrationPoints<type, CohesiveReduceFunctionMean>(
         u, uq, nb_degree_of_freedom, ghost_type, filter_elements);
   }
 
   /// compute the gradient of u on the integration points in the natural
   /// coordinates
   template <ElementType type>
   void gradientOnIntegrationPoints(
       const Array<Real> & u, Array<Real> & nablauq, UInt nb_degree_of_freedom,
       GhostType ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const {
     variationOnIntegrationPoints<type, CohesiveReduceFunctionMean>(
         u, nablauq, nb_degree_of_freedom, ghost_type, filter_elements);
   }
 
   template <ElementType type>
   void computeBtD(const Array<Real> & /*Ds*/, Array<Real> & /*BtDs*/,
                   GhostType /*ghost_type*/,
                   const Array<UInt> & /*filter_elements*/) const {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   template <ElementType type>
   void computeBtDB(const Array<Real> & /*Ds*/, Array<Real> & /*BtDBs*/,
                    UInt /*order_d*/, GhostType /*ghost_type*/,
                    const Array<UInt> & /*filter_elements*/) const {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// compute the gradient of u on the integration points
   template <ElementType type, class ReduceFunction>
   void variationOnIntegrationPoints(
       const Array<Real> & u, Array<Real> & nablauq, UInt nb_degree_of_freedom,
       GhostType ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const;
 
   /// compute the normals to the field u on integration points
   template <ElementType type, class ReduceFunction>
   void computeNormalsOnIntegrationPoints(
       const Array<Real> & u, Array<Real> & normals_u,
       GhostType ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const;
 
   /// multiply a field by shape functions
   template <ElementType type>
   void fieldTimesShapes(__attribute__((unused)) const Array<Real> & field,
                         __attribute__((unused))
                         Array<Real> & fiedl_times_shapes,
                         __attribute__((unused)) GhostType ghost_type) const {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 };
 
 /// standard output stream operator
 template <class ShapeFunction>
 inline std::ostream & operator<<(std::ostream & stream,
                                  const ShapeCohesive<ShapeFunction> & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #include "shape_cohesive_inline_impl.cc"
 
 #endif /* __AKANTU_SHAPE_COHESIVE_HH__ */
diff --git a/src/fe_engine/shape_functions.hh b/src/fe_engine/shape_functions.hh
index 9386839a3..3d07d72bd 100644
--- a/src/fe_engine/shape_functions.hh
+++ b/src/fe_engine/shape_functions.hh
@@ -1,216 +1,216 @@
 /**
  * @file   shape_functions.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Oct 22 2015
  *
  * @brief  shape function class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "aka_memory.hh"
 #include "mesh.hh"
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SHAPE_FUNCTIONS_HH__
 #define __AKANTU_SHAPE_FUNCTIONS_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 class ShapeFunctions : protected Memory {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   ShapeFunctions(const Mesh & mesh, const ID & id = "shape",
                  const MemoryID & memory_id = 0);
   ~ShapeFunctions() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// function to print the contain of the class
   virtual void printself(std::ostream & stream, int indent = 0) const {
     std::string space;
     for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
       ;
     stream << space << "Shapes [" << std::endl;
     integration_points.printself(stream, indent + 1);
     // shapes.printself(stream, indent + 1);
     // shapes_derivatives.printself(stream, indent + 1);
     stream << space << "]" << std::endl;
   }
 
   /// set the integration points for a given element
   template <ElementType type>
   void setIntegrationPointsByType(const Matrix<Real> & integration_points,
                                   const GhostType & ghost_type);
 
   /// Build pre-computed matrices for interpolation of field form integration
   /// points at other given positions (interpolation_points)
   void initElementalFieldInterpolationFromIntegrationPoints(
       const ElementTypeMapArray<Real> & interpolation_points_coordinates,
       ElementTypeMapArray<Real> & interpolation_points_coordinates_matrices,
       ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
       const ElementTypeMapArray<Real> & quadrature_points_coordinates,
       const ElementTypeMapArray<UInt> * element_filter) const;
 
   /// Interpolate field at given position from given values of this field at
   /// integration points (field)
   /// using matrices precomputed with
   /// initElementalFieldInterplationFromIntegrationPoints
   void interpolateElementalFieldFromIntegrationPoints(
       const ElementTypeMapArray<Real> & field,
       const ElementTypeMapArray<Real> &
           interpolation_points_coordinates_matrices,
       const ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
       ElementTypeMapArray<Real> & result, const GhostType & ghost_type,
       const ElementTypeMapArray<UInt> * element_filter) const;
 
 protected:
   /// interpolate nodal values stored by element on the integration points
   template <ElementType type>
   void interpolateElementalFieldOnIntegrationPoints(
       const Array<Real> & u_el, Array<Real> & uq, const GhostType & ghost_type,
       const Array<Real> & shapes,
       const Array<UInt> & filter_elements = empty_filter) const;
 
   /// gradient of nodal values stored by element on the control points
   template <ElementType type>
   void gradientElementalFieldOnIntegrationPoints(
       const Array<Real> & u_el, Array<Real> & out_nablauq,
       const GhostType & ghost_type, const Array<Real> & shapes_derivatives,
       const Array<UInt> & filter_elements) const;
 
 protected:
   /// By element versions of non-templated eponym methods
   template <ElementType type>
   inline void interpolateElementalFieldFromIntegrationPoints(
       const Array<Real> & field,
       const Array<Real> & interpolation_points_coordinates_matrices,
       const Array<Real> & quad_points_coordinates_inv_matrices,
       ElementTypeMapArray<Real> & result, const GhostType & ghost_type,
       const Array<UInt> & element_filter) const;
 
   /// Interpolate field at given position from given values of this field at
   /// integration points (field)
   /// using matrices precomputed with
   /// initElementalFieldInterplationFromIntegrationPoints
   template <ElementType type>
   inline void initElementalFieldInterpolationFromIntegrationPoints(
       const Array<Real> & interpolation_points_coordinates,
       ElementTypeMapArray<Real> & interpolation_points_coordinates_matrices,
       ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
       const Array<Real> & quadrature_points_coordinates,
       const GhostType & ghost_type, const Array<UInt> & element_filter) const;
 
   /// build matrix for the interpolation of field form integration points
   template <ElementType type>
   inline void buildElementalFieldInterpolationMatrix(
       const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
       UInt integration_order =
           ElementClassProperty<type>::polynomial_degree) const;
 
   /// build the so called interpolation matrix (first collumn is 1, then the
   /// other collumns are the traansposed coordinates)
   inline void buildInterpolationMatrix(const Matrix<Real> & coordinates,
                                        Matrix<Real> & coordMatrix,
                                        UInt integration_order) const;
 
 public:
   virtual void onElementsAdded(const Array<Element> &) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
   virtual void onElementsRemoved(const Array<Element> &,
                                  const ElementTypeMapArray<UInt> &) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the size of the shapes returned by the element class
   static inline UInt getShapeSize(const ElementType & type);
 
   /// get the size of the shapes derivatives returned by the element class
   static inline UInt getShapeDerivativesSize(const ElementType & type);
 
   inline const Matrix<Real> &
   getIntegrationPoints(const ElementType & type,
                        const GhostType & ghost_type) const {
     return integration_points(type, ghost_type);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get a the shapes vector
   inline const Array<Real> &
   getShapes(const ElementType & el_type,
             const GhostType & ghost_type = _not_ghost) const;
 
   /// get a the shapes derivatives vector
   inline const Array<Real> &
   getShapesDerivatives(const ElementType & el_type,
                        const GhostType & ghost_type = _not_ghost) const;
 
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// shape functions for all elements
   ElementTypeMapArray<Real, InterpolationType> shapes;
 
   /// shape functions derivatives for all elements
   ElementTypeMapArray<Real, InterpolationType> shapes_derivatives;
 
   /// associated mesh
   const Mesh & mesh;
 
   /// shape functions for all elements
   ElementTypeMap<Matrix<Real>> integration_points;
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream,
                                  const ShapeFunctions & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 #include "shape_functions_inline_impl.cc"
 
 #endif /* __AKANTU_SHAPE_FUNCTIONS_HH__ */
diff --git a/src/fe_engine/shape_functions_inline_impl.cc b/src/fe_engine/shape_functions_inline_impl.cc
index 8774aa1b1..be1d9b5fc 100644
--- a/src/fe_engine/shape_functions_inline_impl.cc
+++ b/src/fe_engine/shape_functions_inline_impl.cc
@@ -1,402 +1,402 @@
 /**
  * @file   shape_functions_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Oct 27 2010
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  ShapeFunctions inline implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "fe_engine.hh"
 #include "shape_functions.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SHAPE_FUNCTIONS_INLINE_IMPL_CC__
 #define __AKANTU_SHAPE_FUNCTIONS_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline const Array<Real> &
 ShapeFunctions::getShapes(const ElementType & el_type,
                           const GhostType & ghost_type) const {
   return shapes(FEEngine::getInterpolationType(el_type), ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Array<Real> &
 ShapeFunctions::getShapesDerivatives(const ElementType & el_type,
                                      const GhostType & ghost_type) const {
   return shapes_derivatives(FEEngine::getInterpolationType(el_type),
                             ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt ShapeFunctions::getShapeSize(const ElementType & type) {
   AKANTU_DEBUG_IN();
 
   UInt shape_size = 0;
 #define GET_SHAPE_SIZE(type) shape_size = ElementClass<type>::getShapeSize()
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_SHAPE_SIZE); // ,
 
 #undef GET_SHAPE_SIZE
 
   AKANTU_DEBUG_OUT();
   return shape_size;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt ShapeFunctions::getShapeDerivativesSize(const ElementType & type) {
   AKANTU_DEBUG_IN();
 
   UInt shape_derivatives_size = 0;
 #define GET_SHAPE_DERIVATIVES_SIZE(type)                                       \
   shape_derivatives_size = ElementClass<type>::getShapeDerivativesSize()
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_SHAPE_DERIVATIVES_SIZE); // ,
 
 #undef GET_SHAPE_DERIVATIVES_SIZE
 
   AKANTU_DEBUG_OUT();
   return shape_derivatives_size;
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void ShapeFunctions::setIntegrationPointsByType(const Matrix<Real> & points,
                                                 const GhostType & ghost_type) {
   if (not this->integration_points.exists(type, ghost_type))
     this->integration_points(type, ghost_type).shallowCopy(points);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void
 ShapeFunctions::buildInterpolationMatrix(const Matrix<Real> & coordinates,
                                          Matrix<Real> & coordMatrix,
                                          UInt integration_order) const {
   switch (integration_order) {
   case 1: {
     for (UInt i = 0; i < coordinates.cols(); ++i)
       coordMatrix(i, 0) = 1;
     break;
   }
   case 2: {
     UInt nb_quadrature_points = coordMatrix.cols();
 
     for (UInt i = 0; i < coordinates.cols(); ++i) {
       coordMatrix(i, 0) = 1;
       for (UInt j = 1; j < nb_quadrature_points; ++j)
         coordMatrix(i, j) = coordinates(j - 1, i);
     }
     break;
   }
   default: {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
     break;
   }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 inline void ShapeFunctions::buildElementalFieldInterpolationMatrix(
     const Matrix<Real> &, Matrix<Real> &, UInt) const {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void ShapeFunctions::buildElementalFieldInterpolationMatrix<_segment_2>(
     const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
     UInt integration_order) const {
   buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void ShapeFunctions::buildElementalFieldInterpolationMatrix<_segment_3>(
     const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
     UInt integration_order) const {
   buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void ShapeFunctions::buildElementalFieldInterpolationMatrix<_triangle_3>(
     const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
     UInt integration_order) const {
   buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void ShapeFunctions::buildElementalFieldInterpolationMatrix<_triangle_6>(
     const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
     UInt integration_order) const {
   buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ShapeFunctions::buildElementalFieldInterpolationMatrix<_tetrahedron_4>(
     const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
     UInt integration_order) const {
   buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ShapeFunctions::buildElementalFieldInterpolationMatrix<_tetrahedron_10>(
     const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
     UInt integration_order) const {
   buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
 }
 
 /**
  * @todo Write a more efficient interpolation for quadrangles by
  * dropping unnecessary quadrature points
  *
  */
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ShapeFunctions::buildElementalFieldInterpolationMatrix<_quadrangle_4>(
     const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
     UInt integration_order) const {
 
   if (integration_order !=
       ElementClassProperty<_quadrangle_4>::polynomial_degree) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   } else {
     for (UInt i = 0; i < coordinates.cols(); ++i) {
       Real x = coordinates(0, i);
       Real y = coordinates(1, i);
 
       coordMatrix(i, 0) = 1;
       coordMatrix(i, 1) = x;
       coordMatrix(i, 2) = y;
       coordMatrix(i, 3) = x * y;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ShapeFunctions::buildElementalFieldInterpolationMatrix<_quadrangle_8>(
     const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
     UInt integration_order) const {
 
   if (integration_order !=
       ElementClassProperty<_quadrangle_8>::polynomial_degree) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   } else {
     for (UInt i = 0; i < coordinates.cols(); ++i) {
       //UInt j = 0;
       Real x = coordinates(0, i);
       Real y = coordinates(1, i);
 
       coordMatrix(i, 0) = 1;
       coordMatrix(i, 1) = x;
       coordMatrix(i, 2) = y;
       coordMatrix(i, 3) = x * y;
       // for (UInt e = 0; e <= 2; ++e) {
       //   for (UInt n = 0; n <= 2; ++n) {
       //     coordMatrix(i, j) = std::pow(x, e) * std::pow(y, n);
       //     ++j;
       //   }
       // }
     }
   }
 }
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 inline void ShapeFunctions::interpolateElementalFieldFromIntegrationPoints(
     const Array<Real> & field,
     const Array<Real> & interpolation_points_coordinates_matrices,
     const Array<Real> & quad_points_coordinates_inv_matrices,
     ElementTypeMapArray<Real> & result, const GhostType & ghost_type,
     const Array<UInt> & element_filter) const {
   AKANTU_DEBUG_IN();
 
   auto nb_element = this->mesh.getNbElement(type, ghost_type);
 
   auto nb_quad_per_element =
       GaussIntegrationElement<type>::getNbQuadraturePoints();
   auto nb_interpolation_points_per_elem =
       interpolation_points_coordinates_matrices.getNbComponent() /
       nb_quad_per_element;
 
   if (!result.exists(type, ghost_type))
     result.alloc(nb_element * nb_interpolation_points_per_elem,
                  field.getNbComponent(), type, ghost_type);
 
   if (element_filter != empty_filter)
     nb_element = element_filter.size();
 
   Matrix<Real> coefficients(nb_quad_per_element, field.getNbComponent());
 
   auto & result_vec = result(type, ghost_type);
 
   auto field_it = field.begin_reinterpret(field.getNbComponent(),
                                           nb_quad_per_element, nb_element);
 
   auto interpolation_points_coordinates_it =
       interpolation_points_coordinates_matrices.begin(
           nb_interpolation_points_per_elem, nb_quad_per_element);
 
   auto result_begin = result_vec.begin_reinterpret(
       field.getNbComponent(), nb_interpolation_points_per_elem,
       result_vec.size() / nb_interpolation_points_per_elem);
 
   auto inv_quad_coord_it = quad_points_coordinates_inv_matrices.begin(
       nb_quad_per_element, nb_quad_per_element);
 
   /// loop over the elements of the current filter and element type
   for (UInt el = 0; el < nb_element; ++el, ++field_it, ++inv_quad_coord_it,
             ++interpolation_points_coordinates_it) {
     /**
      * matrix containing the inversion of the quadrature points'
      * coordinates
      */
     const auto & inv_quad_coord_matrix = *inv_quad_coord_it;
 
     /**
      * multiply it by the field values over quadrature points to get
      * the interpolation coefficients
      */
     coefficients.mul<false, true>(inv_quad_coord_matrix, *field_it);
 
     /// matrix containing the points' coordinates
     const auto & coord = *interpolation_points_coordinates_it;
 
     /// multiply the coordinates matrix by the coefficients matrix and store the
     /// result
     Matrix<Real> res(result_begin[element_filter(el)]);
     res.mul<true, true>(coefficients, coord);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 inline void ShapeFunctions::interpolateElementalFieldOnIntegrationPoints(
     const Array<Real> & u_el, Array<Real> & uq, const GhostType & ghost_type,
     const Array<Real> & shapes, const Array<UInt> & filter_elements) const {
   auto nb_element = mesh.getNbElement(type, ghost_type);
   auto nb_nodes_per_element = ElementClass<type>::getShapeSize();
   auto nb_points = shapes.size() / mesh.getNbElement(type, ghost_type);
   auto nb_degree_of_freedom = u_el.getNbComponent() / nb_nodes_per_element;
 
   Array<Real>::const_matrix_iterator N_it;
   Array<Real> * filtered_N = nullptr;
   if (filter_elements != empty_filter) {
     nb_element = filter_elements.size();
     filtered_N = new Array<Real>(0, shapes.getNbComponent());
     FEEngine::filterElementalData(mesh, shapes, *filtered_N, type, ghost_type,
                                   filter_elements);
     N_it = filtered_N->begin_reinterpret(nb_nodes_per_element, nb_points,
                                          nb_element);
   } else {
     N_it =
         shapes.begin_reinterpret(nb_nodes_per_element, nb_points, nb_element);
   }
 
   uq.resize(nb_element * nb_points);
 
   auto u_it = u_el.begin(nb_degree_of_freedom, nb_nodes_per_element);
   auto inter_u_it =
       uq.begin_reinterpret(nb_degree_of_freedom, nb_points, nb_element);
 
   for (UInt el = 0; el < nb_element; ++el, ++N_it, ++u_it, ++inter_u_it) {
     const auto & u = *u_it;
     const auto & N = *N_it;
     auto & inter_u = *inter_u_it;
 
     inter_u.template mul<false, false>(u, N);
   }
 
   delete filtered_N;
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void ShapeFunctions::gradientElementalFieldOnIntegrationPoints(
     const Array<Real> & u_el, Array<Real> & out_nablauq,
     const GhostType & ghost_type, const Array<Real> & shapes_derivatives,
     const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   auto nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
   auto nb_points = integration_points(type, ghost_type).cols();
   auto element_dimension = ElementClass<type>::getNaturalSpaceDimension();
   auto nb_degree_of_freedom = u_el.getNbComponent() / nb_nodes_per_element;
   auto nb_element = mesh.getNbElement(type, ghost_type);
 
   Array<Real>::const_matrix_iterator B_it;
 
   Array<Real> * filtered_B = nullptr;
   if (filter_elements != empty_filter) {
     nb_element = filter_elements.size();
     filtered_B = new Array<Real>(0, shapes_derivatives.getNbComponent());
     FEEngine::filterElementalData(mesh, shapes_derivatives, *filtered_B, type,
                                   ghost_type, filter_elements);
     B_it = filtered_B->begin(element_dimension, nb_nodes_per_element);
   } else {
     B_it = shapes_derivatives.begin(element_dimension, nb_nodes_per_element);
   }
 
   out_nablauq.resize(nb_element * nb_points);
   auto u_it = u_el.begin(nb_degree_of_freedom, nb_nodes_per_element);
   auto nabla_u_it = out_nablauq.begin(nb_degree_of_freedom, element_dimension);
 
   for (UInt el = 0; el < nb_element; ++el, ++u_it) {
     const auto & u = *u_it;
     for (UInt q = 0; q < nb_points; ++q, ++B_it, ++nabla_u_it) {
       const auto & B = *B_it;
      auto & nabla_u = *nabla_u_it;
       nabla_u.template mul<false, true>(u, B);
     }
   }
 
   delete filtered_B;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
 
 #endif /* __AKANTU_SHAPE_FUNCTIONS_INLINE_IMPL_CC__ */
diff --git a/src/fe_engine/shape_lagrange_base.cc b/src/fe_engine/shape_lagrange_base.cc
index 2d9dcb7b0..ad9f1c4a6 100644
--- a/src/fe_engine/shape_lagrange_base.cc
+++ b/src/fe_engine/shape_lagrange_base.cc
@@ -1,159 +1,159 @@
 /**
  * @file   shape_lagrange_base.cc
  *
  * @author Nicolas Richart
  *
  * @date creation  Thu Jul 27 2017
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 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 "shape_lagrange_base.hh"
 #include "mesh_iterators.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 ShapeLagrangeBase::ShapeLagrangeBase(const Mesh & mesh,
                                      const ElementKind & kind, const ID & id,
                                      const MemoryID & memory_id)
     : ShapeFunctions(mesh, id, memory_id),
       _kind(kind) {}
 
 /* -------------------------------------------------------------------------- */
 ShapeLagrangeBase::~ShapeLagrangeBase() = default;
 
 /* -------------------------------------------------------------------------- */
 #define AKANTU_COMPUTE_SHAPES(type)                                            \
   _this.template computeShapesOnIntegrationPoints<type>(                       \
       nodes, integration_points, shapes, ghost_type, filter_elements)
 
 namespace shape_lagrange {
   namespace details {
     template <ElementKind kind> struct Helper {
       template <class S>
       static void call(const S &, const Array<Real> &, const Matrix<Real> &,
                        Array<Real> &, const ElementType &, const GhostType &,
                        const Array<UInt> &) {
-        AKANTU_DEBUG_TO_IMPLEMENT();
+        AKANTU_TO_IMPLEMENT();
       }
     };
 
 #define AKANTU_COMPUTE_SHAPES_KIND(kind)                                       \
   template <> struct Helper<kind> {                                            \
     template <class S>                                                         \
     static void call(const S & _this, const Array<Real> & nodes,               \
                      const Matrix<Real> & integration_points,                  \
                      Array<Real> & shapes, const ElementType & type,           \
                      const GhostType & ghost_type,                             \
                      const Array<UInt> & filter_elements) {                    \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(AKANTU_COMPUTE_SHAPES, kind);           \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(AKANTU_COMPUTE_SHAPES_KIND,
                                AKANTU_FE_ENGINE_LIST_LAGRANGE_BASE)
 
   } // namespace details
 } // namespace shape_lagrange
 
 /* -------------------------------------------------------------------------- */
 void ShapeLagrangeBase::computeShapesOnIntegrationPoints(
     const Array<Real> & nodes, const Matrix<Real> & integration_points,
     Array<Real> & shapes, const ElementType & type,
     const GhostType & ghost_type, const Array<UInt> & filter_elements) const {
 
   auto kind = Mesh::getKind(type);
 
 #define AKANTU_COMPUTE_SHAPES_KIND_SWITCH(kind)                                \
   shape_lagrange::details::Helper<kind>::call(                                 \
       *this, nodes, integration_points, shapes, type, ghost_type,              \
       filter_elements);
 
   AKANTU_BOOST_LIST_SWITCH(
       AKANTU_COMPUTE_SHAPES_KIND_SWITCH,
       BOOST_PP_LIST_TO_SEQ(AKANTU_FE_ENGINE_LIST_LAGRANGE_BASE), kind);
 
 #undef AKANTU_COMPUTE_SHAPES
 #undef AKANTU_COMPUTE_SHAPES_KIND
 #undef AKANTU_COMPUTE_SHAPES_KIND_SWITCH
 }
 
 /* -------------------------------------------------------------------------- */
 void ShapeLagrangeBase::onElementsAdded(const Array<Element> & new_elements) {
   AKANTU_DEBUG_IN();
   const auto & nodes = mesh.getNodes();
 
   for (auto elements_range : MeshElementsByTypes(new_elements)) {
     auto type = elements_range.getType();
     auto ghost_type = elements_range.getGhostType();
 
     if (mesh.getKind(type) != _kind)
       continue;
 
     auto & elements = elements_range.getElements();
 
     auto itp_type = FEEngine::getInterpolationType(type);
 
     if (not this->shapes_derivatives.exists(itp_type, ghost_type)) {
       auto size_of_shapesd = this->getShapeDerivativesSize(type);
       this->shapes_derivatives.alloc(0, size_of_shapesd, itp_type, ghost_type);
     }
 
     if (not shapes.exists(itp_type, ghost_type)) {
       auto size_of_shapes = this->getShapeSize(type);
       this->shapes.alloc(0, size_of_shapes, itp_type, ghost_type);
     }
 
     const auto & natural_coords = integration_points(type, ghost_type);
     computeShapesOnIntegrationPoints(nodes, natural_coords,
                                      shapes(itp_type, ghost_type), type,
                                      ghost_type, elements);
 
     computeShapeDerivativesOnIntegrationPoints(
         nodes, natural_coords, shapes_derivatives(itp_type, ghost_type), type,
         ghost_type, elements);
   }
 #undef INIT_SHAPE_FUNCTIONS
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ShapeLagrangeBase::onElementsRemoved(
     const Array<Element> &, const ElementTypeMapArray<UInt> & new_numbering) {
   this->shapes.onElementsRemoved(new_numbering);
   this->shapes_derivatives.onElementsRemoved(new_numbering);
 }
 
 /* -------------------------------------------------------------------------- */
 void ShapeLagrangeBase::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "Shapes Lagrange [" << std::endl;
   ShapeFunctions::printself(stream, indent + 1);
   shapes.printself(stream, indent + 1);
   shapes_derivatives.printself(stream, indent + 1);
   stream << space << "]" << std::endl;
 }
 
 } // namespace akantu
diff --git a/src/fe_engine/shape_lagrange_inline_impl.cc b/src/fe_engine/shape_lagrange_inline_impl.cc
index f2cf401c2..e8b8aaba0 100644
--- a/src/fe_engine/shape_lagrange_inline_impl.cc
+++ b/src/fe_engine/shape_lagrange_inline_impl.cc
@@ -1,526 +1,526 @@
 /**
  * @file   shape_lagrange_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Oct 27 2010
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  ShapeLagrange inline implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "aka_iterators.hh"
 #include "aka_voigthelper.hh"
 #include "fe_engine.hh"
 #include "shape_lagrange.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SHAPE_LAGRANGE_INLINE_IMPL_CC__
 #define __AKANTU_SHAPE_LAGRANGE_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 #define INIT_SHAPE_FUNCTIONS(type)                                             \
   setIntegrationPointsByType<type>(integration_points, ghost_type);            \
   precomputeShapesOnIntegrationPoints<type>(nodes, ghost_type);                \
   if (ElementClass<type>::getNaturalSpaceDimension() ==                        \
           mesh.getSpatialDimension() ||                                        \
       kind != _ek_regular)                                                     \
     precomputeShapeDerivativesOnIntegrationPoints<type>(nodes, ghost_type);
 
 template <ElementKind kind>
 inline void ShapeLagrange<kind>::initShapeFunctions(
     const Array<Real> & nodes, const Matrix<Real> & integration_points,
     const ElementType & type, const GhostType & ghost_type) {
   AKANTU_BOOST_REGULAR_ELEMENT_SWITCH(INIT_SHAPE_FUNCTIONS);
 }
 
 #undef INIT_SHAPE_FUNCTIONS
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 inline void ShapeLagrange<kind>::computeShapeDerivativesOnCPointsByElement(
     const Matrix<Real> & node_coords, const Matrix<Real> & natural_coords,
     Tensor3<Real> & shapesd) const {
   AKANTU_DEBUG_IN();
 
   // compute dnds
   Tensor3<Real> dnds(node_coords.rows(), node_coords.cols(),
                      natural_coords.cols());
   ElementClass<type>::computeDNDS(natural_coords, dnds);
   // compute jacobian
   Tensor3<Real> J(node_coords.rows(), natural_coords.rows(),
                   natural_coords.cols());
   ElementClass<type>::computeJMat(dnds, node_coords, J);
 
   // compute dndx
   ElementClass<type>::computeShapeDerivatives(J, dnds, shapesd);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::inverseMap(const Vector<Real> & real_coords,
                                      UInt elem, Vector<Real> & natural_coords,
                                      const GhostType & ghost_type) const {
 
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
 
   UInt * elem_val = mesh.getConnectivity(type, ghost_type).storage();
   Matrix<Real> nodes_coord(spatial_dimension, nb_nodes_per_element);
 
   mesh.extractNodalValuesFromElement(mesh.getNodes(), nodes_coord.storage(),
                                      elem_val + elem * nb_nodes_per_element,
                                      nb_nodes_per_element, spatial_dimension);
 
   ElementClass<type>::inverseMap(real_coords, nodes_coord, natural_coords);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 bool ShapeLagrange<kind>::contains(const Vector<Real> & real_coords, UInt elem,
                                    const GhostType & ghost_type) const {
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   Vector<Real> natural_coords(spatial_dimension);
 
   inverseMap<type>(real_coords, elem, natural_coords, ghost_type);
   return ElementClass<type>::contains(natural_coords);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::interpolate(const Vector<Real> & real_coords,
                                       UInt elem,
                                       const Matrix<Real> & nodal_values,
                                       Vector<Real> & interpolated,
                                       const GhostType & ghost_type) const {
   UInt nb_shapes = ElementClass<type>::getShapeSize();
   Vector<Real> shapes(nb_shapes);
   computeShapes<type>(real_coords, elem, shapes, ghost_type);
   ElementClass<type>::interpolate(nodal_values, shapes, interpolated);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::computeShapes(const Vector<Real> & real_coords,
                                         UInt elem, Vector<Real> & shapes,
                                         const GhostType & ghost_type) const {
 
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   Vector<Real> natural_coords(spatial_dimension);
 
   inverseMap<type>(real_coords, elem, natural_coords, ghost_type);
   ElementClass<type>::computeShapes(natural_coords, shapes);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::computeShapeDerivatives(
     const Matrix<Real> & real_coords, UInt elem, Tensor3<Real> & shapesd,
     const GhostType & ghost_type) const {
 
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt nb_points = real_coords.cols();
   UInt nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
 
   AKANTU_DEBUG_ASSERT(mesh.getSpatialDimension() == shapesd.size(0) &&
                           nb_nodes_per_element == shapesd.size(1),
                       "Shape size doesn't match");
   AKANTU_DEBUG_ASSERT(nb_points == shapesd.size(2),
                       "Number of points doesn't match shapes size");
 
   Matrix<Real> natural_coords(spatial_dimension, nb_points);
 
   // Creates the matrix of natural coordinates
   for (UInt i = 0; i < nb_points; i++) {
     Vector<Real> real_point = real_coords(i);
     Vector<Real> natural_point = natural_coords(i);
 
     inverseMap<type>(real_point, elem, natural_point, ghost_type);
   }
 
   UInt * elem_val = mesh.getConnectivity(type, ghost_type).storage();
   Matrix<Real> nodes_coord(spatial_dimension, nb_nodes_per_element);
 
   mesh.extractNodalValuesFromElement(mesh.getNodes(), nodes_coord.storage(),
                                      elem_val + elem * nb_nodes_per_element,
                                      nb_nodes_per_element, spatial_dimension);
 
   computeShapeDerivativesOnCPointsByElement<type>(nodes_coord, natural_coords,
                                                   shapesd);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 ShapeLagrange<kind>::ShapeLagrange(const Mesh & mesh, const ID & id,
                                    const MemoryID & memory_id)
     : ShapeLagrangeBase(mesh, kind, id, memory_id) {}
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::computeShapeDerivativesOnIntegrationPoints(
     const Array<Real> & nodes, const Matrix<Real> & integration_points,
     Array<Real> & shape_derivatives, const GhostType & ghost_type,
     const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   UInt nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
 
   UInt nb_points = integration_points.cols();
   UInt nb_element = mesh.getConnectivity(type, ghost_type).size();
 
   UInt size_of_shapesd = ElementClass<type>::getShapeDerivativesSize();
   AKANTU_DEBUG_ASSERT(shape_derivatives.getNbComponent() == size_of_shapesd,
                       "The shapes_derivatives array does not have the correct "
                           << "number of component");
   shape_derivatives.resize(nb_element * nb_points);
 
   Array<Real> x_el(0, spatial_dimension * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, nodes, x_el, type, ghost_type,
                                        filter_elements);
 
   Real * shapesd_val = shape_derivatives.storage();
   Array<Real>::matrix_iterator x_it =
       x_el.begin(spatial_dimension, nb_nodes_per_element);
 
   if (filter_elements != empty_filter)
     nb_element = filter_elements.size();
 
   for (UInt elem = 0; elem < nb_element; ++elem, ++x_it) {
     if (filter_elements != empty_filter)
       shapesd_val = shape_derivatives.storage() +
                     filter_elements(elem) * size_of_shapesd * nb_points;
 
     Matrix<Real> & X = *x_it;
     Tensor3<Real> B(shapesd_val, spatial_dimension, nb_nodes_per_element,
                     nb_points);
     computeShapeDerivativesOnCPointsByElement<type>(X, integration_points, B);
 
     if (filter_elements == empty_filter)
       shapesd_val += size_of_shapesd * nb_points;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 void ShapeLagrange<kind>::computeShapeDerivativesOnIntegrationPoints(
     const Array<Real> & nodes, const Matrix<Real> & integration_points,
     Array<Real> & shape_derivatives, const ElementType & type,
     const GhostType & ghost_type, const Array<UInt> & filter_elements) const {
 #define AKANTU_COMPUTE_SHAPES(type)                                            \
   computeShapeDerivativesOnIntegrationPoints<type>(                            \
       nodes, integration_points, shape_derivatives, ghost_type,                \
       filter_elements);
 
   AKANTU_BOOST_REGULAR_ELEMENT_SWITCH(AKANTU_COMPUTE_SHAPES);
 
 #undef AKANTU_COMPUTE_SHAPES
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::precomputeShapesOnIntegrationPoints(
     const Array<Real> & nodes, const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   InterpolationType itp_type = ElementClassProperty<type>::interpolation_type;
   Matrix<Real> & natural_coords = integration_points(type, ghost_type);
   UInt size_of_shapes = ElementClass<type>::getShapeSize();
 
   Array<Real> & shapes_tmp =
       shapes.alloc(0, size_of_shapes, itp_type, ghost_type);
 
   this->computeShapesOnIntegrationPoints<type>(nodes, natural_coords,
                                                shapes_tmp, ghost_type);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::precomputeShapeDerivativesOnIntegrationPoints(
     const Array<Real> & nodes, const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   InterpolationType itp_type = ElementClassProperty<type>::interpolation_type;
   Matrix<Real> & natural_coords = integration_points(type, ghost_type);
   UInt size_of_shapesd = ElementClass<type>::getShapeDerivativesSize();
 
   Array<Real> & shapes_derivatives_tmp =
       shapes_derivatives.alloc(0, size_of_shapesd, itp_type, ghost_type);
 
   this->computeShapeDerivativesOnIntegrationPoints<type>(
       nodes, natural_coords, shapes_derivatives_tmp, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::interpolateOnIntegrationPoints(
     const Array<Real> & in_u, Array<Real> & out_uq, UInt nb_degree_of_freedom,
     const Array<Real> & shapes, GhostType ghost_type,
     const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
 
   Array<Real> u_el(0, nb_degree_of_freedom * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, in_u, u_el, type, ghost_type,
                                        filter_elements);
 
   this->interpolateElementalFieldOnIntegrationPoints<type>(
       u_el, out_uq, ghost_type, shapes, filter_elements);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::interpolateOnIntegrationPoints(
     const Array<Real> & in_u, Array<Real> & out_uq, UInt nb_degree_of_freedom,
     GhostType ghost_type, const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   InterpolationType itp_type = ElementClassProperty<type>::interpolation_type;
   AKANTU_DEBUG_ASSERT(shapes.exists(itp_type, ghost_type),
                       "No shapes for the type "
                           << shapes.printType(itp_type, ghost_type));
 
   this->interpolateOnIntegrationPoints<type>(in_u, out_uq, nb_degree_of_freedom,
                                              shapes(itp_type, ghost_type),
                                              ghost_type, filter_elements);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::gradientOnIntegrationPoints(
     const Array<Real> & in_u, Array<Real> & out_nablauq,
     UInt nb_degree_of_freedom, GhostType ghost_type,
     const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   InterpolationType itp_type = ElementClassProperty<type>::interpolation_type;
   AKANTU_DEBUG_ASSERT(
       shapes_derivatives.exists(itp_type, ghost_type),
       "No shapes derivatives for the type "
           << shapes_derivatives.printType(itp_type, ghost_type));
 
   UInt nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
 
   Array<Real> u_el(0, nb_degree_of_freedom * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, in_u, u_el, type, ghost_type,
                                        filter_elements);
 
   this->gradientElementalFieldOnIntegrationPoints<type>(
       u_el, out_nablauq, ghost_type, shapes_derivatives(itp_type, ghost_type),
       filter_elements);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::computeBtD(
     const Array<Real> & Ds, Array<Real> & BtDs, GhostType ghost_type,
     const Array<UInt> & filter_elements) const {
   auto itp_type = ElementClassProperty<type>::interpolation_type;
   const auto & shapes_derivatives =
       this->shapes_derivatives(itp_type, ghost_type);
 
   auto spatial_dimension = mesh.getSpatialDimension();
   auto nb_nodes_per_element = mesh.getNbNodesPerElement(type);
 
   Array<Real> shapes_derivatives_filtered(0,
                                           shapes_derivatives.getNbComponent());
   auto && view =
       make_view(shapes_derivatives, spatial_dimension, nb_nodes_per_element);
   auto B_it = view.begin();
   auto B_end = view.end();
 
   if (filter_elements != empty_filter) {
     FEEngine::filterElementalData(this->mesh, shapes_derivatives,
                                   shapes_derivatives_filtered, type, ghost_type,
                                   filter_elements);
     auto && view = make_view(shapes_derivatives_filtered, spatial_dimension,
                              nb_nodes_per_element);
     B_it = view.begin();
     B_end = view.end();
   }
 
   for (auto && values :
        zip(range(B_it, B_end),
            make_view(Ds, Ds.getNbComponent() / spatial_dimension,
                      spatial_dimension),
            make_view(BtDs, BtDs.getNbComponent() / nb_nodes_per_element,
                      nb_nodes_per_element))) {
     const auto & B = std::get<0>(values);
     const auto & D = std::get<1>(values);
     auto & Bt_D = std::get<2>(values);
     // transposed due to the storage layout of B
     Bt_D.template mul<false, false>(D, B);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::computeBtDB(
     const Array<Real> & Ds, Array<Real> & BtDBs, UInt order_d,
     GhostType ghost_type, const Array<UInt> & filter_elements) const {
   auto itp_type = ElementClassProperty<type>::interpolation_type;
   const auto & shapes_derivatives =
       this->shapes_derivatives(itp_type, ghost_type);
 
   constexpr auto dim = ElementClass<type>::getSpatialDimension();
   auto nb_nodes_per_element = mesh.getNbNodesPerElement(type);
 
   Array<Real> shapes_derivatives_filtered(0,
                                           shapes_derivatives.getNbComponent());
   auto && view = make_view(shapes_derivatives, dim, nb_nodes_per_element);
   auto B_it = view.begin();
   auto B_end = view.end();
 
   if (filter_elements != empty_filter) {
     FEEngine::filterElementalData(this->mesh, shapes_derivatives,
                                   shapes_derivatives_filtered, type, ghost_type,
                                   filter_elements);
     auto && view =
         make_view(shapes_derivatives_filtered, dim, nb_nodes_per_element);
     B_it = view.begin();
     B_end = view.end();
   }
 
   if (order_d == 4) {
     UInt tangent_size = VoigtHelper<dim>::size;
     Matrix<Real> B(tangent_size, dim * nb_nodes_per_element);
     Matrix<Real> Bt_D(dim * nb_nodes_per_element, tangent_size);
 
     for (auto && values :
          zip(range(B_it, B_end), make_view(Ds, tangent_size, tangent_size),
              make_view(BtDBs, dim * nb_nodes_per_element,
                        dim * nb_nodes_per_element))) {
       const auto & Bfull = std::get<0>(values);
       const auto & D = std::get<1>(values);
       auto & Bt_D_B = std::get<2>(values);
 
       VoigtHelper<dim>::transferBMatrixToSymVoigtBMatrix(Bfull, B,
                                                          nb_nodes_per_element);
       Bt_D.template mul<true, false>(B, D);
       Bt_D_B.template mul<false, false>(Bt_D, B);
     }
   } else if (order_d == 2) {
     Matrix<Real> Bt_D(nb_nodes_per_element, dim);
     for (auto && values :
          zip(range(B_it, B_end), make_view(Ds, dim, dim),
              make_view(BtDBs, nb_nodes_per_element, nb_nodes_per_element))) {
       const auto & B = std::get<0>(values);
       const auto & D = std::get<1>(values);
       auto & Bt_D_B = std::get<2>(values);
       Bt_D.template mul<true, false>(B, D);
       Bt_D_B.template mul<false, false>(Bt_D, B);
     }
   }
 }
 
 template <>
 template <>
 inline void ShapeLagrange<_ek_regular>::computeBtDB<_point_1>(
     const Array<Real> & /*Ds*/, Array<Real> & /*BtDBs*/, UInt /*order_d*/,
     GhostType /*ghost_type*/, const Array<UInt> & /*filter_elements*/) const {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::fieldTimesShapes(const Array<Real> & field,
                                            Array<Real> & field_times_shapes,
                                            GhostType ghost_type) const {
   AKANTU_DEBUG_IN();
 
   field_times_shapes.resize(field.size());
 
   UInt size_of_shapes = ElementClass<type>::getShapeSize();
   InterpolationType itp_type = ElementClassProperty<type>::interpolation_type;
   UInt nb_degree_of_freedom = field.getNbComponent();
 
   const auto & shape = shapes(itp_type, ghost_type);
 
   auto field_it = field.begin(nb_degree_of_freedom, 1);
   auto shapes_it = shape.begin(1, size_of_shapes);
 
   auto it = field_times_shapes.begin(nb_degree_of_freedom, size_of_shapes);
   auto end = field_times_shapes.end(nb_degree_of_freedom, size_of_shapes);
 
   for (; it != end; ++it, ++field_it, ++shapes_it) {
     it->template mul<false, false>(*field_it, *shapes_it);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_SHAPE_LAGRANGE_INLINE_IMPL_CC__ */
diff --git a/src/fe_engine/shape_structural.hh b/src/fe_engine/shape_structural.hh
index e3da7366b..840bc116c 100644
--- a/src/fe_engine/shape_structural.hh
+++ b/src/fe_engine/shape_structural.hh
@@ -1,177 +1,177 @@
 /**
  * @file   shape_structural.hh
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Feb 15 2011
  * @date last modification: Thu Oct 22 2015
  *
  * @brief  shape class for element with different set of shapes functions
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "shape_functions.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SHAPE_STRUCTURAL_HH__
 #define __AKANTU_SHAPE_STRUCTURAL_HH__
 
 namespace akantu {
 
 template <ElementKind kind> class ShapeStructural : public ShapeFunctions {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
   // Ctors/Dtors should be explicitely implemented for _ek_structural
 public:
   ShapeStructural(Mesh & mesh, const ID & id = "shape_structural",
                   const MemoryID & memory_id = 0);
   ~ShapeStructural() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// function to print the contain of the class
   void printself(std::ostream & stream, int indent = 0) const override {
     std::string space;
     for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
       ;
     stream << space << "ShapesStructural [" << std::endl;
     rotation_matrices.printself(stream, indent + 1);
     ShapeFunctions::printself(stream, indent + 1);
     stream << space << "]" << std::endl;
   }
 
   /// compute shape functions on given integration points
   template <ElementType type>
   void computeShapesOnIntegrationPoints(
       const Array<Real> &, const Matrix<Real> & integration_points,
       Array<Real> & shapes, const GhostType & ghost_type,
       const Array<UInt> & filter_elements = empty_filter) const;
 
   /// initialization function for structural elements
   inline void initShapeFunctions(const Array<Real> & nodes,
                                  const Matrix<Real> & integration_points,
                                  const ElementType & type,
                                  const GhostType & ghost_type);
 
   /// precompute the rotation matrices for the elements dofs
   template <ElementType type>
   void precomputeRotationMatrices(const Array<Real> & nodes,
                                   const GhostType & ghost_type);
 
   /// pre compute all shapes on the element integration points from natural
   /// coordinates
   template <ElementType type>
   void precomputeShapesOnIntegrationPoints(const Array<Real> & nodes,
                                            const GhostType & ghost_type);
 
   /// pre compute all shapes on the element integration points from natural
   /// coordinates
   template <ElementType type>
   void
   precomputeShapeDerivativesOnIntegrationPoints(const Array<Real> & nodes,
                                                 const GhostType & ghost_type);
 
   /// interpolate nodal values on the integration points
   template <ElementType type>
   void interpolateOnIntegrationPoints(
       const Array<Real> & u, Array<Real> & uq, UInt nb_degree_of_freedom,
       const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const;
 
   /// compute the gradient of u on the integration points
   template <ElementType type>
   void gradientOnIntegrationPoints(
       const Array<Real> & u, Array<Real> & nablauq, UInt nb_degree_of_freedom,
       const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const;
 
   /// interpolate on physical point
   template <ElementType type>
   void interpolate(const Vector<Real> & /*real_coords*/, UInt /*elem*/,
                    const Matrix<Real> & /*nodal_values*/,
                    Vector<Real> & /*interpolated*/,
                    const GhostType & /*ghost_type*/) const {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// compute the shapes on a provided point
   template <ElementType type>
   void computeShapes(const Vector<Real> & /*real_coords*/, UInt /*elem*/,
                      Vector<Real> & /*shapes*/,
                      const GhostType & /*ghost_type*/) const {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
  
   /// compute the shape derivatives on a provided point
   template <ElementType type>
   void computeShapeDerivatives(const Matrix<Real> & /*real_coords*/, UInt /*elem*/,
                                Tensor3<Real> & /*shapes*/,
                                const GhostType & /*ghost_type*/) const {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// multiply a field by shape functions
   template <ElementType type>
   void
   fieldTimesShapes(__attribute__((unused)) const Array<Real> & field,
                    __attribute__((unused)) Array<Real> & field_times_shapes,
                    __attribute__((unused)) const GhostType & ghost_type) const {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// get the rotations vector
   inline const Array<Real> &
   getRotations(const ElementType & el_type,
                __attribute__((unused))
                const GhostType & ghost_type = _not_ghost) const {
     return rotation_matrices(el_type);
   }
 
   template <ElementType type>
   void computeBtD(const Array<Real> & /*Ds*/, Array<Real> & /*BtDs*/,
                   GhostType /*ghost_type*/,
                   const Array<UInt> & /*filter_elements*/) const {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   template <ElementType type>
   void computeBtDB(const Array<Real> & /*Ds*/, Array<Real> & /*BtDBs*/,
                    UInt /*order_d*/, GhostType /*ghost_type*/,
                    const Array<UInt> & /*filter_elements*/) const {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
 protected:
   ElementTypeMapArray<Real> rotation_matrices;
 };
 
 } // namespace akantu
 
 #include "shape_structural_inline_impl.cc"
 
 #endif /* __AKANTU_SHAPE_STRUCTURAL_HH__ */
diff --git a/src/fe_engine/shape_structural_inline_impl.cc b/src/fe_engine/shape_structural_inline_impl.cc
index 5792b0d34..bf1c2fce1 100644
--- a/src/fe_engine/shape_structural_inline_impl.cc
+++ b/src/fe_engine/shape_structural_inline_impl.cc
@@ -1,389 +1,389 @@
 /**
  * @file   shape_structural_inline_impl.cc
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Dec 13 2010
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  ShapeStructural inline implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "mesh_iterators.hh"
 #include "shape_structural.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SHAPE_STRUCTURAL_INLINE_IMPL_CC__
 #define __AKANTU_SHAPE_STRUCTURAL_INLINE_IMPL_CC__
 
 namespace akantu {
 
 namespace {
   /// Extract nodal coordinates per elements
   template <ElementType type>
   std::unique_ptr<Array<Real>>
   getNodesPerElement(const Mesh & mesh, const Array<Real> & nodes,
                      const GhostType & ghost_type) {
     const auto dim = ElementClass<type>::getSpatialDimension();
     const auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
     auto nodes_per_element = std::make_unique<Array<Real>>(0, dim * nb_nodes_per_element);
     FEEngine::extractNodalToElementField(mesh, nodes, *nodes_per_element, type, ghost_type);
     return nodes_per_element;
   }
 }
 
 template <ElementKind kind>
 inline void ShapeStructural<kind>::initShapeFunctions(
     const Array<Real> & /* unused */, const Matrix<Real> & /* unused */,
     const ElementType & /* unused */, const GhostType & /* unused */) {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 #define INIT_SHAPE_FUNCTIONS(type)                                             \
   setIntegrationPointsByType<type>(integration_points, ghost_type);            \
   precomputeRotationMatrices<type>(nodes, ghost_type);                         \
   precomputeShapesOnIntegrationPoints<type>(nodes, ghost_type);                \
   precomputeShapeDerivativesOnIntegrationPoints<type>(nodes, ghost_type);
 
 template <>
 inline void ShapeStructural<_ek_structural>::initShapeFunctions(
     const Array<Real> & nodes, const Matrix<Real> & integration_points,
     const ElementType & type, const GhostType & ghost_type) {
   AKANTU_BOOST_STRUCTURAL_ELEMENT_SWITCH(INIT_SHAPE_FUNCTIONS);
 }
 
 #undef INIT_SHAPE_FUNCTIONS
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <ElementType type>
 void ShapeStructural<_ek_structural>::computeShapesOnIntegrationPoints(
     const Array<Real> & nodes, const Matrix<Real> & integration_points,
     Array<Real> & shapes, const GhostType & ghost_type,
     const Array<UInt> & filter_elements) const {
 
   UInt nb_points = integration_points.cols();
   UInt nb_element = mesh.getConnectivity(type, ghost_type).size();
 
   shapes.resize(nb_element * nb_points);
 
   UInt ndof = ElementClass<type>::getNbDegreeOfFreedom();
 
 #if !defined(AKANTU_NDEBUG)
   UInt size_of_shapes = ElementClass<type>::getShapeSize();
   AKANTU_DEBUG_ASSERT(shapes.getNbComponent() == size_of_shapes,
                       "The shapes array does not have the correct "
                           << "number of component");
 #endif
 
   auto shapes_it = shapes.begin_reinterpret(
       ElementClass<type>::getNbNodesPerInterpolationElement(), ndof, nb_points,
       nb_element);
 
   auto shapes_begin = shapes_it;
   if (filter_elements != empty_filter) {
     nb_element = filter_elements.size();
   }
 
   auto nodes_per_element = getNodesPerElement<type>(mesh, nodes, ghost_type);
   auto nodes_it = nodes_per_element->begin(mesh.getSpatialDimension(),
                                            Mesh::getNbNodesPerElement(type));
   auto nodes_begin = nodes_it;
 
   for (UInt elem = 0; elem < nb_element; ++elem) {
     if (filter_elements != empty_filter) {
       shapes_it = shapes_begin + filter_elements(elem);
       nodes_it = nodes_begin + filter_elements(elem);
     }
 
     Tensor3<Real> & N = *shapes_it;
     auto & real_coord = *nodes_it;
     ElementClass<type>::computeShapes(integration_points, real_coord, N);
 
     if (filter_elements == empty_filter)
       ++shapes_it;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeStructural<kind>::precomputeRotationMatrices(
     const Array<Real> & nodes, const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   const auto spatial_dimension = mesh.getSpatialDimension();
   const auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   const auto nb_element = mesh.getNbElement(type, ghost_type);
   const auto nb_dof = ElementClass<type>::getNbDegreeOfFreedom();
 
   if (not this->rotation_matrices.exists(type, ghost_type)) {
     this->rotation_matrices.alloc(0, nb_dof * nb_dof, type, ghost_type);
   }
 
   auto & rot_matrices = this->rotation_matrices(type, ghost_type);
   rot_matrices.resize(nb_element);
 
   Array<Real> x_el(0, spatial_dimension * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, nodes, x_el, type, ghost_type);
 
   bool has_extra_normal = mesh.hasData<Real>("extra_normal", type, ghost_type);
   Array<Real>::const_vector_iterator extra_normal;
   if (has_extra_normal)
     extra_normal = mesh.getData<Real>("extra_normal", type, ghost_type)
                        .begin(spatial_dimension);
 
   for (auto && tuple :
        zip(make_view(x_el, spatial_dimension, nb_nodes_per_element),
            make_view(rot_matrices, nb_dof, nb_dof))) {
     // compute shape derivatives
     auto & X = std::get<0>(tuple);
     auto & R = std::get<1>(tuple);
 
     if (has_extra_normal) {
       ElementClass<type>::computeRotationMatrix(R, X, *extra_normal);
       ++extra_normal;
     } else {
       ElementClass<type>::computeRotationMatrix(
           R, X, Vector<Real>(spatial_dimension));
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <ElementKind kind>
 template <ElementType type>
 void ShapeStructural<kind>::precomputeShapesOnIntegrationPoints(
     const Array<Real> & nodes, const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   const auto & natural_coords = integration_points(type, ghost_type);
   auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   auto nb_points = integration_points(type, ghost_type).cols();
   auto nb_element = mesh.getNbElement(type, ghost_type);
   auto nb_dof = ElementClass<type>::getNbDegreeOfFreedom();
   const auto dim = ElementClass<type>::getSpatialDimension();
 
   auto itp_type = FEEngine::getInterpolationType(type);
   if (not shapes.exists(itp_type, ghost_type)) {
     auto size_of_shapes = this->getShapeSize(type);
     this->shapes.alloc(0, size_of_shapes, itp_type, ghost_type);
   }
 
   auto & shapes_ = this->shapes(itp_type, ghost_type);
   shapes_.resize(nb_element * nb_points);
 
   auto nodes_per_element = getNodesPerElement<type>(mesh, nodes, ghost_type);
 
   for (auto && tuple :
 	 zip(make_view(shapes_, nb_dof, nb_dof * nb_nodes_per_element, nb_points),
 	     make_view(*nodes_per_element, dim, nb_nodes_per_element))) {
     auto & N = std::get<0>(tuple);
     auto & real_coord = std::get<1>(tuple);
     ElementClass<type>::computeShapes(natural_coords, real_coord, N);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeStructural<kind>::precomputeShapeDerivativesOnIntegrationPoints(
     const Array<Real> & nodes, const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   const auto & natural_coords = integration_points(type, ghost_type);
   const auto spatial_dimension = mesh.getSpatialDimension();
   const auto natural_spatial_dimension =
       ElementClass<type>::getNaturalSpaceDimension();
   const auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   const auto nb_points = natural_coords.cols();
   const auto nb_dof = ElementClass<type>::getNbDegreeOfFreedom();
   const auto nb_element = mesh.getNbElement(type, ghost_type);
   const auto nb_stress_components = ElementClass<type>::getNbStressComponents();
 
   auto itp_type = FEEngine::getInterpolationType(type);
   if (not this->shapes_derivatives.exists(itp_type, ghost_type)) {
     auto size_of_shapesd = this->getShapeDerivativesSize(type);
     this->shapes_derivatives.alloc(0, size_of_shapesd, itp_type, ghost_type);
   }
 
   auto & rot_matrices = this->rotation_matrices(type, ghost_type);
 
   Array<Real> x_el(0, spatial_dimension * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, nodes, x_el, type, ghost_type);
 
   auto & shapesd = this->shapes_derivatives(itp_type, ghost_type);
   shapesd.resize(nb_element * nb_points);
 
 
   for (auto && tuple :
        zip(make_view(x_el, spatial_dimension, nb_nodes_per_element),
            make_view(shapesd, nb_stress_components,
                      nb_nodes_per_element * nb_dof, nb_points),
            make_view(rot_matrices, nb_dof, nb_dof))) {
     // compute shape derivatives
     auto & X = std::get<0>(tuple);
     auto & B = std::get<1>(tuple);
     auto & RDOFs = std::get<2>(tuple);
 
 
     // /!\ This is a temporary variable with no specified size for columns !
     // It is up to the element to resize
     Tensor3<Real> dnds(natural_spatial_dimension,
                        ElementClass<type>::interpolation_property::dnds_columns,
                        B.size(2));
     ElementClass<type>::computeDNDS(natural_coords, X, dnds);
 
     Tensor3<Real> J(natural_spatial_dimension, natural_coords.rows(), natural_coords.cols());
 
     // Computing the coordinates of the element in the natural space
     auto R = RDOFs.block(0, 0, spatial_dimension, spatial_dimension);
     Matrix<Real> T(B.size(1), B.size(1));
     T.block(RDOFs, 0, 0);
     T.block(RDOFs, RDOFs.rows(), RDOFs.rows());
 
     // Rotate to local basis
     auto x =
         (R * X).block(0, 0, natural_spatial_dimension, nb_nodes_per_element);
 
     ElementClass<type>::computeJMat(natural_coords, x, J);
     ElementClass<type>::computeShapeDerivatives(J, dnds, T, B);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeStructural<kind>::interpolateOnIntegrationPoints(
     const Array<Real> & in_u, Array<Real> & out_uq, UInt nb_dof,
     const GhostType & ghost_type, const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(out_uq.getNbComponent() == nb_dof,
                       "The output array shape is not correct");
 
   auto itp_type = FEEngine::getInterpolationType(type);
   const auto & shapes_ = shapes(itp_type, ghost_type);
 
   auto nb_element = mesh.getNbElement(type, ghost_type);
   auto nb_nodes_per_element = ElementClass<type>::getNbNodesPerElement();
   auto nb_quad_points_per_element = integration_points(type, ghost_type).cols();
 
   Array<Real> u_el(0, nb_nodes_per_element * nb_dof);
   FEEngine::extractNodalToElementField(mesh, in_u, u_el, type, ghost_type,
                                        filter_elements);
 
   auto nb_quad_points = nb_quad_points_per_element * u_el.size();
   out_uq.resize(nb_quad_points);
 
   auto out_it = out_uq.begin_reinterpret(nb_dof, 1, nb_quad_points_per_element,
                                          u_el.size());
   auto shapes_it =
       shapes_.begin_reinterpret(nb_dof, nb_dof * nb_nodes_per_element,
                                 nb_quad_points_per_element, nb_element);
   auto u_it = u_el.begin_reinterpret(nb_dof * nb_nodes_per_element, 1,
                                      nb_quad_points_per_element, u_el.size());
 
   for_each_element(nb_element, filter_elements, [&](auto && el) {
     auto & uq = *out_it;
     const auto & u = *u_it;
     auto N = Tensor3<Real>(shapes_it[el]);
 
     for (auto && q : arange(uq.size(2))) {
       auto uq_q = Matrix<Real>(uq(q));
       auto u_q = Matrix<Real>(u(q));
       auto N_q = Matrix<Real>(N(q));
 
       uq_q.mul<false, false>(N_q, u_q);
     }
 
     ++out_it;
     ++u_it;
   });
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeStructural<kind>::gradientOnIntegrationPoints(
     const Array<Real> & in_u, Array<Real> & out_nablauq, UInt nb_dof,
     const GhostType & ghost_type, const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   auto itp_type = FEEngine::getInterpolationType(type);
   const auto & shapesd = shapes_derivatives(itp_type, ghost_type);
 
   auto nb_element = mesh.getNbElement(type, ghost_type);
   auto element_dimension = ElementClass<type>::getSpatialDimension();
   auto nb_quad_points_per_element = integration_points(type, ghost_type).cols();
   auto nb_nodes_per_element = ElementClass<type>::getNbNodesPerElement();
 
   Array<Real> u_el(0, nb_nodes_per_element * nb_dof);
   FEEngine::extractNodalToElementField(mesh, in_u, u_el, type, ghost_type,
                                        filter_elements);
 
   auto nb_quad_points = nb_quad_points_per_element * u_el.size();
   out_nablauq.resize(nb_quad_points);
 
   auto out_it = out_nablauq.begin_reinterpret(
       element_dimension, 1, nb_quad_points_per_element, u_el.size());
   auto shapesd_it = shapesd.begin_reinterpret(
       element_dimension, nb_dof * nb_nodes_per_element,
       nb_quad_points_per_element, nb_element);
   auto u_it = u_el.begin_reinterpret(nb_dof * nb_nodes_per_element, 1,
                                      nb_quad_points_per_element, u_el.size());
 
   for_each_element(nb_element, filter_elements, [&](auto && el) {
     auto & nablau = *out_it;
     const auto & u = *u_it;
     auto B = Tensor3<Real>(shapesd_it[el]);
 
     for (auto && q : arange(nablau.size(2))) {
       auto nablau_q = Matrix<Real>(nablau(q));
       auto u_q = Matrix<Real>(u(q));
       auto B_q = Matrix<Real>(B(q));
 
       nablau_q.mul<false, false>(B_q, u_q);
     }
 
     ++out_it;
     ++u_it;
   });
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_SHAPE_STRUCTURAL_INLINE_IMPL_CC__ */
diff --git a/src/geometry/mesh_segment_intersector_tmpl.hh b/src/geometry/mesh_segment_intersector_tmpl.hh
index ba60c2b23..73f27a071 100644
--- a/src/geometry/mesh_segment_intersector_tmpl.hh
+++ b/src/geometry/mesh_segment_intersector_tmpl.hh
@@ -1,283 +1,283 @@
 /**
  * @file   mesh_segment_intersector_tmpl.hh
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Clement Roux <clement.roux@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Apr 29 2015
  * @date last modification: Thu Jan 14 2016
  *
  * @brief  Computation of mesh intersection with segments
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MESH_SEGMENT_INTERSECTOR_TMPL_HH__
 #define __AKANTU_MESH_SEGMENT_INTERSECTOR_TMPL_HH__
 
 #include "aka_common.hh"
 #include "mesh_geom_common.hh"
 #include "tree_type_helper.hh"
 
 namespace akantu {
 
 template <UInt dim, ElementType type>
 MeshSegmentIntersector<dim, type>::MeshSegmentIntersector(Mesh & mesh,
                                                           Mesh & result_mesh)
     : parent_type(mesh), result_mesh(result_mesh), current_physical_name() {
   this->intersection_points = new Array<Real>(0, dim);
   this->constructData();
 }
 
 template <UInt dim, ElementType type>
 MeshSegmentIntersector<dim, type>::~MeshSegmentIntersector() {}
 
 template <UInt dim, ElementType type>
 void MeshSegmentIntersector<dim, type>::computeIntersectionQuery(
     const K::Segment_3 & query) {
   AKANTU_DEBUG_IN();
 
   result_mesh.addConnectivityType(_segment_2, _not_ghost);
   result_mesh.addConnectivityType(_segment_2, _ghost);
 
   std::list<result_type> result_list;
   std::set<std::pair<K::Segment_3, UInt>, segmentPairsLess> segment_set;
 
   this->factory.getTree().all_intersections(query,
                                             std::back_inserter(result_list));
   this->computeSegments(result_list, segment_set, query);
 
   // Arrays for storing nodes and connectivity
   Array<Real> & nodes = result_mesh.getNodes();
   Array<UInt> & connectivity = result_mesh.getConnectivity(_segment_2);
 
   // Arrays for storing associated element and physical name
   bool valid_elemental_data = true;
   Array<Element> * associated_element = NULL;
   Array<std::string> * associated_physical_name = NULL;
 
   try {
     associated_element =
         &result_mesh.getData<Element>("associated_element", _segment_2);
     associated_physical_name =
         &result_mesh.getData<std::string>("physical_names", _segment_2);
   } catch (debug::Exception & e) {
     valid_elemental_data = false;
   }
 
   std::set<pair_type, segmentPairsLess>::iterator it = segment_set.begin(),
                                                   end = segment_set.end();
 
   // Loop over the segment pairs
   for (; it != end; ++it) {
     if (!it->first.is_degenerate()) {
       Vector<UInt> segment_connectivity(2);
       segment_connectivity(0) = result_mesh.getNbNodes();
       segment_connectivity(1) = result_mesh.getNbNodes() + 1;
       connectivity.push_back(segment_connectivity);
 
       // Copy nodes
       Vector<Real> source(dim), target(dim);
       for (UInt j = 0; j < dim; j++) {
         source(j) = it->first.source()[j];
         target(j) = it->first.target()[j];
       }
 
       nodes.push_back(source);
       nodes.push_back(target);
 
       // Copy associated element info
       if (valid_elemental_data) {
         associated_element->push_back(Element{type, it->second, _not_ghost});
         associated_physical_name->push_back(current_physical_name);
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 template <UInt dim, ElementType type>
 void MeshSegmentIntersector<dim, type>::computeMeshQueryIntersectionPoint(
     const K::Segment_3 & /*query*/, UInt /*nb_old_nodes*/) {
-  AKANTU_DEBUG_ERROR("The method: computeMeshQueryIntersectionPoint has not "
+  AKANTU_ERROR("The method: computeMeshQueryIntersectionPoint has not "
                      "been implemented in class MeshSegmentIntersector!");
 }
 
 template <UInt dim, ElementType type>
 void MeshSegmentIntersector<dim, type>::buildResultFromQueryList(
     const std::list<K::Segment_3> & query_list) {
   AKANTU_DEBUG_IN();
 
   this->computeIntersectionQueryList(query_list);
 
   AKANTU_DEBUG_OUT();
 }
 
 template <UInt dim, ElementType type>
 void MeshSegmentIntersector<dim, type>::computeSegments(
     const std::list<result_type> & intersections,
     std::set<pair_type, segmentPairsLess> & segments,
     const K::Segment_3 & query) {
   AKANTU_DEBUG_IN();
 
   /*
    * Number of intersections = 0 means
    *
    * - query is completely outside mesh
    * - query is completely inside primitive
    *
    * We try to determine the case and still construct the segment list
    */
   if (intersections.size() == 0) {
     // We look at all the primitives intersected by two rays
     // If there is one primitive in common, then query is inside
     // that primitive
     K::Ray_3 ray1(query.source(), query.target());
     K::Ray_3 ray2(query.target(), query.source());
 
     std::set<UInt> ray1_results, ray2_results;
 
     this->factory.getTree().all_intersected_primitives(
         ray1, std::inserter(ray1_results, ray1_results.begin()));
     this->factory.getTree().all_intersected_primitives(
         ray2, std::inserter(ray2_results, ray2_results.begin()));
 
     bool inside_primitive = false;
     UInt primitive_id = 0;
 
     std::set<UInt>::iterator ray2_it = ray2_results.begin(),
                              ray2_end = ray2_results.end();
 
     // Test if first list contains an element of second list
     for (; ray2_it != ray2_end && !inside_primitive; ++ray2_it) {
       if (ray1_results.find(*ray2_it) != ray1_results.end()) {
         inside_primitive = true;
         primitive_id = *ray2_it;
       }
     }
 
     if (inside_primitive) {
       segments.insert(std::make_pair(query, primitive_id));
     }
   }
 
   else {
     typename std::list<result_type>::const_iterator it = intersections.begin(),
                                                     end = intersections.end();
 
     for (; it != end; ++it) {
       UInt el = (*it)->second;
 
       // Result of intersection is a segment
       if (const K::Segment_3 * segment =
               boost::get<K::Segment_3>(&((*it)->first))) {
         // Check if the segment was alread created
         segments.insert(std::make_pair(*segment, el));
       }
 
       // Result of intersection is a point
       else if (const K::Point_3 * point =
                    boost::get<K::Point_3>(&((*it)->first))) {
         // We only want to treat points differently if we're in 3D with Tetra4
         // elements This should be optimized by compilator
         if (dim == 3 && type == _tetrahedron_4) {
           UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
           TreeTypeHelper<Triangle<K>, K>::container_type facets;
 
           const Array<Real> & nodes = this->mesh.getNodes();
           Array<UInt>::const_vector_iterator connectivity_vec =
               this->mesh.getConnectivity(type).begin(nb_nodes_per_element);
 
           const Vector<UInt> & el_connectivity = connectivity_vec[el];
 
           Matrix<Real> node_coordinates(dim, nb_nodes_per_element);
           for (UInt i = 0; i < nb_nodes_per_element; i++)
             for (UInt j = 0; j < dim; j++)
               node_coordinates(j, i) = nodes(el_connectivity(i), j);
 
           this->factory.addPrimitive(node_coordinates, el, facets);
 
           // Local tree
           TreeTypeHelper<Triangle<K>, K>::tree * local_tree =
               new TreeTypeHelper<Triangle<K>, K>::tree(facets.begin(),
                                                        facets.end());
 
           // Compute local intersections (with current element)
           std::list<result_type> local_intersections;
           local_tree->all_intersections(
               query, std::back_inserter(local_intersections));
 
           bool out_point_found = false;
           typename std::list<result_type>::const_iterator
               local_it = local_intersections.begin(),
               local_end = local_intersections.end();
 
           for (; local_it != local_end; ++local_it) {
             if (const K::Point_3 * local_point =
                     boost::get<K::Point_3>(&((*local_it)->first))) {
               if (!comparePoints(*point, *local_point)) {
                 K::Segment_3 seg(*point, *local_point);
                 segments.insert(std::make_pair(seg, el));
                 out_point_found = true;
               }
             }
           }
 
           if (!out_point_found) {
             TreeTypeHelper<Triangle<K>, K>::point_type a(
                 node_coordinates(0, 0), node_coordinates(1, 0),
                 node_coordinates(2, 0)),
                 b(node_coordinates(0, 1), node_coordinates(1, 1),
                   node_coordinates(2, 1)),
                 c(node_coordinates(0, 2), node_coordinates(1, 2),
                   node_coordinates(2, 2)),
                 d(node_coordinates(0, 3), node_coordinates(1, 3),
                   node_coordinates(2, 3));
             K::Tetrahedron_3 tetra(a, b, c, d);
             const K::Point_3 * inside_point = NULL;
             if (tetra.has_on_bounded_side(query.source()) &&
                 !tetra.has_on_boundary(query.source()))
               inside_point = &query.source();
             else if (tetra.has_on_bounded_side(query.target()) &&
                      !tetra.has_on_boundary(query.target()))
               inside_point = &query.target();
 
             if (inside_point) {
               K::Segment_3 seg(*inside_point, *point);
               segments.insert(std::make_pair(seg, el));
             }
           }
 
           delete local_tree;
         }
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
 
 #endif // __AKANTU_MESH_SEGMENT_INTERSECTOR_TMPL_HH__
diff --git a/src/geometry/mesh_sphere_intersector.hh b/src/geometry/mesh_sphere_intersector.hh
index 776bd29c2..7cac489cb 100644
--- a/src/geometry/mesh_sphere_intersector.hh
+++ b/src/geometry/mesh_sphere_intersector.hh
@@ -1,119 +1,119 @@
 /**
  * @file   mesh_sphere_intersector.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Clement Roux <clement.roux@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue Jun 23 2015
  * @date last modification: Thu Jan 14 2016
  *
  * @brief  Computation of mesh intersection with sphere(s)
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MESH_SPHERE_INTERSECTOR_HH__
 #define __AKANTU_MESH_SPHERE_INTERSECTOR_HH__
 
 #include "aka_common.hh"
 #include "mesh_geom_intersector.hh"
 
 #include "mesh_geom_common.hh"
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 template <UInt dim, ElementType type>
 class MeshSphereIntersector
     : public MeshGeomIntersector<dim, type, Line_arc<cgal::Spherical>,
                                  cgal::Spherical::Sphere_3, cgal::Spherical> {
   using SK = cgal::Spherical;
   using K = cgal::Cartesian;
 
   /// Parent class type
   typedef MeshGeomIntersector<dim, type, Line_arc<SK>, SK::Sphere_3, SK>
       parent_type;
 
   /// Result of intersection function type
   typedef typename IntersectionTypeHelper<TreeTypeHelper<Triangle<K>, K>,
                                           K::Segment_3>::intersection_type
       result_type;
 
   /// Pair of intersection points and element id
   typedef std::pair<SK::Circular_arc_point_3, UInt> pair_type;
 
 public:
   /// Construct from mesh
   explicit MeshSphereIntersector(Mesh & mesh);
 
   /// Destructor
   virtual ~MeshSphereIntersector();
 
 public:
   /// Construct the primitive tree object
   virtual void constructData(GhostType ghost_type = _not_ghost);
 
   /**
    * @brief Computes the intersection of the mesh with a sphere
    *
    * @param query (sphere) to compute the intersections with the mesh
    */
   virtual void computeIntersectionQuery(const SK::Sphere_3 & /*query*/) {
-    AKANTU_DEBUG_ERROR("This function is not implemented for spheres (It was "
+    AKANTU_ERROR("This function is not implemented for spheres (It was "
                        "to generic and has been replaced by "
                        "computeMeshQueryIntersectionPoint");
   }
 
   /// Compute intersection points between the mesh primitives (segments) and a
   /// query (surface in 3D or a curve in 2D), double intersection points for the
   /// same primitives are not considered. A maximum is set to the number of
   /// intersection nodes per element: 2 in 2D and 4 in 3D
   virtual void computeMeshQueryIntersectionPoint(const SK::Sphere_3 & query,
                                                  UInt nb_old_nodes);
 
   /// Build the IGFEM mesh
   virtual void
   buildResultFromQueryList(const std::list<SK::Sphere_3> & /*query*/) {
-    AKANTU_DEBUG_ERROR("This function is no longer implemented to split "
+    AKANTU_ERROR("This function is no longer implemented to split "
                        "geometrical operations and dedicated result "
                        "construction");
   }
 
   /// Set the tolerance
   void setToleranceIntersectionOnNode(UInt tol) {
     this->tol_intersection_on_node = tol;
   }
 
 protected:
   /// tolerance for which the intersection is considered on the mesh node
   /// (relative to the segment lenght)
   Real tol_intersection_on_node;
 };
 
 } // akantu
 
 #include "mesh_sphere_intersector_tmpl.hh"
 
 #endif // __AKANTU_MESH_SPHERE_INTERSECTOR_HH__
diff --git a/src/geometry/mesh_sphere_intersector_tmpl.hh b/src/geometry/mesh_sphere_intersector_tmpl.hh
index ab6dc705a..d95d86710 100644
--- a/src/geometry/mesh_sphere_intersector_tmpl.hh
+++ b/src/geometry/mesh_sphere_intersector_tmpl.hh
@@ -1,195 +1,195 @@
 /**
  * @file   mesh_sphere_intersector_tmpl.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Clement Roux <clement.roux@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue Jun 23 2015
  * @date last modification: Thu Jan 14 2016
  *
  * @brief  Computation of mesh intersection with spheres
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MESH_SPHERE_INTERSECTOR_TMPL_HH__
 #define __AKANTU_MESH_SPHERE_INTERSECTOR_TMPL_HH__
 
 #include "aka_common.hh"
 #include "mesh_geom_common.hh"
 #include "tree_type_helper.hh"
 #include "mesh_sphere_intersector.hh"
 
 namespace akantu {
 
 template<UInt dim, ElementType type>
 MeshSphereIntersector<dim, type>::MeshSphereIntersector(Mesh & mesh):
   parent_type(mesh),
   tol_intersection_on_node(1e-10)
 {
 #if defined(AKANTU_IGFEM)
   if( (type == _triangle_3) || (type == _igfem_triangle_4) || (type == _igfem_triangle_5) ){
     const_cast<UInt &>(this->nb_seg_by_el) = 3;
   } else {
-    AKANTU_DEBUG_ERROR("Not ready for mesh type " << type);
+    AKANTU_ERROR("Not ready for mesh type " << type);
   }
 #else
   if( (type != _triangle_3) )
-    AKANTU_DEBUG_ERROR("Not ready for mesh type " << type);
+    AKANTU_ERROR("Not ready for mesh type " << type);
 #endif
 
   // initialize the intersection pointsss array with the spatial dimension
   this->intersection_points = new Array<Real>(0,dim);
   //  A maximum is set to the number of intersection nodes per element to limit the size of new_node_per_elem: 2 in 2D and 4 in 3D
   this->new_node_per_elem = new Array<UInt>(0, 1 + 4 * (dim-1));
 }
 
 template<UInt dim, ElementType type>
 MeshSphereIntersector<dim, type>::~MeshSphereIntersector() {
   delete this->new_node_per_elem;
   delete this->intersection_points;
 }
 
 template<UInt dim, ElementType type>
 void MeshSphereIntersector<dim, type>::constructData(GhostType ghost_type) {
 
   this->new_node_per_elem->resize(this->mesh.getNbElement(type, ghost_type));
   this->new_node_per_elem->clear();
 
   MeshGeomIntersector<dim, type, Line_arc<SK>, SK::Sphere_3, SK>::constructData(ghost_type);
 }
 
 template<UInt dim, ElementType type>
 void MeshSphereIntersector<dim, type>:: computeMeshQueryIntersectionPoint(const SK::Sphere_3 & query,
 									  UInt nb_old_nodes) {
   /// function to replace computeIntersectionQuery in a more generic geometry module version
   // The newNodeEvent is not send from this method who only compute the intersection points
   AKANTU_DEBUG_IN();
 
   Array<Real> & nodes = this->mesh.getNodes();
   UInt nb_node = nodes.size() + this->intersection_points->size();
 
   // Tolerance for proximity checks should be defined by user
   Real global_tolerance = Math::getTolerance();
   Math::setTolerance(tol_intersection_on_node);
   typedef boost::variant<pair_type> sk_inter_res;
 
   TreeTypeHelper<Line_arc<cgal::Spherical>, cgal::Spherical>::const_iterator
     it = this->factory.getPrimitiveList().begin(),
     end= this->factory.getPrimitiveList().end();
 
   for (; it != end ; ++it) { // loop on the primitives (segments)
     std::list<sk_inter_res> s_results;
     CGAL::intersection(*it, query, std::back_inserter(s_results));
 
     if (s_results.size() == 1) { // just one point
       if (pair_type * pair = boost::get<pair_type>(&s_results.front())) {
         if (pair->second == 1) { // not a point tangent to the sphere
           // the intersection point written as a vector
           Vector<Real> new_node(dim, 0.0);
           cgal::Cartesian::Point_3 point(CGAL::to_double(pair->first.x()),
                                    CGAL::to_double(pair->first.y()),
                                    CGAL::to_double(pair->first.z()));
           for (UInt i = 0 ; i < dim ; i++) {
             new_node(i) = point[i];
           }
 
 	  /// boolean to decide wheter intersection point is on a standard node of the mesh or not
           bool is_on_mesh = false;
 	  /// boolean to decide if this intersection point has been already computed for a neighbor element
 	  bool is_new = true;
         
 	  /// check if intersection point has already been computed
 	  UInt n = nb_old_nodes;
 
           // check if we already compute this intersection and add it as a node for a neighboor element of another type
 	  Array<Real>::vector_iterator existing_node = nodes.begin(dim);
 
 	  for (; n < nodes.size() ; ++n) {// loop on the nodes from nb_old_nodes
 	    if (Math::are_vector_equal(dim, new_node.storage(), existing_node[n].storage())) {
 	      is_new = false;
 	      break;
 	    }
 	  }
 	  if(is_new){
 	    Array<Real>::vector_iterator intersection_points_it = this->intersection_points->begin(dim);
 	    Array<Real>::vector_iterator intersection_points_end = this->intersection_points->end(dim);
 	    for (; intersection_points_it != intersection_points_end ; ++intersection_points_it, ++n) {
 	      if (Math::are_vector_equal(dim, new_node.storage(), intersection_points_it->storage())) {
 		is_new = false;
 		break;
 	      }
 	    }
 	  }
 	  
 	  // get the initial and final points of the primitive (segment) and write them as vectors
 	  cgal::Cartesian::Point_3 source_cgal(CGAL::to_double(it->source().x()),
 					 CGAL::to_double(it->source().y()),
 					 CGAL::to_double(it->source().z()));
 	  cgal::Cartesian::Point_3 target_cgal(CGAL::to_double(it->target().x()),
 					 CGAL::to_double(it->target().y()),
 					 CGAL::to_double(it->target().z()));
 	  Vector<Real> source(dim), target(dim);
 	  for (UInt i = 0 ; i < dim ; i++) {
 	    source(i) = source_cgal[i];
 	    target(i) = target_cgal[i];
 	  }
 
 	  // Check if we are close from a node of the primitive (segment)
 	  if (Math::are_vector_equal(dim, source.storage(), new_node.storage()) ||
 	      Math::are_vector_equal(dim, target.storage(), new_node.storage())) {
 	    is_on_mesh = true;
 	    is_new = false;
 	  }
 
 	  if (is_new) {// if the intersection point is a new one add it to the list
 	    this->intersection_points->push_back(new_node);
 	    nb_node++;
 	  }
 
 	  // deduce the element id
 	  UInt element_id = it->id();
 
 	  // fill the new_node_per_elem array
 	  if (!is_on_mesh) { // if the node is not on a mesh node
 	    UInt & nb_new_nodes_per_el = (*this->new_node_per_elem)(element_id, 0);
 	    nb_new_nodes_per_el += 1;
 	    AKANTU_DEBUG_ASSERT(2 * nb_new_nodes_per_el < this->new_node_per_elem->getNbComponent(),
 				"You might have to interface crossing the same material");
 	    (*this->new_node_per_elem)(element_id, (2 * nb_new_nodes_per_el) - 1) = n;
 	    (*this->new_node_per_elem)(element_id, 2 * nb_new_nodes_per_el) = it->segId();
 	  } 
 	}
       }
     }
   }
 
   Math::setTolerance(global_tolerance);
 
   AKANTU_DEBUG_OUT();
 }
 
 } // akantu
 
 #endif // __AKANTU_MESH_SPHERE_INTERSECTOR_TMPL_HH__
diff --git a/src/io/dumper/dumpable.cc b/src/io/dumper/dumpable.cc
index 12a692aa6..04997c49c 100644
--- a/src/io/dumper/dumpable.cc
+++ b/src/io/dumper/dumpable.cc
@@ -1,285 +1,285 @@
 /**
  * @file   dumpable.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Thu Jan 21 2016
  *
  * @brief  Implementation of the dumpable interface
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 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 "dumpable.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifdef AKANTU_USE_IOHELPER
 
 #include <io_helper.hh>
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Dumpable::Dumpable() : default_dumper("") {}
 
 /* -------------------------------------------------------------------------- */
 Dumpable::~Dumpable() {
 
   auto it = dumpers.begin();
   auto end = dumpers.end();
 
   for (; it != end; ++it) {
     delete it->second;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::registerExternalDumper(DumperIOHelper & dumper,
                                       const std::string & dumper_name,
                                       const bool is_default) {
   this->dumpers[dumper_name] = &dumper;
   if (is_default)
     this->default_dumper = dumper_name;
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpMesh(const Mesh & mesh, UInt spatial_dimension,
                            const GhostType & ghost_type,
                            const ElementKind & element_kind) {
 
   this->addDumpMeshToDumper(this->default_dumper, mesh, spatial_dimension,
                             ghost_type, element_kind);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpMeshToDumper(const std::string & dumper_name,
                                    const Mesh & mesh, UInt spatial_dimension,
                                    const GhostType & ghost_type,
                                    const ElementKind & element_kind) {
 
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerMesh(mesh, spatial_dimension, ghost_type, element_kind);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFilteredMesh(
     const Mesh & mesh, const ElementTypeMapArray<UInt> & elements_filter,
     const Array<UInt> & nodes_filter, UInt spatial_dimension,
     const GhostType & ghost_type, const ElementKind & element_kind) {
   this->addDumpFilteredMeshToDumper(this->default_dumper, mesh, elements_filter,
                                     nodes_filter, spatial_dimension, ghost_type,
                                     element_kind);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFilteredMeshToDumper(
     const std::string & dumper_name, const Mesh & mesh,
     const ElementTypeMapArray<UInt> & elements_filter,
     const Array<UInt> & nodes_filter, UInt spatial_dimension,
     const GhostType & ghost_type, const ElementKind & element_kind) {
 
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerFilteredMesh(mesh, elements_filter, nodes_filter,
                               spatial_dimension, ghost_type, element_kind);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpField(const std::string & field_id) {
   this->addDumpFieldToDumper(this->default_dumper, field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldToDumper(__attribute__((unused))
                                     const std::string & dumper_name,
                                     __attribute__((unused))
                                     const std::string & field_id) {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldExternal(const std::string & field_id,
                                     dumper::Field * field) {
   this->addDumpFieldExternalToDumper(this->default_dumper, field_id, field);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldExternalToDumper(const std::string & dumper_name,
                                             const std::string & field_id,
                                             dumper::Field * field) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerField(field_id, field);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Dumpable::removeDumpField(const std::string & field_id) {
   this->removeDumpFieldFromDumper(this->default_dumper, field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::removeDumpFieldFromDumper(const std::string & dumper_name,
                                          const std::string & field_id) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.unRegisterField(field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldVector(const std::string & field_id) {
   this->addDumpFieldVectorToDumper(this->default_dumper, field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldVectorToDumper(__attribute__((unused))
                                           const std::string & dumper_name,
                                           __attribute__((unused))
                                           const std::string & field_id) {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldTensor(const std::string & field_id) {
   this->addDumpFieldTensorToDumper(this->default_dumper, field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldTensorToDumper(__attribute__((unused))
                                           const std::string & dumper_name,
                                           __attribute__((unused))
                                           const std::string & field_id) {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setDirectory(const std::string & directory) {
   this->setDirectoryToDumper(this->default_dumper, directory);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setDirectoryToDumper(const std::string & dumper_name,
                                     const std::string & directory) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.setDirectory(directory);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setBaseName(const std::string & basename) {
   this->setBaseNameToDumper(this->default_dumper, basename);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setBaseNameToDumper(const std::string & dumper_name,
                                    const std::string & basename) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.setBaseName(basename);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setTimeStepToDumper(Real time_step) {
   this->setTimeStepToDumper(this->default_dumper, time_step);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setTimeStepToDumper(const std::string & dumper_name,
                                    Real time_step) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.setTimeStep(time_step);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Dumpable::setTextModeToDumper(const std::string & dumper_name) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.getDumper().setMode(iohelper::TEXT);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setTextModeToDumper() {
   DumperIOHelper & dumper = this->getDumper(this->default_dumper);
   dumper.getDumper().setMode(iohelper::TEXT);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Dumpable::dump(const std::string & dumper_name) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.dump();
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::dump() { this->dump(this->default_dumper); }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::dump(const std::string & dumper_name, UInt step) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.dump(step);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::dump(UInt step) { this->dump(this->default_dumper, step); }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::dump(const std::string & dumper_name, Real time, UInt step) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.dump(time, step);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::dump(Real time, UInt step) {
   this->dump(this->default_dumper, time, step);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::internalAddDumpFieldToDumper(const std::string & dumper_name,
                                             const std::string & field_id,
                                             dumper::Field * field) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerField(field_id, field);
 }
 
 /* -------------------------------------------------------------------------- */
 DumperIOHelper & Dumpable::getDumper() {
   return this->getDumper(this->default_dumper);
 }
 
 /* -------------------------------------------------------------------------- */
 DumperIOHelper & Dumpable::getDumper(const std::string & dumper_name) {
 
   auto it = this->dumpers.find(dumper_name);
   auto end = this->dumpers.end();
 
   if (it == end)
     AKANTU_EXCEPTION("Dumper " << dumper_name
                                << "has not been registered, yet.");
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 
 std::string Dumpable::getDefaultDumperName() const {
   return this->default_dumper;
 }
 
 } // akantu
 
 #endif
diff --git a/src/io/dumper/dumpable_dummy.hh b/src/io/dumper/dumpable_dummy.hh
index ae8f5551b..3b6ca9686 100644
--- a/src/io/dumper/dumpable_dummy.hh
+++ b/src/io/dumper/dumpable_dummy.hh
@@ -1,252 +1,252 @@
 /**
  * @file   dumpable_dummy.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Oct 26 2012
  * @date last modification: Fri Aug 21 2015
  *
  * @brief  Interface for object who wants to dump themselves
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_DUMPABLE_DUMMY_HH__
 #define __AKANTU_DUMPABLE_DUMMY_HH__
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused"
 
 namespace dumper {
   class Field;
 }
 
 class DumperIOHelper;
 class Mesh;
 
 /* -------------------------------------------------------------------------- */
 class Dumpable {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
 
   Dumpable() {};
   virtual ~Dumpable() { };
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   template<class T>
   inline void registerDumper(const std::string & dumper_name,
                       const std::string & file_name = "",
                       const bool is_default = false) { }
 
   void registerExternalDumper(DumperIOHelper * dumper,
                               const std::string & dumper_name,
                               const bool is_default = false) { }
 
   void addDumpMesh(const Mesh & mesh,
                    UInt spatial_dimension = _all_dimensions,
                    const GhostType & ghost_type = _not_ghost,
                    const ElementKind & element_kind = _ek_not_defined) {
   }
 
   void addDumpMeshToDumper(const std::string & dumper_name,
                            const Mesh & mesh,
                            UInt spatial_dimension = _all_dimensions,
                            const GhostType & ghost_type = _not_ghost,
                            const ElementKind & element_kind = _ek_not_defined) {
   }
 
   void addDumpFilteredMesh(const Mesh & mesh,
                            const ElementTypeMapArray<UInt> & elements_filter,
                            const Array<UInt> & nodes_filter,
                            UInt spatial_dimension = _all_dimensions,
                            const GhostType & ghost_type = _not_ghost,
                            const ElementKind & element_kind = _ek_not_defined) {
   }
 
   void addDumpFilteredMeshToDumper(const std::string & dumper_name,
                                    const Mesh & mesh,
                                    const ElementTypeMapArray<UInt> & elements_filter,
                                    const Array<UInt> & nodes_filter,
                                    UInt spatial_dimension = _all_dimensions,
                                    const GhostType & ghost_type = _not_ghost,
                                    const ElementKind & element_kind = _ek_not_defined) {
   }
 
   virtual void addDumpField(const std::string & field_id){
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
   virtual void addDumpFieldToDumper(const std::string & dumper_name,
                                     const std::string & field_id){
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   virtual void addDumpFieldExternal(const std::string & field_id,
                                     dumper::Field * field) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   virtual void addDumpFieldExternalToDumper(const std::string & dumper_name,
                                     const std::string & field_id,
                                     dumper::Field * field) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   template<typename T>
   void addDumpFieldExternal(const std::string & field_id,
                             const Array<T> & field) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   template<typename T>
   void addDumpFieldExternalToDumper(const std::string & dumper_name,
                                     const std::string & field_id,
                                     const Array<T> & field) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   template<typename T>
   void addDumpFieldExternal(const std::string & field_id,
                             const ElementTypeMapArray<T> & field,
                             UInt spatial_dimension = _all_dimensions,
                             const GhostType & ghost_type = _not_ghost,
                             const ElementKind & element_kind = _ek_not_defined) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   template<typename T>
   void addDumpFieldExternalToDumper(const std::string & dumper_name,
                                     const std::string & field_id,
                                     const ElementTypeMapArray<T> & field,
                                     UInt spatial_dimension = _all_dimensions,
                                     const GhostType & ghost_type = _not_ghost,
                                     const ElementKind & element_kind = _ek_not_defined) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   void removeDumpField(const std::string & field_id) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   void removeDumpFieldFromDumper(const std::string & dumper_name,
                                const std::string & field_id) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   void setDirecory(const std::string & directory) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   void setDirectoryToDumper(const std::string & dumper_name,
                             const std::string & directory) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   void setBaseName(const std::string & basename) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   void setBaseNameToDumper(const std::string & dumper_name,
                            const std::string & basename) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   void setTextModeToDumper(const std::string & dumper_name){
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   void setTextModeToDumper(){
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
 
   void dump() {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   void dump(const std::string & dumper_name) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   void dump(UInt step) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   void dump(const std::string & dumper_name,
             UInt step) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   void dump(Real current_time,
             UInt step) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   void dump(const std::string & dumper_name,
             Real current_time,
             UInt step) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
 protected:
 
   void internalAddDumpFieldToDumper(const std::string & dumper_name,
                                     const std::string & field_id,
                                     dumper::Field * field) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
 protected:
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
 
   DumperIOHelper & getDumper() {
-    AKANTU_DEBUG_ERROR("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
+    AKANTU_ERROR("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   DumperIOHelper & getDumper(const std::string & dumper_name){
-    AKANTU_DEBUG_ERROR("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
+    AKANTU_ERROR("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   template<class T>
   T & getDumper(const std::string & dumper_name) {
-    AKANTU_DEBUG_ERROR("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
+    AKANTU_ERROR("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   std::string getDefaultDumperName() {
-    AKANTU_DEBUG_ERROR("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
+    AKANTU_ERROR("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
 };
 
 #pragma GCC diagnostic pop
 
 } // akantu
 
 #endif /* __AKANTU_DUMPABLE_DUMMY_HH__ */
diff --git a/src/io/dumper/dumper_field.hh b/src/io/dumper/dumper_field.hh
index 0164045e9..66544d73e 100644
--- a/src/io/dumper/dumper_field.hh
+++ b/src/io/dumper/dumper_field.hh
@@ -1,137 +1,137 @@
 /**
  * @file   dumper_field.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  Common interface for fields
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 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/>.
  *
  */
 
 #ifndef __AKANTU_DUMPER_FIELD_HH__
 #define __AKANTU_DUMPER_FIELD_HH__
 /* -------------------------------------------------------------------------- */
 #include "dumper_iohelper.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 __BEGIN_AKANTU_DUMPER__
 /* -------------------------------------------------------------------------- */
 class FieldComputeProxy;
 class FieldComputeBaseInterface;
 class ComputeFunctorInterface;
 class HomogenizerProxy;
 /* -------------------------------------------------------------------------- */
 
 /// Field interface
 class Field {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   Field() = default;
   virtual ~Field() = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
 #ifdef AKANTU_USE_IOHELPER
   /// register this to the provided dumper
   virtual void registerToDumper(const std::string & id,
                                 iohelper::Dumper & dumper) = 0;
 #endif
 
   /// set the number of data per item (used for elements fields at the moment)
   virtual void setNbData(__attribute__((unused)) UInt nb_data) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   };
 
   /// set the number of data per elem (used for elements fields at the moment)
   virtual void setNbDataPerElem(__attribute__((unused))
                                 const ElementTypeMap<UInt> & nb_data) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   };
 
   /// set the number of data per elem (used for elements fields at the moment)
   virtual void setNbDataPerElem(__attribute__((unused)) UInt nb_data) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   };
 
   /// get the number of components of the hosted field
   virtual ElementTypeMap<UInt>
   getNbComponents(__attribute__((unused)) UInt dim = _all_dimensions,
                   __attribute__((unused)) GhostType ghost_type = _not_ghost,
                   __attribute__((unused)) ElementKind kind = _ek_not_defined) {
     throw;
   };
 
   /// for connection to a FieldCompute
   inline virtual Field * connect(__attribute__((unused))
                                  FieldComputeProxy & proxy) {
     throw;
   };
 
   /// for connection to a FieldCompute
   inline virtual ComputeFunctorInterface * connect(__attribute__((unused))
                                                    HomogenizerProxy & proxy) {
     throw;
   };
 
   /// check if the same quantity of data for all element types
   virtual void checkHomogeneity() = 0;
 
   /// return the dumper name
   std::string getGroupName() { return group_name; };
 
   /// return the id of the field
   std::string getID() { return field_id; };
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// return the flag to know if the field is homogeneous/contiguous
   virtual bool isHomogeneous() { return homogeneous; }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// the flag to know if it is homogeneous
   bool homogeneous{false};
 
   /// the name of the group it was associated to
   std::string group_name;
 
   /// the name of the dumper it was associated to
   std::string field_id;
 };
 
 /* -------------------------------------------------------------------------- */
 
 __END_AKANTU_DUMPER__
 } // akantu
 
 #endif /* __AKANTU_DUMPER_FIELD_HH__ */
diff --git a/src/io/dumper/dumper_iohelper.cc b/src/io/dumper/dumper_iohelper.cc
index 534c2bad2..4024bf9ba 100644
--- a/src/io/dumper/dumper_iohelper.cc
+++ b/src/io/dumper/dumper_iohelper.cc
@@ -1,305 +1,305 @@
 /**
  * @file   dumper_iohelper.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Oct 26 2012
  * @date last modification: Thu Sep 17 2015
  *
  * @brief  implementation of DumperIOHelper
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 <io_helper.hh>
 
 #include "dumper_iohelper.hh"
 #include "dumper_elemental_field.hh"
 #include "dumper_nodal_field.hh"
 #include "dumper_filtered_connectivity.hh"
 #include "dumper_variable.hh"
 #include "mesh.hh"
 #if defined(AKANTU_IGFEM)
 #include "dumper_igfem_connectivity.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 DumperIOHelper::DumperIOHelper() = default;
 
 /* -------------------------------------------------------------------------- */
 DumperIOHelper::~DumperIOHelper() {
   for (auto it = fields.begin(); it != fields.end(); ++it) {
     delete it->second;
   }
 
   delete dumper;
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::setParallelContext(bool is_parallel) {
   UInt whoami  = Communicator::getStaticCommunicator().whoAmI();
   UInt nb_proc = Communicator::getStaticCommunicator().getNbProc();
 
   if(is_parallel)
     dumper->setParallelContext(whoami, nb_proc);
   else
     dumper->setParallelContext(0, 1);
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::setDirectory(const std::string & directory) {
   this->directory = directory;
   dumper->setPrefix(directory);
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::setBaseName(const std::string & basename) {
   filename = basename;
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::setTimeStep(Real time_step) {
   if(!time_activated)
     this->dumper->activateTimeDescFiles(time_step);
   else
     this->dumper->setTimeStep(time_step);
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::dump() {
   try {
     dumper->dump(filename, count);
   } catch (iohelper::IOHelperException & e) {
-    AKANTU_DEBUG_ERROR("I was not able to dump your data with a Dumper: " << e.what());
+    AKANTU_ERROR("I was not able to dump your data with a Dumper: " << e.what());
   }
 
   ++count;
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::dump(UInt step) {
   this->count = step;
   this->dump();
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::dump(Real current_time, UInt step) {
   this->dumper->setCurrentTime(current_time);
   this->dump(step);
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::registerMesh(const Mesh & mesh,
 				  UInt spatial_dimension,
 				  const GhostType & ghost_type,
 				  const ElementKind & element_kind) {
 
 #if defined(AKANTU_IGFEM)
   if (element_kind == _ek_igfem) {
     registerField("connectivities",
 		  new dumper::IGFEMConnectivityField(mesh.getConnectivities(),
 						     spatial_dimension,
 						     ghost_type));
   } else
 #endif
   
     registerField("connectivities",
 		  new dumper::ElementalField<UInt>(mesh.getConnectivities(),
 						   spatial_dimension,
 						   ghost_type,
 						   element_kind));
 
   registerField("positions",
 		new dumper::NodalField<Real>(mesh.getNodes()));
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::registerFilteredMesh(const Mesh & mesh,
 					  const ElementTypeMapArray<UInt> & elements_filter,
 					  const Array<UInt> & nodes_filter,
 					  UInt spatial_dimension,
 					  const GhostType & ghost_type,
 					  const ElementKind & element_kind) {
   auto * f_connectivities = new ElementTypeMapArrayFilter<UInt>(
       mesh.getConnectivities(), elements_filter);
 
   this->registerField("connectivities",
                       new dumper::FilteredConnectivityField(*f_connectivities,
                                                             nodes_filter,
                                                             spatial_dimension,
                                                             ghost_type,
                                                             element_kind));
 
   this->registerField("positions",new dumper::NodalField<Real,true>(
                                                                     mesh.getNodes(),
                                                                     0,
                                                                     0,
                                                                     &nodes_filter));
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::registerField(const std::string & field_id,
                                    dumper::Field * field) {
   auto it = fields.find(field_id);
   if(it != fields.end()) {
     AKANTU_DEBUG_WARNING("The field " << field_id
 			 << " is already registered in this Dumper. Field ignored.");
     return;
   }
 
   fields[field_id] = field;
   field->registerToDumper(field_id, *dumper);
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::unRegisterField(const std::string & field_id) {
   auto it = fields.find(field_id);
   if(it == fields.end()) {
     AKANTU_DEBUG_WARNING("The field " << field_id
 			 << " is not registered in this Dumper. Nothing to do.");
     return;
   }
 
   delete it->second;
   fields.erase(it);
 }
 
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::registerVariable(const std::string & variable_id,
                                       dumper::VariableBase * variable) {
   auto it = variables.find(variable_id);
 
   if(it != variables.end()) {
     AKANTU_DEBUG_WARNING("The Variable " << variable_id
 			 << " is already registered in this Dumper. Variable ignored.");
     return;
   }
 
   variables[variable_id] = variable;
   variable->registerToDumper(variable_id, *dumper);
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::unRegisterVariable(const std::string & variable_id) {
   auto it = variables.find(variable_id);
 
   if(it == variables.end()) {
     AKANTU_DEBUG_WARNING("The variable " << variable_id
 			 << " is not registered in this Dumper. Nothing to do.");
     return;
   }
 
   delete it->second;
   variables.erase(it);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 iohelper::ElemType getIOHelperType() {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
   return iohelper::MAX_ELEM_TYPE;
 }
 
 template <>
 iohelper::ElemType getIOHelperType<_point_1>() { return iohelper::POINT_SET; }
 template <>
 iohelper::ElemType getIOHelperType<_segment_2>() { return iohelper::LINE1; }
 template <>
 iohelper::ElemType getIOHelperType<_segment_3>() { return iohelper::LINE2; }
 
 template <>
 iohelper::ElemType getIOHelperType<_triangle_3>() { return iohelper::TRIANGLE1; }
 template <>
 iohelper::ElemType getIOHelperType<_triangle_6>() { return iohelper::TRIANGLE2; }
 
 template <>
 iohelper::ElemType getIOHelperType<_quadrangle_4>() { return iohelper::QUAD1; }
 template <>
 iohelper::ElemType getIOHelperType<_quadrangle_8>() { return iohelper::QUAD2; }
 
 template <>
 iohelper::ElemType getIOHelperType<_tetrahedron_4>()  { return iohelper::TETRA1; }
 template <>
 iohelper::ElemType getIOHelperType<_tetrahedron_10>() { return iohelper::TETRA2; }
 
 template <>
 iohelper::ElemType getIOHelperType<_hexahedron_8>()  { return iohelper::HEX1; }
 template <>
 iohelper::ElemType getIOHelperType<_hexahedron_20>() { return iohelper::HEX2; }
 
 template <>
 iohelper::ElemType getIOHelperType<_pentahedron_6>() { return iohelper::PRISM1; }
 template <>
 iohelper::ElemType getIOHelperType<_pentahedron_15>() { return iohelper::PRISM2; }
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
 template <>
 iohelper::ElemType getIOHelperType<_cohesive_1d_2>() { return iohelper::COH1D2; }
 
 template <>
 iohelper::ElemType getIOHelperType<_cohesive_2d_4>() { return iohelper::COH2D4; }
 template <>
 iohelper::ElemType getIOHelperType<_cohesive_2d_6>() { return iohelper::COH2D6; }
 
 template <>
 iohelper::ElemType getIOHelperType<_cohesive_3d_6>() { return iohelper::COH3D6; }
 template <>
 iohelper::ElemType getIOHelperType<_cohesive_3d_12>() { return iohelper::COH3D12; }
 
 template <>
 iohelper::ElemType getIOHelperType<_cohesive_3d_8>() { return iohelper::COH3D8; }
 //template <>
 //iohelper::ElemType getIOHelperType<_cohesive_3d_16>() { return iohelper::COH3D16; }
 #endif
 
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
 template <>
 iohelper::ElemType getIOHelperType<_bernoulli_beam_2>() { return iohelper::BEAM2; }
 template <>
 iohelper::ElemType getIOHelperType<_bernoulli_beam_3>() { return iohelper::BEAM3; }
 #endif
 
 /* -------------------------------------------------------------------------- */
 UInt getIOHelperType(ElementType type) {
   UInt ioh_type = iohelper::MAX_ELEM_TYPE;
 #define GET_IOHELPER_TYPE(type)			\
   ioh_type = getIOHelperType<type>();
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_IOHELPER_TYPE);
 #undef GET_IOHELPER_TYPE
   return ioh_type;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
 
 namespace iohelper {
   template<>
   DataType getDataType<akantu::NodeType>() { return _int; }
 }
diff --git a/src/io/mesh_io/mesh_io_abaqus.cc b/src/io/mesh_io/mesh_io_abaqus.cc
index 10d3c1f6f..5788b76db 100644
--- a/src/io/mesh_io/mesh_io_abaqus.cc
+++ b/src/io/mesh_io/mesh_io_abaqus.cc
@@ -1,475 +1,475 @@
 /**
  * @file   mesh_io_abaqus.cc
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jan 04 2013
  * @date last modification: Fri Dec 11 2015
  *
  * @brief  read a mesh from an abaqus input file
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 // std library header files
 #include <fstream>
 
 // akantu header files
 #include "mesh.hh"
 #include "mesh_io_abaqus.hh"
 #include "mesh_utils.hh"
 
 #include "element_group.hh"
 #include "node_group.hh"
 
 #if defined(__INTEL_COMPILER)
 //#pragma warning ( disable : 383 )
 #elif defined(__clang__) // test clang to be sure that when we test for gnu it
                          // is only gnu
 #elif (defined(__GNUC__) || defined(__GNUG__))
 #define GCC_VERSION                                                            \
   (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
 #if GCC_VERSION > 40600
 #pragma GCC diagnostic push
 #endif
 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
 #endif
 
 /* -------------------------------------------------------------------------- */
 #include <boost/config/warning_disable.hpp>
 #include <boost/spirit/include/phoenix.hpp>
 #include <boost/spirit/include/qi.hpp>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 MeshIOAbaqus::MeshIOAbaqus() = default;
 
 /* -------------------------------------------------------------------------- */
 MeshIOAbaqus::~MeshIOAbaqus() = default;
 
 /* -------------------------------------------------------------------------- */
 namespace spirit = boost::spirit;
 namespace qi = boost::spirit::qi;
 namespace ascii = boost::spirit::ascii;
 namespace lbs = boost::spirit::qi::labels;
 namespace phx = boost::phoenix;
 
 /* -------------------------------------------------------------------------- */
 void element_read(Mesh & mesh, const ElementType & type, UInt id,
                   const std::vector<Int> & conn,
                   const std::map<UInt, UInt> & nodes_mapping,
                   std::map<UInt, Element> & elements_mapping) {
   Vector<UInt> tmp_conn(Mesh::getNbNodesPerElement(type));
 
   AKANTU_DEBUG_ASSERT(conn.size() == tmp_conn.size(),
                       "The nodes in the Abaqus file have too many coordinates"
                           << " for the mesh you try to fill.");
 
   mesh.addConnectivityType(type);
   Array<UInt> & connectivity = mesh.getConnectivity(type);
 
   UInt i = 0;
   for (auto it = conn.begin(); it != conn.end(); ++it) {
     auto nit = nodes_mapping.find(*it);
     AKANTU_DEBUG_ASSERT(nit != nodes_mapping.end(),
                         "There is an unknown node in the connectivity.");
     tmp_conn[i++] = nit->second;
   }
   Element el{type, connectivity.size(), _not_ghost};
   elements_mapping[id] = el;
   connectivity.push_back(tmp_conn);
 }
 
 void node_read(Mesh & mesh, UInt id, const std::vector<Real> & pos,
                std::map<UInt, UInt> & nodes_mapping) {
   Vector<Real> tmp_pos(mesh.getSpatialDimension());
   UInt i = 0;
   for (auto it = pos.begin(); it != pos.end() || i < mesh.getSpatialDimension();
        ++it)
     tmp_pos[i++] = *it;
 
   nodes_mapping[id] = mesh.getNbNodes();
   mesh.getNodes().push_back(tmp_pos);
 }
 
 /* ------------------------------------------------------------------------ */
 void add_element_to_group(ElementGroup * el_grp, UInt element,
                           const std::map<UInt, Element> & elements_mapping) {
   auto eit = elements_mapping.find(element);
   AKANTU_DEBUG_ASSERT(eit != elements_mapping.end(),
                       "There is an unknown element ("
                           << element << ") in the in the ELSET "
                           << el_grp->getName() << ".");
 
   el_grp->add(eit->second, true, false);
 }
 
 ElementGroup * element_group_create(Mesh & mesh, const ID & name) {
   auto eg_it = mesh.element_group_find(name);
   if (eg_it != mesh.element_group_end()) {
     return eg_it->second;
   } else {
     return &mesh.createElementGroup(name, _all_dimensions);
   }
 }
 
 NodeGroup * node_group_create(Mesh & mesh, const ID & name) {
   auto ng_it = mesh.node_group_find(name);
   if (ng_it != mesh.node_group_end()) {
     return ng_it->second;
   } else {
     return &mesh.createNodeGroup(name, mesh.getSpatialDimension());
   }
 }
 
 void add_node_to_group(NodeGroup * node_grp, UInt node,
                        const std::map<UInt, UInt> & nodes_mapping) {
   auto nit = nodes_mapping.find(node);
 
   AKANTU_DEBUG_ASSERT(nit != nodes_mapping.end(),
                       "There is an unknown node in the in the NSET "
                           << node_grp->getName() << ".");
 
   node_grp->add(nit->second, false);
 }
 
 void optimize_group(NodeGroup * grp) { grp->optimize(); }
 void optimize_element_group(ElementGroup * grp) { grp->optimize(); }
 
 /* -------------------------------------------------------------------------- */
 template <class Iterator> struct AbaqusSkipper : qi::grammar<Iterator> {
   AbaqusSkipper() : AbaqusSkipper::base_type(skip, "abaqus_skipper") {
     /* clang-format off */
     skip
       =   (ascii::space - spirit::eol)
       |   "**" >> *(qi::char_ - spirit::eol) >> spirit::eol
       ;
     /* clang-format on */
   }
   qi::rule<Iterator> skip;
 };
 
 /* -------------------------------------------------------------------------- */
 template <class Iterator, typename Skipper = AbaqusSkipper<Iterator>>
 struct AbaqusMeshGrammar : qi::grammar<Iterator, void(), Skipper> {
 public:
   AbaqusMeshGrammar(Mesh & mesh)
       : AbaqusMeshGrammar::base_type(start, "abaqus_mesh_reader"), mesh(mesh) {
 
     /* clang-format off */
     start
       =  *(
              (qi::char_('*')
                 >  (   (qi::no_case[ qi::lit("node output")    ] > any_section)
                    |   (qi::no_case[ qi::lit("element output") ] > any_section)
                    |   (qi::no_case[ qi::lit("node")           ] > nodes)
                    |   (qi::no_case[ qi::lit("element")        ] > elements)
                    |   (qi::no_case[ qi::lit("heading")        ] > header)
                    |   (qi::no_case[ qi::lit("elset")          ] > elements_set)
                    |   (qi::no_case[ qi::lit("nset")           ] > nodes_set)
                    |   (qi::no_case[ qi::lit("material")       ] > material)
                    |   (keyword > any_section)
                    )
              )
           |  spirit::eol
           )
       ;
 
     header
       =   spirit::eol
       >   *any_line
       ;
 
     nodes
       =   *(qi::char_(',') >> option)
            >> spirit::eol
            >> *( (qi::int_
                   > node_position) [ phx::bind(&node_read,
                                                  phx::ref(mesh),
                                                  lbs::_1,
                                                  lbs::_2,
                                                  phx::ref(abaqus_nodes_to_akantu)) ]
                   >> spirit::eol
                )
       ;
 
     elements
       =   (
              (  qi::char_(',') >> qi::no_case[qi::lit("type")] >> '='
                 >> abaqus_element_type  [ lbs::_a = lbs::_1 ]
              )
           ^  *(qi::char_(',') >> option)
           )
           >> spirit::eol
           >> *(  (qi::int_
                   > connectivity) [ phx::bind(&element_read,
                                                 phx::ref(mesh),
                                                 lbs::_a,
                                                 lbs::_1,
                                                 lbs::_2,
                                                 phx::cref(abaqus_nodes_to_akantu),
                                                 phx::ref(abaqus_elements_to_akantu)) ]
                  >> spirit::eol
                )
       ;
 
     elements_set
       =   (
              (
                 (  qi::char_(',') >> qi::no_case[ qi::lit("elset") ] >> '='
                    >> value [ lbs::_a = phx::bind<ElementGroup *>(&element_group_create,
                                                                     phx::ref(mesh),
                                                                     lbs::_1) ]
                 )
              ^  *(qi::char_(',') >> option)
              )
              >> spirit::eol
              >> qi::skip
                   (qi::char_(',') | qi::space)
              [ +(qi::int_ [ phx::bind(&add_element_to_group,
                                         lbs::_a,
                                         lbs::_1,
                                         phx::cref(abaqus_elements_to_akantu)
                                         )
                                ]
                      )
                  ]
            ) [ phx::bind(&optimize_element_group, lbs::_a) ]
       ;
 
     nodes_set
       =   (
              (
                 (  qi::char_(',')
                    >> qi::no_case[ qi::lit("nset") ] >> '='
                    >> value [ lbs::_a = phx::bind<NodeGroup *>(&node_group_create, phx::ref(mesh), lbs::_1) ]
                 )
              ^  *(qi::char_(',') >> option)
              )
              >> spirit::eol
              >> qi::skip
                  (qi::char_(',') | qi::space)
                  [ +(qi::int_ [ phx::bind(&add_node_to_group,
                                             lbs::_a,
                                             lbs::_1,
                                             phx::cref(abaqus_nodes_to_akantu)
                                            )
                               ]
                     )
                  ]
            ) [ phx::bind(&optimize_group, lbs::_a) ]
       ;
 
     material
       =   (
              (  qi::char_(',') >> qi::no_case[ qi::lit("name") ] >> '='
                 >> value  [ phx::push_back(phx::ref(material_names), lbs::_1) ]
              )
           ^  *(qi::char_(',') >> option)
           ) >> spirit::eol;
       ;
 
     node_position
       =   +(qi::char_(',') > real [ phx::push_back(lbs::_val, lbs::_1) ])
       ;
 
     connectivity
       = +(qi::char_(',') > qi::int_ [ phx::push_back(lbs::_val, lbs::_1) ])
       ;
 
 
     any_section
       =   *(qi::char_(',') >> option) > spirit::eol
       >   *any_line
       ;
 
     any_line
       =   *(qi::char_ - spirit::eol - qi::char_('*')) >> spirit::eol
       ;
 
     keyword
       =   qi::lexeme[ +(qi::char_ - (qi::char_('*') | spirit::eol)) ]
       ;
 
     option
       = key > -( '=' >> value );
 
     key
       =   qi::char_("a-zA-Z_") >> *(qi::char_("a-zA-Z_0-9") | qi::char_('-'))
       ;
 
     value
       =   key.alias()
       ;
 
     BOOST_SPIRIT_DEBUG_NODE(start);
 
     abaqus_element_type.add
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
       ("BE21"  , _bernoulli_beam_2)
       ("BE31"  , _bernoulli_beam_3)
 #endif
       ("T3D2"  , _segment_2) // Gmsh generates this elements
       ("T3D3"  , _segment_3) // Gmsh generates this elements
       ("CPE3"  , _triangle_3)
       ("CPS3"  , _triangle_3)
       ("DC2D3" , _triangle_3)
       ("CPE6"  , _triangle_6)
       ("CPS6"  , _triangle_6)
       ("DC2D6" , _triangle_6)
       ("CPE4"  , _quadrangle_4)
       ("CPS4"  , _quadrangle_4)
       ("DC2D4" , _quadrangle_4)
       ("CPE8"  , _quadrangle_8)
       ("CPS8"  , _quadrangle_8)
       ("DC2D8" , _quadrangle_8)
       ("C3D4"  , _tetrahedron_4)
       ("DC3D4" , _tetrahedron_4)
       ("C3D8"  , _hexahedron_8)
       ("C3D8R" , _hexahedron_8)
       ("DC3D8" , _hexahedron_8)
       ("C3D10" , _tetrahedron_10)
       ("DC3D10", _tetrahedron_10);
 
 #if !defined(AKANTU_NDEBUG) && defined(AKANTU_CORE_CXX_11)
     qi::on_error<qi::fail>(start, error_handler(lbs::_4, lbs::_3, lbs::_2));
 #endif
     
     start              .name("abaqus-start-rule");
     connectivity       .name("abaqus-connectivity");
     node_position      .name("abaqus-nodes-position");
     nodes              .name("abaqus-nodes");
     any_section        .name("abaqus-any_section");
     header             .name("abaqus-header");
     material           .name("abaqus-material");
     elements           .name("abaqus-elements");
     elements_set       .name("abaqus-elements-set");
     nodes_set          .name("abaqus-nodes-set");
     key                .name("abaqus-key");
     value              .name("abaqus-value");
     option             .name("abaqus-option");
     keyword            .name("abaqus-keyword");
     any_line           .name("abaqus-any-line");
     abaqus_element_type.name("abaqus-element-type");
 
     /* clang-format on */
   }
 
 public:
   AKANTU_GET_MACRO(MaterialNames, material_names,
                    const std::vector<std::string> &);
 
   /* ------------------------------------------------------------------------ */
   /* Rules                                                                    */
   /* ------------------------------------------------------------------------ */
 private:
   qi::rule<Iterator, void(), Skipper> start;
   qi::rule<Iterator, std::vector<int>(), Skipper> connectivity;
   qi::rule<Iterator, std::vector<Real>(), Skipper> node_position;
   qi::rule<Iterator, void(), Skipper> nodes, any_section, header, material;
   qi::rule<Iterator, void(), qi::locals<ElementType>, Skipper> elements;
   qi::rule<Iterator, void(), qi::locals<ElementGroup *>, Skipper> elements_set;
   qi::rule<Iterator, void(), qi::locals<NodeGroup *>, Skipper> nodes_set;
 
   qi::rule<Iterator, std::string(), Skipper> key, value, option, keyword,
       any_line;
 
   qi::real_parser<Real, qi::real_policies<Real>> real;
 
   qi::symbols<char, ElementType> abaqus_element_type;
 
   /* ------------------------------------------------------------------------ */
   /* Mambers                                                                  */
   /* ------------------------------------------------------------------------ */
 private:
   /// reference to the mesh to read
   Mesh & mesh;
 
   /// correspondance between the numbering of nodes in the abaqus file and in
   /// the akantu mesh
   std::map<UInt, UInt> abaqus_nodes_to_akantu;
 
   /// correspondance between the element number in the abaqus file and the
   /// Element in the akantu mesh
   std::map<UInt, Element> abaqus_elements_to_akantu;
 
   /// list of the material names
   std::vector<std::string> material_names;
 };
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 void MeshIOAbaqus::read(const std::string & filename, Mesh & mesh) {
   namespace spirit = boost::spirit;
   namespace qi = boost::spirit::qi;
   namespace lbs = boost::spirit::qi::labels;
   namespace ascii = boost::spirit::ascii;
   namespace phx = boost::phoenix;
 
   std::ifstream infile;
   infile.open(filename.c_str());
 
   if (!infile.good()) {
-    AKANTU_DEBUG_ERROR("Cannot open file " << filename);
+    AKANTU_ERROR("Cannot open file " << filename);
   }
 
   std::string storage;             // We will read the contents here.
   infile.unsetf(std::ios::skipws); // No white space skipping!
   std::copy(std::istream_iterator<char>(infile), std::istream_iterator<char>(),
             std::back_inserter(storage));
 
   using iterator_t = std::string::const_iterator;
   using skipper = AbaqusSkipper<iterator_t>;
   using grammar = AbaqusMeshGrammar<iterator_t, skipper>;
 
   grammar g(mesh);
   skipper ws;
 
   iterator_t iter = storage.begin();
   iterator_t end = storage.end();
 
   qi::phrase_parse(iter, end, g, ws);
 
   MeshAccessor mesh_accessor(mesh);
 
   for (auto & mat_name : g.getMaterialNames()) {
     auto eg_it = mesh.element_group_find(mat_name);
     auto & eg = *eg_it->second;
     if (eg_it != mesh.element_group_end()) {
       for (auto & type : eg.elementTypes()) {
         Array<std::string> & abaqus_material =
             mesh_accessor.getData<std::string>("abaqus_material", type);
 
         for (auto elem : eg.getElements(type)) {
           abaqus_material(elem) = mat_name;
         }
       }
     }
   }
 
   mesh_accessor.setNbGlobalNodes(mesh.getNodes().size());
   MeshUtils::fillElementToSubElementsData(mesh);
 }
 
 } // namespace akantu
diff --git a/src/io/mesh_io/mesh_io_diana.cc b/src/io/mesh_io/mesh_io_diana.cc
index 089edfdde..634226ac0 100644
--- a/src/io/mesh_io/mesh_io_diana.cc
+++ b/src/io/mesh_io/mesh_io_diana.cc
@@ -1,602 +1,602 @@
 /**
  * @file   mesh_io_diana.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Alodie Schneuwly <alodie.schneuwly@epfl.ch>
  *
  * @date creation: Sat Mar 26 2011
  * @date last modification: Thu Jan 21 2016
  *
  * @brief  handles diana meshes
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 <fstream>
 #include <iostream>
 
 /* -------------------------------------------------------------------------- */
 #include "element_group.hh"
 #include "mesh_io_diana.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 #include <string.h>
 /* -------------------------------------------------------------------------- */
 #include <stdio.h>
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /*   Methods Implentations                                                    */
 /* -------------------------------------------------------------------------- */
 
 MeshIODiana::MeshIODiana() {
   canReadSurface = true;
   canReadExtendedData = true;
   _diana_to_akantu_element_types["T9TM"] = _triangle_3;
   _diana_to_akantu_element_types["CT6CM"] = _triangle_6;
   _diana_to_akantu_element_types["Q12TM"] = _quadrangle_4;
   _diana_to_akantu_element_types["CQ8CM"] = _quadrangle_8;
   _diana_to_akantu_element_types["TP18L"] = _pentahedron_6;
   _diana_to_akantu_element_types["CTP45"] = _pentahedron_15;
   _diana_to_akantu_element_types["TE12L"] = _tetrahedron_4;
   _diana_to_akantu_element_types["HX24L"] = _hexahedron_8;
   _diana_to_akantu_element_types["CHX60"] = _hexahedron_20;
   _diana_to_akantu_mat_prop["YOUNG"] = "E";
   _diana_to_akantu_mat_prop["DENSIT"] = "rho";
   _diana_to_akantu_mat_prop["POISON"] = "nu";
 
   std::map<std::string, ElementType>::iterator it;
   for (it = _diana_to_akantu_element_types.begin();
        it != _diana_to_akantu_element_types.end(); ++it) {
     UInt nb_nodes = Mesh::getNbNodesPerElement(it->second);
 
     auto * tmp = new UInt[nb_nodes];
     for (UInt i = 0; i < nb_nodes; ++i) {
       tmp[i] = i;
     }
 
     switch (it->second) {
     case _tetrahedron_10:
       tmp[8] = 9;
       tmp[9] = 8;
       break;
     case _pentahedron_15:
       tmp[0] = 2;
       tmp[1] = 8;
       tmp[2] = 0;
       tmp[3] = 6;
       tmp[4] = 1;
       tmp[5] = 7;
       tmp[6] = 11;
       tmp[7] = 9;
       tmp[8] = 10;
       tmp[9] = 5;
       tmp[10] = 14;
       tmp[11] = 3;
       tmp[12] = 12;
       tmp[13] = 4;
       tmp[14] = 13;
       break;
     case _hexahedron_20:
       tmp[0] = 5;
       tmp[1] = 16;
       tmp[2] = 4;
       tmp[3] = 19;
       tmp[4] = 7;
       tmp[5] = 18;
       tmp[6] = 6;
       tmp[7] = 17;
       tmp[8] = 13;
       tmp[9] = 12;
       tmp[10] = 15;
       tmp[11] = 14;
       tmp[12] = 1;
       tmp[13] = 8;
       tmp[14] = 0;
       tmp[15] = 11;
       tmp[16] = 3;
       tmp[17] = 10;
       tmp[18] = 2;
       tmp[19] = 9;
       break;
     default:
       // nothing to change
       break;
     }
     _read_order[it->second] = tmp;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 MeshIODiana::~MeshIODiana() = default;
 
 /* -------------------------------------------------------------------------- */
 inline void my_getline(std::ifstream & infile, std::string & line) {
   std::getline(infile, line);   // read the line
   size_t pos = line.find('\r'); /// remove the extra \r if needed
   line = line.substr(0, pos);
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIODiana::read(const std::string & filename, Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   MeshAccessor mesh_accessor(mesh);
 
   std::ifstream infile;
   infile.open(filename.c_str());
 
   std::string line;
   UInt first_node_number = std::numeric_limits<UInt>::max();
   diana_element_number_to_elements.clear();
 
   if (!infile.good()) {
-    AKANTU_DEBUG_ERROR("Cannot open file " << filename);
+    AKANTU_ERROR("Cannot open file " << filename);
   }
 
   while (infile.good()) {
     my_getline(infile, line);
 
     /// read all nodes
     if (line == "'COORDINATES'") {
       line = readCoordinates(infile, mesh, first_node_number);
     }
 
     /// read all elements
     if (line == "'ELEMENTS'") {
       line = readElements(infile, mesh, first_node_number);
     }
 
     /// read the material properties and write a .dat file
     if (line == "'MATERIALS'") {
       line = readMaterial(infile, filename);
     }
 
     /// read the material properties and write a .dat file
     if (line == "'GROUPS'") {
       line = readGroups(infile, mesh, first_node_number);
     }
   }
   infile.close();
 
   mesh_accessor.setNbGlobalNodes(mesh.getNbNodes());
 
   MeshUtils::fillElementToSubElementsData(mesh);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIODiana::write(__attribute__((unused)) const std::string & filename,
                         __attribute__((unused)) const Mesh & mesh) {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readCoordinates(std::ifstream & infile, Mesh & mesh,
                                          UInt & first_node_number) {
   AKANTU_DEBUG_IN();
 
   MeshAccessor mesh_accessor(mesh);
 
   Array<Real> & nodes = mesh_accessor.getNodes();
 
   std::string line;
 
   UInt index;
   Vector<Real> coord(3);
 
   do {
     my_getline(infile, line);
     if ("'ELEMENTS'" == line)
       break;
 
     std::stringstream sstr_node(line);
     sstr_node >> index >> coord(0) >> coord(1) >> coord(2);
 
     first_node_number = first_node_number < index ? first_node_number : index;
 
     nodes.push_back(coord);
   } while (true);
 
   AKANTU_DEBUG_OUT();
   return line;
 }
 
 /* -------------------------------------------------------------------------- */
 UInt MeshIODiana::readInterval(std::stringstream & line,
                                std::set<UInt> & interval) {
   UInt first;
   line >> first;
   if (line.fail()) {
     return 0;
   }
   interval.insert(first);
 
   UInt second;
   int dash;
   dash = line.get();
   if (dash == '-') {
     line >> second;
     interval.insert(second);
     return 2;
   }
 
   if (line.fail())
     line.clear(std::ios::eofbit); // in case of get at end of the line
   else
     line.unget();
   return 1;
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readGroups(std::ifstream & infile, Mesh & mesh,
                                     UInt first_node_number) {
   AKANTU_DEBUG_IN();
 
   std::string line;
   my_getline(infile, line);
 
   bool reading_nodes_group = false;
 
   while (line != "'SUPPORTS'") {
     if (line == "NODES") {
       reading_nodes_group = true;
       my_getline(infile, line);
     }
 
     if (line == "ELEMEN") {
       reading_nodes_group = false;
       my_getline(infile, line);
     }
 
     auto * str = new std::stringstream(line);
 
     UInt id;
     std::string name;
     char c;
     *str >> id >> name >> c;
 
     auto * list_ids = new Array<UInt>(0, 1, name);
 
     UInt s = 1;
     bool end = false;
     while (!end) {
       while (!str->eof() && s != 0) {
         std::set<UInt> interval;
         s = readInterval(*str, interval);
         auto it = interval.begin();
         if (s == 1)
           list_ids->push_back(*it);
         if (s == 2) {
           UInt first = *it;
           ++it;
           UInt second = *it;
           for (UInt i = first; i <= second; ++i) {
             list_ids->push_back(i);
           }
         }
       }
       if (str->fail())
         end = true;
       else {
         my_getline(infile, line);
         delete str;
         str = new std::stringstream(line);
       }
     }
 
     delete str;
 
     if (reading_nodes_group) {
       NodeGroup & ng = mesh.createNodeGroup(name);
       for (UInt i = 0; i < list_ids->size(); ++i) {
         UInt node = (*list_ids)(i)-first_node_number;
         ng.add(node, false);
       }
       delete list_ids;
 
     } else {
       ElementGroup & eg = mesh.createElementGroup(name);
       for (UInt i = 0; i < list_ids->size(); ++i) {
         Element & elem = diana_element_number_to_elements[(*list_ids)(i)];
         if (elem.type != _not_defined)
           eg.add(elem, false, false);
       }
 
       eg.optimize();
       delete list_ids;
     }
 
     my_getline(infile, line);
   }
 
   AKANTU_DEBUG_OUT();
   return line;
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readElements(std::ifstream & infile, Mesh & mesh,
                                       UInt first_node_number) {
   AKANTU_DEBUG_IN();
 
   std::string line;
   my_getline(infile, line);
 
   if ("CONNECTIVITY" == line) {
     line = readConnectivity(infile, mesh, first_node_number);
   }
 
   /// read the line corresponding to the materials
   if ("MATERIALS" == line) {
     line = readMaterialElement(infile, mesh);
   }
 
   AKANTU_DEBUG_OUT();
   return line;
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readConnectivity(std::ifstream & infile, Mesh & mesh,
                                           UInt first_node_number) {
   AKANTU_DEBUG_IN();
 
   MeshAccessor mesh_accessor(mesh);
   Int index;
   std::string lline;
 
   std::string diana_type;
   ElementType akantu_type, akantu_type_old = _not_defined;
   Array<UInt> * connectivity = nullptr;
   UInt node_per_element = 0;
   Element elem;
   UInt * read_order = nullptr;
 
   while (true) {
     my_getline(infile, lline);
     //    std::cerr << lline << std::endl;
     std::stringstream sstr_elem(lline);
     if (lline == "MATERIALS")
       break;
 
     /// traiter les coordonnees
     sstr_elem >> index;
     sstr_elem >> diana_type;
 
     akantu_type = _diana_to_akantu_element_types[diana_type];
 
     if (akantu_type == _not_defined)
       continue;
 
     if (akantu_type != akantu_type_old) {
       connectivity = &(mesh_accessor.getConnectivity(akantu_type));
 
       node_per_element = connectivity->getNbComponent();
       akantu_type_old = akantu_type;
       read_order = _read_order[akantu_type];
     }
 
     Vector<UInt> local_connect(node_per_element);
 
     // used if element is written on two lines
     UInt j_last = 0;
 
     for (UInt j = 0; j < node_per_element; ++j) {
       UInt node_index;
       sstr_elem >> node_index;
 
       // check s'il y a pas plus rien après un certain point
 
       if (sstr_elem.fail()) {
         sstr_elem.clear();
         sstr_elem.ignore();
         break;
       }
 
       node_index -= first_node_number;
       local_connect(read_order[j]) = node_index;
       j_last = j;
     }
 
     // check if element is written in two lines
     if (j_last != (node_per_element - 1)) {
 
       // if this is the case, read on more line
       my_getline(infile, lline);
       std::stringstream sstr_elem(lline);
 
       for (UInt j = (j_last + 1); j < node_per_element; ++j) {
 
         UInt node_index;
         sstr_elem >> node_index;
 
         node_index -= first_node_number;
         local_connect(read_order[j]) = node_index;
       }
     }
 
     connectivity->push_back(local_connect);
 
     elem.type = akantu_type;
     elem.element = connectivity->size() - 1;
 
     diana_element_number_to_elements[index] = elem;
     akantu_number_to_diana_number[elem] = index;
   }
 
   AKANTU_DEBUG_OUT();
   return lline;
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readMaterialElement(std::ifstream & infile,
                                              Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   std::string line;
   std::stringstream sstr_tag_name;
   sstr_tag_name << "tag_" << 0;
 
   Mesh::type_iterator it = mesh.firstType();
   Mesh::type_iterator end = mesh.lastType();
   for (; it != end; ++it) {
     UInt nb_element = mesh.getNbElement(*it);
     mesh.getDataPointer<UInt>("material", *it, _not_ghost, 1)
         .resize(nb_element);
   }
 
   my_getline(infile, line);
   while (line != "'MATERIALS'") {
     line =
         line.substr(line.find('/') + 1,
                     std::string::npos); // erase the first slash / of the line
     char tutu[250];
     strncpy(tutu, line.c_str(), 250);
 
     AKANTU_DEBUG_WARNING("reading line " << line);
     Array<UInt> temp_id(0, 2);
     UInt mat;
     while (true) {
       std::stringstream sstr_intervals_elements(line);
       Vector<UInt> id(2);
       char temp;
       while (sstr_intervals_elements.good()) {
         sstr_intervals_elements >> id(0) >> temp >> id(1); // >> "/" >> mat;
         if (!sstr_intervals_elements.fail())
           temp_id.push_back(id);
       }
       if (sstr_intervals_elements.fail()) {
         sstr_intervals_elements.clear();
         sstr_intervals_elements.ignore();
         sstr_intervals_elements >> mat;
         break;
       }
       my_getline(infile, line);
     }
 
     // loop over elements
     //    UInt * temp_id_val = temp_id.storage();
     for (UInt i = 0; i < temp_id.size(); ++i)
       for (UInt j = temp_id(i, 0); j <= temp_id(i, 1); ++j) {
         Element & element = diana_element_number_to_elements[j];
         if (element.type == _not_defined)
           continue;
         UInt elem = element.element;
         ElementType type = element.type;
         Array<UInt> & data =
             mesh.getDataPointer<UInt>("material", type, _not_ghost);
         data(elem) = mat;
       }
 
     my_getline(infile, line);
   }
 
   AKANTU_DEBUG_OUT();
   return line;
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readMaterial(std::ifstream & infile,
                                       const std::string & filename) {
   AKANTU_DEBUG_IN();
 
   std::stringstream mat_file_name;
 
   mat_file_name << "material_" << filename;
 
   std::ofstream material_file;
   material_file.open(mat_file_name.str().c_str()); // mat_file_name.str());
 
   UInt mat_index;
   std::string line;
 
   bool first_mat = true;
   bool end = false;
 
   UInt mat_id = 0;
 
   using MatProp = std::map<std::string, Real>;
   MatProp mat_prop;
   do {
     my_getline(infile, line);
     std::stringstream sstr_material(line);
     if (("'GROUPS'" == line) || ("'END'" == line)) {
       if (!mat_prop.empty()) {
         material_file << "material elastic [" << std::endl;
         material_file << "\tname = material" << ++mat_id << std::endl;
         for (auto it = mat_prop.begin(); it != mat_prop.end(); ++it)
           material_file << "\t" << it->first << " = " << it->second
                         << std::endl;
         material_file << "]" << std::endl;
         mat_prop.clear();
       }
       end = true;
     } else {
       /// traiter les caractéristiques des matériaux
       sstr_material >> mat_index;
 
       if (!sstr_material.fail()) {
         if (!first_mat) {
           if (!mat_prop.empty()) {
             material_file << "material elastic [" << std::endl;
             material_file << "\tname = material" << ++mat_id << std::endl;
             for (auto it = mat_prop.begin(); it != mat_prop.end(); ++it)
               material_file << "\t" << it->first << " = " << it->second
                             << std::endl;
             material_file << "]" << std::endl;
             mat_prop.clear();
           }
         }
         first_mat = false;
       } else {
         sstr_material.clear();
       }
 
       std::string prop_name;
       sstr_material >> prop_name;
 
       std::map<std::string, std::string>::iterator it;
       it = _diana_to_akantu_mat_prop.find(prop_name);
 
       if (it != _diana_to_akantu_mat_prop.end()) {
         Real value;
         sstr_material >> value;
         mat_prop[it->second] = value;
       } else {
         AKANTU_DEBUG_INFO("In material reader, property " << prop_name
                                                           << "not recognized");
       }
     }
   } while (!end);
 
   AKANTU_DEBUG_OUT();
   return line;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/io/mesh_io/mesh_io_msh.cc b/src/io/mesh_io/mesh_io_msh.cc
index 744f36cef..5576f5bf4 100644
--- a/src/io/mesh_io/mesh_io_msh.cc
+++ b/src/io/mesh_io/mesh_io_msh.cc
@@ -1,971 +1,971 @@
 /**
  * @file   mesh_io_msh.cc
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Jan 21 2016
  *
  * @brief  Read/Write for MSH files generated by gmsh
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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/>.
  *
  */
 
 /* -----------------------------------------------------------------------------
    Version (Legacy) 1.0
 
    $NOD
    number-of-nodes
    node-number x-coord y-coord z-coord
    ...
    $ENDNOD
    $ELM
    number-of-elements
    elm-number elm-type reg-phys reg-elem number-of-nodes node-number-list
    ...
    $ENDELM
    -----------------------------------------------------------------------------
    Version 2.1
 
    $MeshFormat
    version-number file-type data-size
    $EndMeshFormat
    $Nodes
    number-of-nodes
    node-number x-coord y-coord z-coord
    ...
    $EndNodes
    $Elements
    number-of-elements
    elm-number elm-type number-of-tags < tag > ... node-number-list
    ...
    $EndElements
    $PhysicalNames
    number-of-names
    physical-dimension physical-number "physical-name"
    ...
    $EndPhysicalNames
    $NodeData
    number-of-string-tags
    < "string-tag" >
    ...
    number-of-real-tags
    < real-tag >
    ...
    number-of-integer-tags
    < integer-tag >
    ...
    node-number value ...
    ...
    $EndNodeData
    $ElementData
    number-of-string-tags
    < "string-tag" >
    ...
    number-of-real-tags
    < real-tag >
    ...
    number-of-integer-tags
    < integer-tag >
    ...
    elm-number value ...
    ...
    $EndElementData
    $ElementNodeData
    number-of-string-tags
    < "string-tag" >
    ...
    number-of-real-tags
    < real-tag >
    ...
    number-of-integer-tags
    < integer-tag >
    ...
    elm-number number-of-nodes-per-element value ...
    ...
    $ElementEndNodeData
 
    -----------------------------------------------------------------------------
    elem-type
 
    1:  2-node line.
    2:  3-node triangle.
    3:  4-node quadrangle.
    4:  4-node tetrahedron.
    5:  8-node hexahedron.
    6:  6-node prism.
    7:  5-node pyramid.
    8:  3-node second order line
    9:  6-node second order triangle
    10: 9-node second order quadrangle
    11: 10-node second order tetrahedron
    12: 27-node second order hexahedron
    13: 18-node second order prism
    14: 14-node second order pyramid
    15: 1-node point.
    16: 8-node second order quadrangle
    17: 20-node second order hexahedron
    18: 15-node second order prism
    19: 13-node second order pyramid
    20: 9-node third order incomplete triangle
    21: 10-node third order triangle
    22: 12-node fourth order incomplete triangle
    23: 15-node fourth order triangle
    24: 15-node fifth order incomplete triangle
    25: 21-node fifth order complete triangle
    26: 4-node third order edge
    27: 5-node fourth order edge
    28: 6-node fifth order edge
    29: 20-node third order tetrahedron
    30: 35-node fourth order tetrahedron
    31: 56-node fifth order tetrahedron
    -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "mesh_io.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 // The boost spirit is a work on the way it does not compile so I kept the
 // current code. The current code does not handle files generated on Windows
 // <CRLF>
 
 // #include <boost/config/warning_disable.hpp>
 // #include <boost/spirit/include/qi.hpp>
 // #include <boost/spirit/include/phoenix_core.hpp>
 // #include <boost/spirit/include/phoenix_fusion.hpp>
 // #include <boost/spirit/include/phoenix_object.hpp>
 // #include <boost/spirit/include/phoenix_container.hpp>
 // #include <boost/spirit/include/phoenix_operator.hpp>
 // #include <boost/spirit/include/phoenix_bind.hpp>
 // #include <boost/spirit/include/phoenix_stl.hpp>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /*   Methods Implentations                                                    */
 /* -------------------------------------------------------------------------- */
 MeshIOMSH::MeshIOMSH() {
   canReadSurface = true;
   canReadExtendedData = true;
 
   _msh_nodes_per_elem[_msh_not_defined] = 0;
   _msh_nodes_per_elem[_msh_segment_2] = 2;
   _msh_nodes_per_elem[_msh_triangle_3] = 3;
   _msh_nodes_per_elem[_msh_quadrangle_4] = 4;
   _msh_nodes_per_elem[_msh_tetrahedron_4] = 4;
   _msh_nodes_per_elem[_msh_hexahedron_8] = 8;
   _msh_nodes_per_elem[_msh_prism_1] = 6;
   _msh_nodes_per_elem[_msh_pyramid_1] = 1;
   _msh_nodes_per_elem[_msh_segment_3] = 3;
   _msh_nodes_per_elem[_msh_triangle_6] = 6;
   _msh_nodes_per_elem[_msh_quadrangle_9] = 9;
   _msh_nodes_per_elem[_msh_tetrahedron_10] = 10;
   _msh_nodes_per_elem[_msh_hexahedron_27] = 27;
   _msh_nodes_per_elem[_msh_hexahedron_20] = 20;
   _msh_nodes_per_elem[_msh_prism_18] = 18;
   _msh_nodes_per_elem[_msh_prism_15] = 15;
   _msh_nodes_per_elem[_msh_pyramid_14] = 14;
   _msh_nodes_per_elem[_msh_point] = 1;
   _msh_nodes_per_elem[_msh_quadrangle_8] = 8;
 
   _msh_to_akantu_element_types[_msh_not_defined] = _not_defined;
   _msh_to_akantu_element_types[_msh_segment_2] = _segment_2;
   _msh_to_akantu_element_types[_msh_triangle_3] = _triangle_3;
   _msh_to_akantu_element_types[_msh_quadrangle_4] = _quadrangle_4;
   _msh_to_akantu_element_types[_msh_tetrahedron_4] = _tetrahedron_4;
   _msh_to_akantu_element_types[_msh_hexahedron_8] = _hexahedron_8;
   _msh_to_akantu_element_types[_msh_prism_1] = _pentahedron_6;
   _msh_to_akantu_element_types[_msh_pyramid_1] = _not_defined;
   _msh_to_akantu_element_types[_msh_segment_3] = _segment_3;
   _msh_to_akantu_element_types[_msh_triangle_6] = _triangle_6;
   _msh_to_akantu_element_types[_msh_quadrangle_9] = _not_defined;
   _msh_to_akantu_element_types[_msh_tetrahedron_10] = _tetrahedron_10;
   _msh_to_akantu_element_types[_msh_hexahedron_27] = _not_defined;
   _msh_to_akantu_element_types[_msh_hexahedron_20] = _hexahedron_20;
   _msh_to_akantu_element_types[_msh_prism_18] = _not_defined;
   _msh_to_akantu_element_types[_msh_prism_15] = _pentahedron_15;
   _msh_to_akantu_element_types[_msh_pyramid_14] = _not_defined;
   _msh_to_akantu_element_types[_msh_point] = _point_1;
   _msh_to_akantu_element_types[_msh_quadrangle_8] = _quadrangle_8;
 
   _akantu_to_msh_element_types[_not_defined] = _msh_not_defined;
   _akantu_to_msh_element_types[_segment_2] = _msh_segment_2;
   _akantu_to_msh_element_types[_segment_3] = _msh_segment_3;
   _akantu_to_msh_element_types[_triangle_3] = _msh_triangle_3;
   _akantu_to_msh_element_types[_triangle_6] = _msh_triangle_6;
   _akantu_to_msh_element_types[_tetrahedron_4] = _msh_tetrahedron_4;
   _akantu_to_msh_element_types[_tetrahedron_10] = _msh_tetrahedron_10;
   _akantu_to_msh_element_types[_quadrangle_4] = _msh_quadrangle_4;
   _akantu_to_msh_element_types[_quadrangle_8] = _msh_quadrangle_8;
   _akantu_to_msh_element_types[_hexahedron_8] = _msh_hexahedron_8;
   _akantu_to_msh_element_types[_hexahedron_20] = _msh_hexahedron_20;
   _akantu_to_msh_element_types[_pentahedron_6] = _msh_prism_1;
   _akantu_to_msh_element_types[_pentahedron_15] = _msh_prism_15;
   _akantu_to_msh_element_types[_point_1] = _msh_point;
 
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
   _akantu_to_msh_element_types[_bernoulli_beam_2] = _msh_segment_2;
   _akantu_to_msh_element_types[_bernoulli_beam_3] = _msh_segment_2;
   _akantu_to_msh_element_types[_discrete_kirchhoff_triangle_18] = _msh_triangle_3;
 #endif
 
   std::map<ElementType, MSHElementType>::iterator it;
   for (it = _akantu_to_msh_element_types.begin();
        it != _akantu_to_msh_element_types.end(); ++it) {
     UInt nb_nodes = _msh_nodes_per_elem[it->second];
 
     std::vector<UInt> tmp(nb_nodes);
     for (UInt i = 0; i < nb_nodes; ++i) {
       tmp[i] = i;
     }
 
     switch (it->first) {
     case _tetrahedron_10:
       tmp[8] = 9;
       tmp[9] = 8;
       break;
     case _pentahedron_6:
       tmp[0] = 2;
       tmp[1] = 0;
       tmp[2] = 1;
       tmp[3] = 5;
       tmp[4] = 3;
       tmp[5] = 4;
       break;
     case _pentahedron_15:
       tmp[0] = 2;
       tmp[1] = 0;
       tmp[2] = 1;
       tmp[3] = 5;
       tmp[4] = 3;
       tmp[5] = 4;
       tmp[6] = 8;
       tmp[8] = 11;
       tmp[9] = 6;
       tmp[10] = 9;
       tmp[11] = 10;
       tmp[12] = 14;
       tmp[14] = 12;
       break;
     case _hexahedron_20:
       tmp[9] = 11;
       tmp[10] = 12;
       tmp[11] = 9;
       tmp[12] = 13;
       tmp[13] = 10;
       tmp[17] = 19;
       tmp[18] = 17;
       tmp[19] = 18;
       break;
     default:
       // nothing to change
       break;
     }
     _read_order[it->first] = tmp;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 MeshIOMSH::~MeshIOMSH() = default;
 
 /* -------------------------------------------------------------------------- */
 /* Spirit stuff                                                               */
 /* -------------------------------------------------------------------------- */
 // namespace _parser {
 //   namespace spirit  = ::boost::spirit;
 //   namespace qi      = ::boost::spirit::qi;
 //   namespace ascii   = ::boost::spirit::ascii;
 //   namespace lbs     = ::boost::spirit::qi::labels;
 //   namespace phx     = ::boost::phoenix;
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   /* Lazy functors */
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct _Element {
 //     int index;
 //     std::vector<int> tags;
 //     std::vector<int> connectivity;
 //     ElementType type;
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct lazy_get_nb_nodes_ {
 //     template <class elem_type> struct result { typedef int type; };
 //     template <class elem_type> bool operator()(elem_type et) {
 //       return MeshIOMSH::_msh_nodes_per_elem[et];
 //     }
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct lazy_element_ {
 //     template <class id_t, class tags_t, class elem_type, class conn_t>
 //     struct result {
 //       typedef _Element type;
 //     };
 //     template <class id_t, class tags_t, class elem_type, class conn_t>
 //     _Element operator()(id_t id, const elem_type & et, const tags_t & t,
 //                        const conn_t & c) {
 //       _Element tmp_el;
 //       tmp_el.index = id;
 //       tmp_el.tags = t;
 //       tmp_el.connectivity = c;
 //       tmp_el.type = et;
 //       return tmp_el;
 //     }
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct lazy_check_value_ {
 //     template <class T> struct result { typedef void type; };
 //     template <class T> void operator()(T v1, T v2) {
 //       if (v1 != v2) {
 //         AKANTU_EXCEPTION("The msh parser expected a "
 //                          << v2 << " in the header bug got a " << v1);
 //       }
 //     }
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct lazy_node_read_ {
 //     template <class Mesh, class ID, class V, class size, class Map>
 //     struct result {
 //       typedef bool type;
 //     };
 //     template <class Mesh, class ID, class V, class size, class Map>
 //     bool operator()(Mesh & mesh, const ID & id, const V & pos, size max,
 //                     Map & nodes_mapping) const {
 //       Vector<Real> tmp_pos(mesh.getSpatialDimension());
 //       UInt i = 0;
 //       for (typename V::const_iterator it = pos.begin();
 //            it != pos.end() || i < mesh.getSpatialDimension(); ++it)
 //         tmp_pos[i++] = *it;
 
 //       nodes_mapping[id] = mesh.getNbNodes();
 //       mesh.getNodes().push_back(tmp_pos);
 //       return (mesh.getNbNodes() < UInt(max));
 //     }
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct lazy_element_read_ {
 //     template <class Mesh, class EL, class size, class NodeMap, class ElemMap>
 //     struct result {
 //       typedef bool type;
 //     };
 
 //     template <class Mesh, class EL, class size, class NodeMap, class ElemMap>
 //     bool operator()(Mesh & mesh, const EL & element, size max,
 //                     const NodeMap & nodes_mapping,
 //                     ElemMap & elements_mapping) const {
 //       Vector<UInt> tmp_conn(Mesh::getNbNodesPerElement(element.type));
 
 //       AKANTU_DEBUG_ASSERT(element.connectivity.size() == tmp_conn.size(),
 //                           "The element "
 //                               << element.index
 //                               << "in the MSH file has too many nodes.");
 
 //       mesh.addConnectivityType(element.type);
 //       Array<UInt> & connectivity = mesh.getConnectivity(element.type);
 
 //       UInt i = 0;
 //       for (std::vector<int>::const_iterator it =
 //       element.connectivity.begin();
 //            it != element.connectivity.end(); ++it) {
 //         typename NodeMap::const_iterator nit = nodes_mapping.find(*it);
 //         AKANTU_DEBUG_ASSERT(nit != nodes_mapping.end(),
 //                             "There is an unknown node in the connectivity.");
 //         tmp_conn[i++] = nit->second;
 //       }
 
 //       ::akantu::Element el(element.type, connectivity.size());
 //       elements_mapping[element.index] = el;
 
 //       connectivity.push_back(tmp_conn);
 
 //       for (UInt i = 0; i < element.tags.size(); ++i) {
 //         std::stringstream tag_sstr;
 //         tag_sstr << "tag_" << i;
 //         Array<UInt> * data =
 //             mesh.template getDataPointer<UInt>(tag_sstr.str(), element.type,
 //             _not_ghost);
 //         data->push_back(element.tags[i]);
 //       }
 
 //       return (mesh.getNbElement() < UInt(max));
 //     }
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   template <class Iterator, typename Skipper = ascii::space_type>
 //   struct MshMeshGrammar : qi::grammar<Iterator, void(), Skipper> {
 //   public:
 //     MshMeshGrammar(Mesh & mesh)
 //         : MshMeshGrammar::base_type(start, "msh_mesh_reader"), mesh(mesh) {
 //       phx::function<lazy_element_> lazy_element;
 //       phx::function<lazy_get_nb_nodes_> lazy_get_nb_nodes;
 //       phx::function<lazy_check_value_> lazy_check_value;
 //       phx::function<lazy_node_read_> lazy_node_read;
 //       phx::function<lazy_element_read_> lazy_element_read;
 
 // clang-format off
 
 //       start
 //         =  *( known_section | unknown_section
 //             )
 //        ;
 
 //       known_section
 //         =  qi::char_("$")
 //            >> sections            [ lbs::_a = lbs::_1 ]
 //            >> qi::lazy(*lbs::_a)
 //            >> qi::lit("$End")
 //           //>> qi::lit(phx::ref(lbs::_a))
 //         ;
 
 //       unknown_section
 //         =  qi::char_("$")
 //            >> qi::char_("")     [ lbs::_a = lbs::_1 ]
 //            >> ignore_section
 //            >> qi::lit("$End")
 //            >> qi::lit(phx::val(lbs::_a))
 //         ;
 
 //       mesh_format // version followed by 0 or 1 for ascii or binary
 //         =  version >> (
 //                         ( qi::char_("0")
 //                           >> qi::int_       [ lazy_check_value(lbs::_1, 8) ]
 //                         )
 //                         | ( qi::char_("1")
 //                             >> qi::int_     [ lazy_check_value(lbs::_1, 8) ]
 //                             >> qi::dword    [ lazy_check_value(lbs::_1, 1) ]
 //                           )
 //                         )
 //         ;
 
 //       nodes
 //         =  nodes_
 //         ;
 
 //       nodes_
 //         =  qi::int_                      [ lbs::_a = lbs::_1 ]
 //            > *(
 //                 ( qi::int_ >> position ) [ lazy_node_read(phx::ref(mesh),
 //                                                           lbs::_1,
 //                                                           phx::cref(lbs::_2),
 //                                                           lbs::_a,
 //                                                           phx::ref(this->msh_nodes_to_akantu)) ]
 //               )
 //         ;
 
 //       element
 //         =  elements_
 //         ;
 
 //       elements_
 //         =  qi::int_                                 [ lbs::_a = lbs::_1 ]
 //            > qi::repeat(phx::ref(lbs::_a))[ element [ lazy_element_read(phx::ref(mesh),
 //                                                                         lbs::_1,
 //                                                                         phx::cref(lbs::_a),
 //                                                                         phx::cref(this->msh_nodes_to_akantu),
 //                                                                         phx::ref(this->msh_elemt_to_akantu)) ]]
 //         ;
 
 //       ignore_section
 //         =  *(qi::char_ - qi::char_('$'))
 //         ;
 
 //       interpolation_scheme = ignore_section;
 //       element_data         = ignore_section;
 //       node_data            = ignore_section;
 
 //       version
 //         =  qi::int_                         [ phx::push_back(lbs::_val, lbs::_1) ]
 //            >> *( qi::char_(".") >> qi::int_ [ phx::push_back(lbs::_val, lbs::_1) ] )
 //         ;
 
 //       position
 //         =  real   [ phx::push_back(lbs::_val, lbs::_1) ]
 //            > real [ phx::push_back(lbs::_val, lbs::_1) ]
 //            > real [ phx::push_back(lbs::_val, lbs::_1) ]
 //         ;
 
 //       tags
 //         =  qi::int_      [ lbs::_a = lbs::_1 ]
 //           > qi::repeat(phx::val(lbs::_a))[ qi::int_ [ phx::push_back(lbs::_val,
 //                                                                      lbs::_1) ] ]
 //         ;
 
 //       element
 //         =  ( qi::int_                [ lbs::_a = lbs::_1 ]
 //              > msh_element_type      [ lbs::_b = lazy_get_nb_nodes(lbs::_1) ]
 //              > tags                  [ lbs::_c = lbs::_1 ]
 //              > connectivity(lbs::_a) [ lbs::_d = lbs::_1 ]
 //            )                         [ lbs::_val = lazy_element(lbs::_a,
 //                                                                 phx::cref(lbs::_b),
 //                                                                 phx::cref(lbs::_c),
 //                                                                 phx::cref(lbs::_d)) ]
 //         ;
 //       connectivity
 //         =  qi::repeat(lbs::_r1)[ qi::int_ [ phx::push_back(lbs::_val,
 //                                                            lbs::_1) ] ]
 //         ;
 
 //       sections.add
 //           ("MeshFormat", &mesh_format)
 //           ("Nodes", &nodes)
 //           ("Elements", &elements)
 //           ("PhysicalNames", &physical_names)
 //           ("InterpolationScheme", &interpolation_scheme)
 //           ("ElementData", &element_data)
 //           ("NodeData", &node_data);
 
 //       msh_element_type.add
 //           ("0" , _not_defined   )
 //           ("1" , _segment_2     )
 //           ("2" , _triangle_3    )
 //           ("3" , _quadrangle_4  )
 //           ("4" , _tetrahedron_4 )
 //           ("5" , _hexahedron_8  )
 //           ("6" , _pentahedron_6 )
 //           ("7" , _not_defined   )
 //           ("8" , _segment_3     )
 //           ("9" , _triangle_6    )
 //           ("10", _not_defined   )
 //           ("11", _tetrahedron_10)
 //           ("12", _not_defined   )
 //           ("13", _not_defined   )
 //           ("14", _hexahedron_20 )
 //           ("15", _pentahedron_15)
 //           ("16", _not_defined   )
 //           ("17", _point_1       )
 //           ("18", _quadrangle_8  );
 
 //       mesh_format         .name("MeshFormat"         );
 //       nodes               .name("Nodes"              );
 //       elements            .name("Elements"           );
 //       physical_names      .name("PhysicalNames"      );
 //       interpolation_scheme.name("InterpolationScheme");
 //       element_data        .name("ElementData"        );
 //       node_data           .name("NodeData"           );
 
 // clang-format on
 //     }
 
 //     /* ----------------------------------------------------------------------
 //     */
 //     /* Rules */
 //     /* ----------------------------------------------------------------------
 //     */
 //   private:
 //     qi::symbols<char, ElementType> msh_element_type;
 //     qi::symbols<char, qi::rule<Iterator, void(), Skipper> *> sections;
 //     qi::rule<Iterator, void(), Skipper> start;
 //     qi::rule<Iterator, void(), Skipper, qi::locals<std::string> >
 //     unknown_section;
 //     qi::rule<Iterator, void(), Skipper, qi::locals<qi::rule<Iterator,
 //     Skipper> *> > known_section;
 //     qi::rule<Iterator, void(), Skipper> mesh_format, nodes, elements,
 //     physical_names, ignore_section,
 //         interpolation_scheme, element_data, node_data, any_line;
 //     qi::rule<Iterator, void(), Skipper, qi::locals<int> > nodes_;
 //     qi::rule<Iterator, void(), Skipper, qi::locals< int, int, vector<int>,
 //     vector<int> > > elements_;
 
 //     qi::rule<Iterator, std::vector<int>(), Skipper> version;
 //     qi::rule<Iterator, _Element(), Skipper, qi::locals<ElementType> >
 //     element;
 //     qi::rule<Iterator, std::vector<int>(), Skipper, qi::locals<int> > tags;
 //     qi::rule<Iterator, std::vector<int>(int), Skipper> connectivity;
 //     qi::rule<Iterator, std::vector<Real>(), Skipper> position;
 
 //     qi::real_parser<Real, qi::real_policies<Real> > real;
 
 //     /* ----------------------------------------------------------------------
 //     */
 //     /* Members */
 //     /* ----------------------------------------------------------------------
 //     */
 //   private:
 //     /// reference to the mesh to read
 //     Mesh & mesh;
 
 //     /// correspondance between the numbering of nodes in the abaqus file and
 //     in
 //     /// the akantu mesh
 //     std::map<UInt, UInt> msh_nodes_to_akantu;
 
 //     /// correspondance between the element number in the abaqus file and the
 //     /// Element in the akantu mesh
 //     std::map<UInt, Element> msh_elemt_to_akantu;
 //   };
 // }
 
 // /* --------------------------------------------------------------------------
 // */
 // void MeshIOAbaqus::read(const std::string& filename, Mesh& mesh) {
 //   namespace qi      = boost::spirit::qi;
 //   namespace ascii   = boost::spirit::ascii;
 
 //   std::ifstream infile;
 //   infile.open(filename.c_str());
 
 //   if(!infile.good()) {
-//     AKANTU_DEBUG_ERROR("Cannot open file " << filename);
+//     AKANTU_ERROR("Cannot open file " << filename);
 //   }
 
 //   std::string storage; // We will read the contents here.
 //   infile.unsetf(std::ios::skipws); // No white space skipping!
 //   std::copy(std::istream_iterator<char>(infile),
 //             std::istream_iterator<char>(),
 //             std::back_inserter(storage));
 
 //   typedef std::string::const_iterator iterator_t;
 //   typedef ascii::space_type skipper;
 //   typedef _parser::MshMeshGrammar<iterator_t, skipper> grammar;
 
 //   grammar g(mesh);
 //   skipper ws;
 
 //   iterator_t iter = storage.begin();
 //   iterator_t end  = storage.end();
 
 //   qi::phrase_parse(iter, end, g, ws);
 
 //   this->setNbGlobalNodes(mesh, mesh.getNodes().size());
 //   MeshUtils::fillElementToSubElementsData(mesh);
 // }
 
 static void my_getline(std::ifstream & infile, std::string & str) {
   std::string tmp_str;
   std::getline(infile, tmp_str);
   str = trim(tmp_str);
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIOMSH::read(const std::string & filename, Mesh & mesh) {
 
   MeshAccessor mesh_accessor(mesh);
 
   std::ifstream infile;
   infile.open(filename.c_str());
 
   std::string line;
   UInt first_node_number = std::numeric_limits<UInt>::max(),
        last_node_number = 0, file_format = 1, current_line = 0;
   bool has_physical_names = false;
 
   if (!infile.good()) {
     AKANTU_EXCEPTION("Cannot open file " << filename);
   }
 
   while (infile.good()) {
     my_getline(infile, line);
     current_line++;
 
     /// read the header
     if (line == "$MeshFormat") {
       my_getline(infile, line); /// the format line
       std::stringstream sstr(line);
       std::string version;
       sstr >> version;
       Int format;
       sstr >> format;
       if (format != 0)
-        AKANTU_DEBUG_ERROR("This reader can only read ASCII files.");
+        AKANTU_ERROR("This reader can only read ASCII files.");
       my_getline(infile, line); /// the end of block line
       current_line += 2;
       file_format = 2;
     }
 
     /// read the physical names
     if (line == "$PhysicalNames") {
       has_physical_names = true;
       my_getline(infile, line); /// the format line
       std::stringstream sstr(line);
 
       UInt num_of_phys_names;
       sstr >> num_of_phys_names;
 
       for (UInt k(0); k < num_of_phys_names; k++) {
         my_getline(infile, line);
         std::stringstream sstr_phys_name(line);
         UInt phys_name_id;
         UInt phys_dim;
 
         sstr_phys_name >> phys_dim >> phys_name_id;
 
         std::size_t b = line.find('\"');
         std::size_t e = line.rfind('\"');
         std::string phys_name = line.substr(b + 1, e - b - 1);
 
         phys_name_map[phys_name_id] = phys_name;
       }
     }
 
     /// read all nodes
     if (line == "$Nodes" || line == "$NOD") {
       UInt nb_nodes;
 
       my_getline(infile, line);
       std::stringstream sstr(line);
       sstr >> nb_nodes;
       current_line++;
 
       Array<Real> & nodes = mesh_accessor.getNodes();
       nodes.resize(nb_nodes);
       mesh_accessor.setNbGlobalNodes(nb_nodes);
 
       UInt index;
       Real coord[3];
       UInt spatial_dimension = nodes.getNbComponent();
       /// for each node, read the coordinates
       for (UInt i = 0; i < nb_nodes; ++i) {
         UInt offset = i * spatial_dimension;
 
         my_getline(infile, line);
         std::stringstream sstr_node(line);
         sstr_node >> index >> coord[0] >> coord[1] >> coord[2];
         current_line++;
 
         first_node_number = std::min(first_node_number, index);
         last_node_number = std::max(last_node_number, index);
 
         /// read the coordinates
         for (UInt j = 0; j < spatial_dimension; ++j)
           nodes.storage()[offset + j] = coord[j];
       }
       my_getline(infile, line); /// the end of block line
     }
 
     /// read all elements
     if (line == "$Elements" || line == "$ELM") {
       UInt nb_elements;
 
       std::vector<UInt> read_order;
 
       my_getline(infile, line);
       std::stringstream sstr(line);
       sstr >> nb_elements;
       current_line++;
 
       Int index;
       UInt msh_type;
       ElementType akantu_type, akantu_type_old = _not_defined;
       Array<UInt> * connectivity = nullptr;
       UInt node_per_element = 0;
 
       for (UInt i = 0; i < nb_elements; ++i) {
         my_getline(infile, line);
         std::stringstream sstr_elem(line);
         current_line++;
 
         sstr_elem >> index;
         sstr_elem >> msh_type;
 
         /// get the connectivity vector depending on the element type
         akantu_type =
             this->_msh_to_akantu_element_types[(MSHElementType)msh_type];
 
         if (akantu_type == _not_defined) {
           AKANTU_DEBUG_WARNING("Unsuported element kind "
                                << msh_type << " at line " << current_line);
           continue;
         }
 
         if (akantu_type != akantu_type_old) {
           connectivity = &mesh_accessor.getConnectivity(akantu_type);
           //          connectivity->resize(0);
 
           node_per_element = connectivity->getNbComponent();
           akantu_type_old = akantu_type;
           read_order = this->_read_order[akantu_type];
         }
 
         /// read tags informations
         if (file_format == 2) {
           UInt nb_tags;
           sstr_elem >> nb_tags;
           for (UInt j = 0; j < nb_tags; ++j) {
             Int tag;
             sstr_elem >> tag;
             std::stringstream sstr_tag_name;
             sstr_tag_name << "tag_" << j;
             Array<UInt> & data = mesh.getDataPointer<UInt>(
                 sstr_tag_name.str(), akantu_type, _not_ghost);
             data.push_back(tag);
           }
         } else if (file_format == 1) {
           Int tag;
           sstr_elem >> tag; // reg-phys
           std::string tag_name = "tag_0";
           Array<UInt> * data =
               &mesh.getDataPointer<UInt>(tag_name, akantu_type, _not_ghost);
           data->push_back(tag);
 
           sstr_elem >> tag; // reg-elem
           tag_name = "tag_1";
           data = &mesh.getDataPointer<UInt>(tag_name, akantu_type, _not_ghost);
           data->push_back(tag);
 
           sstr_elem >> tag; // number-of-nodes
         }
 
         Vector<UInt> local_connect(node_per_element);
         for (UInt j = 0; j < node_per_element; ++j) {
           UInt node_index;
           sstr_elem >> node_index;
 
           AKANTU_DEBUG_ASSERT(node_index <= last_node_number,
                               "Node number not in range : line "
                                   << current_line);
 
           node_index -= first_node_number;
           local_connect(read_order[j]) = node_index;
         }
         connectivity->push_back(local_connect);
       }
       my_getline(infile, line); /// the end of block line
     }
 
     if ((line[0] == '$') && (line.find("End") == std::string::npos)) {
       AKANTU_DEBUG_WARNING("Unsuported block_kind " << line << " at line "
                                                     << current_line);
     }
   }
 
   // mesh.updateTypesOffsets(_not_ghost);
 
   infile.close();
 
   this->constructPhysicalNames("tag_0", mesh);
 
   if (has_physical_names)
     mesh.createGroupsFromMeshData<std::string>("physical_names");
 
   MeshUtils::fillElementToSubElementsData(mesh);
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIOMSH::write(const std::string & filename, const Mesh & mesh) {
   std::ofstream outfile;
   const Array<Real> & nodes = mesh.getNodes();
 
   outfile.open(filename.c_str());
 
   outfile << "$MeshFormat" << std::endl;
   outfile << "2.1 0 8" << std::endl;
   outfile << "$EndMeshFormat" << std::endl;
 
   outfile << std::setprecision(std::numeric_limits<Real>::digits10);
   outfile << "$Nodes" << std::endl;
 
   outfile << nodes.size() << std::endl;
 
   outfile << std::uppercase;
   for (UInt i = 0; i < nodes.size(); ++i) {
     Int offset = i * nodes.getNbComponent();
     outfile << i + 1;
     for (UInt j = 0; j < nodes.getNbComponent(); ++j) {
       outfile << " " << nodes.storage()[offset + j];
     }
 
     for (UInt p = nodes.getNbComponent(); p < 3; ++p)
       outfile << " " << 0.;
     outfile << std::endl;
     ;
   }
   outfile << std::nouppercase;
   outfile << "$EndNodes" << std::endl;
   ;
 
   outfile << "$Elements" << std::endl;
   ;
 
   Int nb_elements = 0;
   for (auto && type :
        mesh.elementTypes(_all_dimensions, _not_ghost, _ek_not_defined)) {
     const Array<UInt> & connectivity = mesh.getConnectivity(type, _not_ghost);
     nb_elements += connectivity.size();
   }
   outfile << nb_elements << std::endl;
 
   UInt element_idx = 1;
   for (auto && type :
        mesh.elementTypes(_all_dimensions, _not_ghost, _ek_not_defined)) {
     const auto & connectivity = mesh.getConnectivity(type, _not_ghost);
 
     UInt * tag[2] = {nullptr, nullptr};
     if (mesh.hasData<UInt>("tag_0", type, _not_ghost)) {
       const auto & data_tag_0 = mesh.getData<UInt>("tag_0", type, _not_ghost);
       tag[0] = data_tag_0.storage();
     }
 
     if (mesh.hasData<UInt>("tag_1", type, _not_ghost)) {
       const auto & data_tag_1 = mesh.getData<UInt>("tag_1", type, _not_ghost);
       tag[1] = data_tag_1.storage();
     }
 
     for (UInt i = 0; i < connectivity.size(); ++i) {
       UInt offset = i * connectivity.getNbComponent();
       outfile << element_idx << " " << _akantu_to_msh_element_types[type]
               << " 2";
 
       /// \todo write the real data in the file
       for (UInt t = 0; t < 2; ++t)
         if (tag[t])
           outfile << " " << tag[t][i];
         else
           outfile << " 0";
 
       for (UInt j = 0; j < connectivity.getNbComponent(); ++j) {
         outfile << " " << connectivity.storage()[offset + j] + 1;
       }
       outfile << std::endl;
       element_idx++;
     }
   }
 
   outfile << "$EndElements" << std::endl;
   ;
 
   outfile.close();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/mesh/group_manager.cc b/src/mesh/group_manager.cc
index 80c078599..7989e8404 100644
--- a/src/mesh/group_manager.cc
+++ b/src/mesh/group_manager.cc
@@ -1,1042 +1,1042 @@
 /**
  * @file   group_manager.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@gmail.com>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Mon Aug 17 2015
  *
  * @brief  Stores information about ElementGroup and NodeGroup
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 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 "group_manager.hh"
 #include "aka_csr.hh"
 #include "data_accessor.hh"
 #include "element_group.hh"
 #include "element_synchronizer.hh"
 #include "mesh.hh"
 #include "mesh_accessor.hh"
 #include "mesh_utils.hh"
 #include "node_group.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <iterator>
 #include <list>
 #include <numeric>
 #include <queue>
 #include <sstream>
 #include <utility>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 GroupManager::GroupManager(const Mesh & mesh, const ID & id,
                            const MemoryID & mem_id)
     : id(id), memory_id(mem_id), mesh(mesh) {
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 GroupManager::~GroupManager() {
   auto eit = element_groups.begin();
   auto eend = element_groups.end();
   for (; eit != eend; ++eit)
     delete (eit->second);
 
   auto nit = node_groups.begin();
   auto nend = node_groups.end();
   for (; nit != nend; ++nit)
     delete (nit->second);
 }
 
 /* -------------------------------------------------------------------------- */
 NodeGroup & GroupManager::createNodeGroup(const std::string & group_name,
                                           bool replace_group) {
   AKANTU_DEBUG_IN();
 
   auto it = node_groups.find(group_name);
 
   if (it != node_groups.end()) {
     if (replace_group) {
       it->second->empty();
       AKANTU_DEBUG_OUT();
       return *(it->second);
     } else
       AKANTU_EXCEPTION(
           "Trying to create a node group that already exists:" << group_name);
   }
 
   std::stringstream sstr;
   sstr << this->id << ":" << group_name << "_node_group";
 
   NodeGroup * node_group =
       new NodeGroup(group_name, mesh, sstr.str(), memory_id);
 
   node_groups[group_name] = node_group;
 
   AKANTU_DEBUG_OUT();
 
   return *node_group;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 NodeGroup &
 GroupManager::createFilteredNodeGroup(const std::string & group_name,
                                       const NodeGroup & source_node_group,
                                       T & filter) {
   AKANTU_DEBUG_IN();
 
   NodeGroup & node_group = this->createNodeGroup(group_name);
   node_group.append(source_node_group);
   if (T::type == FilterFunctor::_node_filter_functor) {
     node_group.applyNodeFilter(filter);
   } else {
-    AKANTU_DEBUG_ERROR("ElementFilter cannot be applied to NodeGroup yet."
+    AKANTU_ERROR("ElementFilter cannot be applied to NodeGroup yet."
                        << " Needs to be implemented.");
   }
 
   AKANTU_DEBUG_OUT();
   return node_group;
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::destroyNodeGroup(const std::string & group_name) {
   AKANTU_DEBUG_IN();
 
   auto nit = node_groups.find(group_name);
   auto nend = node_groups.end();
   if (nit != nend) {
     delete (nit->second);
     node_groups.erase(nit);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 ElementGroup & GroupManager::createElementGroup(const std::string & group_name,
                                                 UInt dimension,
                                                 bool replace_group) {
   AKANTU_DEBUG_IN();
 
   NodeGroup & new_node_group =
       createNodeGroup(group_name + "_nodes", replace_group);
 
   auto it = element_groups.find(group_name);
 
   if (it != element_groups.end()) {
     if (replace_group) {
       it->second->empty();
       AKANTU_DEBUG_OUT();
       return *(it->second);
     } else
       AKANTU_EXCEPTION("Trying to create a element group that already exists:"
                        << group_name);
   }
 
   std::stringstream sstr;
   sstr << this->id << ":" << group_name << "_element_group";
 
   ElementGroup * element_group = new ElementGroup(
       group_name, mesh, new_node_group, dimension, sstr.str(), memory_id);
 
   std::stringstream sstr_nodes;
   sstr_nodes << group_name << "_nodes";
 
   node_groups[sstr_nodes.str()] = &new_node_group;
   element_groups[group_name] = element_group;
 
   AKANTU_DEBUG_OUT();
 
   return *element_group;
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::destroyElementGroup(const std::string & group_name,
                                        bool destroy_node_group) {
   AKANTU_DEBUG_IN();
 
   auto eit = element_groups.find(group_name);
   auto eend = element_groups.end();
   if (eit != eend) {
     if (destroy_node_group)
       destroyNodeGroup(eit->second->getNodeGroup().getName());
     delete (eit->second);
     element_groups.erase(eit);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::destroyAllElementGroups(bool destroy_node_groups) {
   AKANTU_DEBUG_IN();
 
   auto eit = element_groups.begin();
   auto eend = element_groups.end();
   for (; eit != eend; ++eit) {
     if (destroy_node_groups)
       destroyNodeGroup(eit->second->getNodeGroup().getName());
     delete (eit->second);
   }
   element_groups.clear();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 ElementGroup & GroupManager::createElementGroup(const std::string & group_name,
                                                 UInt dimension,
                                                 NodeGroup & node_group) {
   AKANTU_DEBUG_IN();
 
   if (element_groups.find(group_name) != element_groups.end())
     AKANTU_EXCEPTION(
         "Trying to create a element group that already exists:" << group_name);
 
   ElementGroup * element_group =
       new ElementGroup(group_name, mesh, node_group, dimension,
                        id + ":" + group_name + "_element_group", memory_id);
 
   element_groups[group_name] = element_group;
 
   AKANTU_DEBUG_OUT();
 
   return *element_group;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 ElementGroup & GroupManager::createFilteredElementGroup(
     const std::string & group_name, UInt dimension,
     const NodeGroup & node_group, T & filter) {
   AKANTU_DEBUG_IN();
 
   ElementGroup * element_group = nullptr;
 
   if (T::type == FilterFunctor::_node_filter_functor) {
     NodeGroup & filtered_node_group = this->createFilteredNodeGroup(
         group_name + "_nodes", node_group, filter);
     element_group =
         &(this->createElementGroup(group_name, dimension, filtered_node_group));
   } else if (T::type == FilterFunctor::_element_filter_functor) {
-    AKANTU_DEBUG_ERROR(
+    AKANTU_ERROR(
         "Cannot handle an ElementFilter yet. Needs to be implemented.");
   }
 
   AKANTU_DEBUG_OUT();
 
   return *element_group;
 }
 
 /* -------------------------------------------------------------------------- */
 class ClusterSynchronizer : public DataAccessor<Element> {
   using DistantIDs = std::set<std::pair<UInt, UInt>>;
 
 public:
   ClusterSynchronizer(GroupManager & group_manager, UInt element_dimension,
                       std::string cluster_name_prefix,
                       ElementTypeMapArray<UInt> & element_to_fragment,
                       const ElementSynchronizer & element_synchronizer,
                       UInt nb_cluster)
       : group_manager(group_manager), element_dimension(element_dimension),
         cluster_name_prefix(std::move(cluster_name_prefix)),
         element_to_fragment(element_to_fragment),
         element_synchronizer(element_synchronizer), nb_cluster(nb_cluster) {}
 
   UInt synchronize() {
     Communicator & comm = Communicator::getStaticCommunicator();
     UInt rank = comm.whoAmI();
     UInt nb_proc = comm.getNbProc();
 
     /// find starting index to renumber local clusters
     Array<UInt> nb_cluster_per_proc(nb_proc);
     nb_cluster_per_proc(rank) = nb_cluster;
     comm.allGather(nb_cluster_per_proc);
 
     starting_index = std::accumulate(nb_cluster_per_proc.begin(),
                                      nb_cluster_per_proc.begin() + rank, 0);
 
     UInt global_nb_fragment =
         std::accumulate(nb_cluster_per_proc.begin() + rank,
                         nb_cluster_per_proc.end(), starting_index);
 
     /// create the local to distant cluster pairs with neighbors
     element_synchronizer.synchronizeOnce(*this, _gst_gm_clusters);
 
     /// count total number of pairs
     Array<int> nb_pairs(nb_proc); // This is potentially a bug for more than
     // 2**31 pairs, but due to a all gatherv after
     // it must be int to match MPI interfaces
     nb_pairs(rank) = distant_ids.size();
     comm.allGather(nb_pairs);
 
     UInt total_nb_pairs = std::accumulate(nb_pairs.begin(), nb_pairs.end(), 0);
 
     /// generate pairs global array
     UInt local_pair_index =
         std::accumulate(nb_pairs.storage(), nb_pairs.storage() + rank, 0);
 
     Array<UInt> total_pairs(total_nb_pairs, 2);
 
     for (auto & ids : distant_ids) {
       total_pairs(local_pair_index, 0) = ids.first;
       total_pairs(local_pair_index, 1) = ids.second;
       ++local_pair_index;
     }
 
     /// communicate pairs to all processors
     nb_pairs *= 2;
     comm.allGatherV(total_pairs, nb_pairs);
 
     /// renumber clusters
 
     /// generate fragment list
     std::vector<std::set<UInt>> global_clusters;
     UInt total_nb_cluster = 0;
 
     Array<bool> is_fragment_in_cluster(global_nb_fragment, 1, false);
     std::queue<UInt> fragment_check_list;
 
     while (total_pairs.size() != 0) {
       /// create a new cluster
       ++total_nb_cluster;
       global_clusters.resize(total_nb_cluster);
       std::set<UInt> & current_cluster = global_clusters[total_nb_cluster - 1];
 
       UInt first_fragment = total_pairs(0, 0);
       UInt second_fragment = total_pairs(0, 1);
       total_pairs.erase(0);
 
       fragment_check_list.push(first_fragment);
       fragment_check_list.push(second_fragment);
 
       while (!fragment_check_list.empty()) {
         UInt current_fragment = fragment_check_list.front();
 
         UInt * total_pairs_end =
             total_pairs.storage() + total_pairs.size() * 2;
 
         UInt * fragment_found =
             std::find(total_pairs.storage(), total_pairs_end, current_fragment);
 
         if (fragment_found != total_pairs_end) {
           UInt position = fragment_found - total_pairs.storage();
           UInt pair = position / 2;
           UInt other_index = (position + 1) % 2;
           fragment_check_list.push(total_pairs(pair, other_index));
           total_pairs.erase(pair);
         } else {
           fragment_check_list.pop();
           current_cluster.insert(current_fragment);
           is_fragment_in_cluster(current_fragment) = true;
         }
       }
     }
 
     /// add to FragmentToCluster all local fragments
     for (UInt c = 0; c < global_nb_fragment; ++c) {
       if (!is_fragment_in_cluster(c)) {
         ++total_nb_cluster;
         global_clusters.resize(total_nb_cluster);
         std::set<UInt> & current_cluster =
             global_clusters[total_nb_cluster - 1];
 
         current_cluster.insert(c);
       }
     }
 
     /// reorganize element groups to match global clusters
     for (UInt c = 0; c < global_clusters.size(); ++c) {
 
       /// create new element group corresponding to current cluster
       std::stringstream sstr;
       sstr << cluster_name_prefix << "_" << c;
       ElementGroup & cluster =
           group_manager.createElementGroup(sstr.str(), element_dimension, true);
 
       auto it = global_clusters[c].begin();
       auto end = global_clusters[c].end();
 
       /// append to current element group all fragments that belong to
       /// the same cluster if they exist
       for (; it != end; ++it) {
         Int local_index = *it - starting_index;
 
         if (local_index < 0 || local_index >= Int(nb_cluster))
           continue;
 
         std::stringstream tmp_sstr;
         tmp_sstr << "tmp_" << cluster_name_prefix << "_" << local_index;
         auto eg_it = group_manager.element_group_find(tmp_sstr.str());
 
         AKANTU_DEBUG_ASSERT(eg_it != group_manager.element_group_end(),
                             "Temporary fragment \"" << tmp_sstr.str()
                                                     << "\" not found");
 
         cluster.append(*(eg_it->second));
         group_manager.destroyElementGroup(tmp_sstr.str(), true);
       }
     }
 
     return total_nb_cluster;
   }
 
 private:
   /// functions for parallel communications
   inline UInt getNbData(const Array<Element> & elements,
                         const SynchronizationTag & tag) const override {
     if (tag == _gst_gm_clusters)
       return elements.size() * sizeof(UInt);
 
     return 0;
   }
 
   inline void packData(CommunicationBuffer & buffer,
                        const Array<Element> & elements,
                        const SynchronizationTag & tag) const override {
     if (tag != _gst_gm_clusters)
       return;
 
     Array<Element>::const_iterator<> el_it = elements.begin();
     Array<Element>::const_iterator<> el_end = elements.end();
 
     for (; el_it != el_end; ++el_it) {
 
       const Element & el = *el_it;
 
       /// for each element pack its global cluster index
       buffer << element_to_fragment(el.type, el.ghost_type)(el.element) +
                     starting_index;
     }
   }
 
   inline void unpackData(CommunicationBuffer & buffer,
                          const Array<Element> & elements,
                          const SynchronizationTag & tag) override {
     if (tag != _gst_gm_clusters)
       return;
 
     Array<Element>::const_iterator<> el_it = elements.begin();
     Array<Element>::const_iterator<> el_end = elements.end();
 
     for (; el_it != el_end; ++el_it) {
       UInt distant_cluster;
 
       buffer >> distant_cluster;
 
       const Element & el = *el_it;
       UInt local_cluster =
           element_to_fragment(el.type, el.ghost_type)(el.element) +
           starting_index;
 
       distant_ids.insert(std::make_pair(local_cluster, distant_cluster));
     }
   }
 
 private:
   GroupManager & group_manager;
   UInt element_dimension;
   std::string cluster_name_prefix;
   ElementTypeMapArray<UInt> & element_to_fragment;
   const ElementSynchronizer & element_synchronizer;
 
   UInt nb_cluster;
   DistantIDs distant_ids;
 
   UInt starting_index;
 };
 
 /* -------------------------------------------------------------------------- */
 /// \todo this function doesn't work in 1D
 UInt GroupManager::createBoundaryGroupFromGeometry() {
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   return createClusters(spatial_dimension - 1, "boundary");
 }
 
 /* -------------------------------------------------------------------------- */
 UInt GroupManager::createClusters(
     UInt element_dimension, Mesh & mesh_facets, std::string cluster_name_prefix,
     const GroupManager::ClusteringFilter & filter) {
   return createClusters(element_dimension, std::move(cluster_name_prefix),
                         filter, mesh_facets);
 }
 
 /* -------------------------------------------------------------------------- */
 UInt GroupManager::createClusters(
     UInt element_dimension, std::string cluster_name_prefix,
     const GroupManager::ClusteringFilter & filter) {
   std::unique_ptr<Mesh> mesh_facets;
   if (!mesh_facets && element_dimension > 0) {
     MeshAccessor mesh_accessor(const_cast<Mesh &>(mesh));
     mesh_facets = std::make_unique<Mesh>(mesh.getSpatialDimension(),
                                          mesh_accessor.getNodesSharedPtr(),
                                          "mesh_facets_for_clusters");
 
     mesh_facets->defineMeshParent(mesh);
 
     MeshUtils::buildAllFacets(mesh, *mesh_facets, element_dimension,
                               element_dimension - 1);
   }
 
   return createClusters(element_dimension, std::move(cluster_name_prefix),
                         filter, *mesh_facets);
 }
 
 /* -------------------------------------------------------------------------- */
 //// \todo if needed element list construction can be optimized by
 //// templating the filter class
 UInt GroupManager::createClusters(UInt element_dimension,
                                   const std::string & cluster_name_prefix,
                                   const GroupManager::ClusteringFilter & filter,
                                   Mesh & mesh_facets) {
   AKANTU_DEBUG_IN();
 
   UInt nb_proc = mesh.getCommunicator().getNbProc();
   std::string tmp_cluster_name_prefix = cluster_name_prefix;
 
   ElementTypeMapArray<UInt> * element_to_fragment = nullptr;
 
   if (nb_proc > 1 && mesh.isDistributed()) {
     element_to_fragment =
         new ElementTypeMapArray<UInt>("element_to_fragment", id, memory_id);
 
     element_to_fragment->initialize(
         mesh, _nb_component = 1, _spatial_dimension = element_dimension,
         _element_kind = _ek_not_defined, _with_nb_element = true);
     // mesh.initElementTypeMapArray(*element_to_fragment, 1, element_dimension,
     //                              false, _ek_not_defined, true);
     tmp_cluster_name_prefix = "tmp_" + tmp_cluster_name_prefix;
   }
 
   ElementTypeMapArray<bool> seen_elements("seen_elements", id, memory_id);
   seen_elements.initialize(mesh, _spatial_dimension = element_dimension,
                            _element_kind = _ek_not_defined,
                            _with_nb_element = true);
   // mesh.initElementTypeMapArray(seen_elements, 1, element_dimension, false,
   //                              _ek_not_defined, true);
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType ghost_type = *gt;
     Element el;
     el.ghost_type = ghost_type;
 
     Mesh::type_iterator type_it =
         mesh.firstType(element_dimension, ghost_type, _ek_not_defined);
     Mesh::type_iterator type_end =
         mesh.lastType(element_dimension, ghost_type, _ek_not_defined);
 
     for (; type_it != type_end; ++type_it) {
       el.type = *type_it;
       UInt nb_element = mesh.getNbElement(*type_it, ghost_type);
       Array<bool> & seen_elements_array = seen_elements(el.type, ghost_type);
 
       for (UInt e = 0; e < nb_element; ++e) {
         el.element = e;
         if (!filter(el))
           seen_elements_array(e) = true;
       }
     }
   }
 
   Array<bool> checked_node(mesh.getNbNodes(), 1, false);
 
   UInt nb_cluster = 0;
 
   /// keep looping until all elements are seen
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType ghost_type = *gt;
     Element uns_el;
     uns_el.ghost_type = ghost_type;
 
     Mesh::type_iterator type_it =
         mesh.firstType(element_dimension, ghost_type, _ek_not_defined);
     Mesh::type_iterator type_end =
         mesh.lastType(element_dimension, ghost_type, _ek_not_defined);
 
     for (; type_it != type_end; ++type_it) {
       uns_el.type = *type_it;
       Array<bool> & seen_elements_vec =
           seen_elements(uns_el.type, uns_el.ghost_type);
 
       for (UInt e = 0; e < seen_elements_vec.size(); ++e) {
         // skip elements that have been already seen
         if (seen_elements_vec(e) == true)
           continue;
 
         // set current element
         uns_el.element = e;
         seen_elements_vec(e) = true;
 
         /// create a new cluster
         std::stringstream sstr;
         sstr << tmp_cluster_name_prefix << "_" << nb_cluster;
         ElementGroup & cluster =
             createElementGroup(sstr.str(), element_dimension, true);
         ++nb_cluster;
 
         // point element are cluster by themself
         if (element_dimension == 0) {
           cluster.add(uns_el);
 
           UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(uns_el.type);
           Vector<UInt> connect =
               mesh.getConnectivity(uns_el.type, uns_el.ghost_type)
                   .begin(nb_nodes_per_element)[uns_el.element];
           for (UInt n = 0; n < nb_nodes_per_element; ++n) {
             /// add element's nodes to the cluster
             UInt node = connect[n];
             if (!checked_node(node)) {
               cluster.addNode(node);
               checked_node(node) = true;
             }
           }
 
           continue;
         }
 
         std::queue<Element> element_to_add;
         element_to_add.push(uns_el);
 
         /// keep looping until current cluster is complete (no more
         /// connected elements)
         while (!element_to_add.empty()) {
 
           /// take first element and erase it in the queue
           Element el = element_to_add.front();
           element_to_add.pop();
 
           /// if parallel, store cluster index per element
           if (nb_proc > 1 && mesh.isDistributed())
             (*element_to_fragment)(el.type, el.ghost_type)(el.element) =
                 nb_cluster - 1;
 
           /// add current element to the cluster
           cluster.add(el);
 
           const Array<Element> & element_to_facet =
               mesh_facets.getSubelementToElement(el.type, el.ghost_type);
 
           UInt nb_facet_per_element = element_to_facet.getNbComponent();
 
           for (UInt f = 0; f < nb_facet_per_element; ++f) {
             const Element & facet = element_to_facet(el.element, f);
 
             if (facet == ElementNull)
               continue;
 
             const std::vector<Element> & connected_elements =
                 mesh_facets.getElementToSubelement(
                     facet.type, facet.ghost_type)(facet.element);
 
             for (UInt elem = 0; elem < connected_elements.size(); ++elem) {
               const Element & check_el = connected_elements[elem];
 
               // check if this element has to be skipped
               if (check_el == ElementNull || check_el == el)
                 continue;
 
               Array<bool> & seen_elements_vec_current =
                   seen_elements(check_el.type, check_el.ghost_type);
 
               if (seen_elements_vec_current(check_el.element) == false) {
                 seen_elements_vec_current(check_el.element) = true;
                 element_to_add.push(check_el);
               }
             }
           }
 
           UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(el.type);
           Vector<UInt> connect = mesh.getConnectivity(el.type, el.ghost_type)
                                      .begin(nb_nodes_per_element)[el.element];
           for (UInt n = 0; n < nb_nodes_per_element; ++n) {
             /// add element's nodes to the cluster
             UInt node = connect[n];
             if (!checked_node(node)) {
               cluster.addNode(node, false);
               checked_node(node) = true;
             }
           }
         }
       }
     }
   }
 
   if (nb_proc > 1 && mesh.isDistributed()) {
     ClusterSynchronizer cluster_synchronizer(
         *this, element_dimension, cluster_name_prefix, *element_to_fragment,
         this->mesh.getElementSynchronizer(), nb_cluster);
     nb_cluster = cluster_synchronizer.synchronize();
     delete element_to_fragment;
   }
 
   if (mesh.isDistributed())
     this->synchronizeGroupNames();
 
   AKANTU_DEBUG_OUT();
   return nb_cluster;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void GroupManager::createGroupsFromMeshData(const std::string & dataset_name) {
   std::set<std::string> group_names;
   const ElementTypeMapArray<T> & datas = mesh.getData<T>(dataset_name);
   using type_iterator =
       typename ElementTypeMapArray<T>::type_iterator;
 
   std::map<std::string, UInt> group_dim;
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     type_iterator type_it = datas.firstType(_all_dimensions, *gt);
     type_iterator type_end = datas.lastType(_all_dimensions, *gt);
     for (; type_it != type_end; ++type_it) {
       const Array<T> & dataset = datas(*type_it, *gt);
       UInt nb_element = mesh.getNbElement(*type_it, *gt);
       AKANTU_DEBUG_ASSERT(dataset.size() == nb_element,
                           "Not the same number of elements ("
                               << *type_it << ":" << *gt
                               << ") in the map from MeshData ("
                               << dataset.size() << ") " << dataset_name
                               << " and in the mesh (" << nb_element << ")!");
       for (UInt e(0); e < nb_element; ++e) {
         std::stringstream sstr;
         sstr << dataset(e);
         std::string gname = sstr.str();
         group_names.insert(gname);
 
         auto it = group_dim.find(gname);
         if (it == group_dim.end()) {
           group_dim[gname] = mesh.getSpatialDimension(*type_it);
         } else {
           it->second = std::max(it->second, mesh.getSpatialDimension(*type_it));
         }
       }
     }
   }
 
   auto git = group_names.begin();
   auto gend = group_names.end();
   for (; git != gend; ++git)
     createElementGroup(*git, group_dim[*git]);
 
   if (mesh.isDistributed())
     this->synchronizeGroupNames();
 
   Element el;
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     el.ghost_type = *gt;
 
     type_iterator type_it = datas.firstType(_all_dimensions, *gt);
     type_iterator type_end = datas.lastType(_all_dimensions, *gt);
     for (; type_it != type_end; ++type_it) {
       el.type = *type_it;
 
       const Array<T> & dataset = datas(*type_it, *gt);
       UInt nb_element = mesh.getNbElement(*type_it, *gt);
       AKANTU_DEBUG_ASSERT(dataset.size() == nb_element,
                           "Not the same number of elements in the map from "
                           "MeshData and in the mesh!");
 
       UInt nb_nodes_per_element = mesh.getNbNodesPerElement(el.type);
 
       Array<UInt>::const_iterator<Vector<UInt>> cit =
           mesh.getConnectivity(*type_it, *gt).begin(nb_nodes_per_element);
 
       for (UInt e(0); e < nb_element; ++e, ++cit) {
         el.element = e;
         std::stringstream sstr;
         sstr << dataset(e);
         ElementGroup & group = getElementGroup(sstr.str());
         group.add(el, false, false);
 
         const Vector<UInt> & connect = *cit;
         for (UInt n = 0; n < nb_nodes_per_element; ++n) {
           UInt node = connect[n];
           group.addNode(node, false);
         }
       }
     }
   }
 
   git = group_names.begin();
   for (; git != gend; ++git) {
     getElementGroup(*git).optimize();
   }
 }
 
 template void GroupManager::createGroupsFromMeshData<std::string>(
     const std::string & dataset_name);
 template void
 GroupManager::createGroupsFromMeshData<UInt>(const std::string & dataset_name);
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::createElementGroupFromNodeGroup(
     const std::string & name, const std::string & node_group_name,
     UInt dimension) {
   NodeGroup & node_group = getNodeGroup(node_group_name);
   ElementGroup & group = createElementGroup(name, dimension, node_group);
 
   group.fillFromNodeGroup();
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "GroupManager [" << std::endl;
 
   std::set<std::string> node_group_seen;
   for (auto it(element_group_begin()); it != element_group_end(); ++it) {
     it->second->printself(stream, indent + 1);
     node_group_seen.insert(it->second->getNodeGroup().getName());
   }
 
   for (auto it(node_group_begin()); it != node_group_end(); ++it) {
     if (node_group_seen.find(it->second->getName()) == node_group_seen.end())
       it->second->printself(stream, indent + 1);
   }
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 UInt GroupManager::getNbElementGroups(UInt dimension) const {
   if (dimension == _all_dimensions)
     return element_groups.size();
 
   auto it = element_groups.begin();
   auto end = element_groups.end();
   UInt count = 0;
   for (; it != end; ++it)
     count += (it->second->getDimension() == dimension);
   return count;
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::checkAndAddGroups(CommunicationBuffer & buffer) {
   AKANTU_DEBUG_IN();
 
   UInt nb_node_group;
   buffer >> nb_node_group;
   AKANTU_DEBUG_INFO("Received " << nb_node_group << " node group names");
 
   for (UInt ng = 0; ng < nb_node_group; ++ng) {
     std::string node_group_name;
     buffer >> node_group_name;
 
     if (node_groups.find(node_group_name) == node_groups.end()) {
       this->createNodeGroup(node_group_name);
     }
 
     AKANTU_DEBUG_INFO("Received node goup name: " << node_group_name);
   }
 
   UInt nb_element_group;
   buffer >> nb_element_group;
   AKANTU_DEBUG_INFO("Received " << nb_element_group << " element group names");
   for (UInt eg = 0; eg < nb_element_group; ++eg) {
     std::string element_group_name;
     buffer >> element_group_name;
     std::string node_group_name;
     buffer >> node_group_name;
     UInt dim;
     buffer >> dim;
 
     AKANTU_DEBUG_INFO("Received element group name: "
                       << element_group_name << " corresponding to a "
                       << Int(dim) << "D group with node group "
                       << node_group_name);
 
     NodeGroup & node_group = *node_groups[node_group_name];
 
     if (element_groups.find(element_group_name) == element_groups.end()) {
       this->createElementGroup(element_group_name, dim, node_group);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::fillBufferWithGroupNames(
     DynamicCommunicationBuffer & comm_buffer) const {
   AKANTU_DEBUG_IN();
 
   // packing node group names;
   UInt nb_groups = this->node_groups.size();
   comm_buffer << nb_groups;
   AKANTU_DEBUG_INFO("Sending " << nb_groups << " node group names");
 
   auto nnames_it = node_groups.begin();
   auto nnames_end = node_groups.end();
   for (; nnames_it != nnames_end; ++nnames_it) {
     std::string node_group_name = nnames_it->first;
     comm_buffer << node_group_name;
     AKANTU_DEBUG_INFO("Sending node goupe name: " << node_group_name);
   }
 
   // packing element group names with there associated node group name
   nb_groups = this->element_groups.size();
   comm_buffer << nb_groups;
   AKANTU_DEBUG_INFO("Sending " << nb_groups << " element group names");
   auto gnames_it = this->element_groups.begin();
   auto gnames_end = this->element_groups.end();
   for (; gnames_it != gnames_end; ++gnames_it) {
     ElementGroup & element_group = *(gnames_it->second);
     std::string element_group_name = gnames_it->first;
     std::string node_group_name = element_group.getNodeGroup().getName();
     UInt dim = element_group.getDimension();
 
     comm_buffer << element_group_name;
     comm_buffer << node_group_name;
     comm_buffer << dim;
 
     AKANTU_DEBUG_INFO("Sending element group name: "
                       << element_group_name << " corresponding to a "
                       << Int(dim) << "D group with the node group "
                       << node_group_name);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::synchronizeGroupNames() {
   AKANTU_DEBUG_IN();
 
   const Communicator & comm = mesh.getCommunicator();
   Int nb_proc = comm.getNbProc();
   Int my_rank = comm.whoAmI();
 
   if (nb_proc == 1)
     return;
 
   if (my_rank == 0) {
     for (Int p = 1; p < nb_proc; ++p) {
       CommunicationStatus status;
       comm.probe<char>(p, p, status);
       AKANTU_DEBUG_INFO("Got " << printMemorySize<char>(status.size())
                                << " from proc " << p);
 
       CommunicationBuffer recv_buffer(status.size());
       comm.receive(recv_buffer, p, p);
 
       this->checkAndAddGroups(recv_buffer);
     }
 
     DynamicCommunicationBuffer comm_buffer;
     this->fillBufferWithGroupNames(comm_buffer);
 
     UInt buffer_size = comm_buffer.size();
 
     comm.broadcast(buffer_size, 0);
 
     AKANTU_DEBUG_INFO("Initiating broadcast with "
                       << printMemorySize<char>(comm_buffer.size()));
     comm.broadcast(comm_buffer, 0);
 
   } else {
     DynamicCommunicationBuffer comm_buffer;
     this->fillBufferWithGroupNames(comm_buffer);
 
     AKANTU_DEBUG_INFO("Sending " << printMemorySize<char>(comm_buffer.size())
                                  << " to proc " << 0);
     comm.send(comm_buffer, 0, my_rank);
 
     UInt buffer_size = 0;
     comm.broadcast(buffer_size, 0);
 
     AKANTU_DEBUG_INFO("Receiving broadcast with "
                       << printMemorySize<char>(comm_buffer.size()));
     CommunicationBuffer recv_buffer(buffer_size);
     comm.broadcast(recv_buffer, 0);
 
     this->checkAndAddGroups(recv_buffer);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 const ElementGroup &
 GroupManager::getElementGroup(const std::string & name) const {
   auto it = element_group_find(name);
   if (it == element_group_end()) {
     AKANTU_EXCEPTION("There are no element groups named "
                      << name << " associated to the group manager: " << id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 ElementGroup & GroupManager::getElementGroup(const std::string & name) {
   auto it = element_group_find(name);
   if (it == element_group_end()) {
     AKANTU_EXCEPTION("There are no element groups named "
                      << name << " associated to the group manager: " << id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 const NodeGroup & GroupManager::getNodeGroup(const std::string & name) const {
   auto it = node_group_find(name);
   if (it == node_group_end()) {
     AKANTU_EXCEPTION("There are no node groups named "
                      << name << " associated to the group manager: " << id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 NodeGroup & GroupManager::getNodeGroup(const std::string & name) {
   auto it = node_group_find(name);
   if (it == node_group_end()) {
     AKANTU_EXCEPTION("There are no node groups named "
                      << name << " associated to the group manager: " << id);
   }
 
   return *(it->second);
 }
 
 } // namespace akantu
diff --git a/src/mesh/mesh.cc b/src/mesh/mesh.cc
index 49cd44069..88c7d1050 100644
--- a/src/mesh/mesh.cc
+++ b/src/mesh/mesh.cc
@@ -1,571 +1,571 @@
 /**
  * @file   mesh.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  class handling meshes
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "aka_config.hh"
 /* -------------------------------------------------------------------------- */
 #include "element_class.hh"
 #include "group_manager_inline_impl.cc"
 #include "mesh.hh"
 #include "mesh_io.hh"
 #include "mesh_iterators.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 #include "communicator.hh"
 #include "element_synchronizer.hh"
 #include "facet_synchronizer.hh"
 #include "mesh_utils_distribution.hh"
 #include "node_synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 #ifdef AKANTU_USE_IOHELPER
 #include "dumper_field.hh"
 #include "dumper_internal_material_field.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 #include <limits>
 #include <sstream>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Mesh::Mesh(UInt spatial_dimension, const ID & id, const MemoryID & memory_id,
            Communicator & communicator)
     : Memory(id, memory_id),
       GroupManager(*this, id + ":group_manager", memory_id),
       nodes_type(0, 1, id + ":nodes_type"),
       connectivities("connectivities", id, memory_id),
       ghosts_counters("ghosts_counters", id, memory_id),
       normals("normals", id, memory_id), spatial_dimension(spatial_dimension),
       lower_bounds(spatial_dimension, 0.), upper_bounds(spatial_dimension, 0.),
       size(spatial_dimension, 0.), local_lower_bounds(spatial_dimension, 0.),
       local_upper_bounds(spatial_dimension, 0.),
       mesh_data("mesh_data", id, memory_id), communicator(&communicator) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Mesh::Mesh(UInt spatial_dimension, Communicator & communicator, const ID & id,
            const MemoryID & memory_id)
     : Mesh(spatial_dimension, id, memory_id, communicator) {
   AKANTU_DEBUG_IN();
 
   this->nodes =
       std::make_shared<Array<Real>>(0, spatial_dimension, id + ":coordinates");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Mesh::Mesh(UInt spatial_dimension, const ID & id, const MemoryID & memory_id)
     : Mesh(spatial_dimension, Communicator::getStaticCommunicator(), id,
            memory_id) {}
 
 /* -------------------------------------------------------------------------- */
 Mesh::Mesh(UInt spatial_dimension, const std::shared_ptr<Array<Real>> & nodes,
            const ID & id, const MemoryID & memory_id)
     : Mesh(spatial_dimension, id, memory_id,
            Communicator::getStaticCommunicator()) {
   this->nodes = nodes;
 
   this->nb_global_nodes = this->nodes->size();
 
   this->nodes_to_elements.resize(nodes->size());
   for (auto & node_set : nodes_to_elements) {
     node_set = std::make_unique<std::set<Element>>();
   }
 
   this->computeBoundingBox();
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::getBarycenters(Array<Real> & barycenter, const ElementType & type,
                           const GhostType & ghost_type) const {
   barycenter.resize(getNbElement(type, ghost_type));
   for (auto && data : enumerate(make_view(barycenter, spatial_dimension))) {
     getBarycenter(Element{type, UInt(std::get<0>(data)), ghost_type},
                   std::get<1>(data));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 Mesh & Mesh::initMeshFacets(const ID & id) {
   AKANTU_DEBUG_IN();
 
   if (!mesh_facets) {
     mesh_facets = std::make_unique<Mesh>(spatial_dimension, this->nodes,
                                          getID() + ":" + id, getMemoryID());
 
     mesh_facets->mesh_parent = this;
     mesh_facets->is_mesh_facets = true;
 
     MeshUtils::buildAllFacets(*this, *mesh_facets, 0);
 
     if (mesh.isDistributed()) {
       mesh_facets->is_distributed = true;
       mesh_facets->element_synchronizer = std::make_unique<FacetSynchronizer>(
           *mesh_facets, mesh.getElementSynchronizer());
     }
 
     /// transfers the the mesh physical names to the mesh facets
     if (not this->hasData("physical_names")) {
       AKANTU_DEBUG_OUT();
       return *mesh_facets;
     }
 
     if (not mesh_facets->hasData("physical_names")) {
       mesh_facets->registerData<std::string>("physical_names");
     }
 
     auto & mesh_phys_data = this->getData<std::string>("physical_names");
     auto & phys_data = mesh_facets->getData<std::string>("physical_names");
     phys_data.initialize(*mesh_facets,
                          _spatial_dimension = spatial_dimension - 1,
                          _with_nb_element = true);
 
     ElementTypeMapArray<Real> barycenters(getID(), "temporary_barycenters");
     barycenters.initialize(*mesh_facets, _nb_component = spatial_dimension,
                            _spatial_dimension = spatial_dimension - 1,
                            _with_nb_element = true);
 
     for (auto && ghost_type : ghost_types) {
       for (auto && type : barycenters.elementTypes(
                spatial_dimension - 1, ghost_type)) {
         mesh_facets->getBarycenters(barycenters(type, ghost_type), type,
                                     ghost_type);
       }
     }
 
     for_each_element(
         mesh,
         [&](auto && element) {
           Vector<Real> barycenter(spatial_dimension);
           mesh.getBarycenter(element, barycenter);
           auto norm_barycenter = barycenter.norm();
           auto tolerance = Math::getTolerance();
           if (norm_barycenter > tolerance)
             tolerance *= norm_barycenter;
 
           const auto & element_to_facet = mesh_facets->getElementToSubelement(
               element.type, element.ghost_type);
 
           Vector<Real> barycenter_facet(spatial_dimension);
 
           auto range =
               enumerate(make_view(barycenters(element.type, element.ghost_type),
                                   spatial_dimension));
 #ifndef AKANTU_NDEBUG
           auto min_dist = std::numeric_limits<Real>::max();
 #endif
           // this is a spacial search coded the most inefficient way.
           auto facet =
               std::find_if(range.begin(), range.end(), [&](auto && data) {
                 auto facet = std::get<0>(data);
                 if (element_to_facet(facet)[1] == ElementNull)
                   return false;
 
                 auto norm_distance = barycenter.distance(std::get<1>(data));
 #ifndef AKANTU_NDEBUG
                 min_dist = std::min(min_dist, norm_distance);
 #endif
                 return (norm_distance < tolerance);
               });
 
           if (facet == range.end()) {
             AKANTU_DEBUG_INFO("The element "
                               << element
                               << " did not find its associated facet in the "
                                  "mesh_facets! Try to decrease math tolerance. "
                                  "The closest element was at a distance of "
                               << min_dist);
             return;
           }
 
           // set physical name
           phys_data(Element{element.type, UInt(std::get<0>(*facet)),
                             element.ghost_type}) = mesh_phys_data(element);
         },
         _spatial_dimension = spatial_dimension - 1);
 
     mesh_facets->createGroupsFromMeshData<std::string>("physical_names");
   }
 
   AKANTU_DEBUG_OUT();
   return *mesh_facets;
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::defineMeshParent(const Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   this->mesh_parent = &mesh;
   this->is_mesh_facets = true;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Mesh::~Mesh() = default;
 
 /* -------------------------------------------------------------------------- */
 void Mesh::read(const std::string & filename, const MeshIOType & mesh_io_type) {
   MeshIO mesh_io;
   mesh_io.read(filename, *this, mesh_io_type);
 
   type_iterator it =
       this->firstType(spatial_dimension, _not_ghost, _ek_not_defined);
   type_iterator last =
       this->lastType(spatial_dimension, _not_ghost, _ek_not_defined);
   if (it == last)
     AKANTU_EXCEPTION(
         "The mesh contained in the file "
         << filename << " does not seem to be of the good dimension."
         << " No element of dimension " << spatial_dimension << " where read.");
 
   this->nb_global_nodes = this->nodes->size();
 
   this->computeBoundingBox();
 
   this->nodes_to_elements.resize(nodes->size());
   for (auto & node_set : nodes_to_elements) {
     node_set = std::make_unique<std::set<Element>>();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::write(const std::string & filename,
                  const MeshIOType & mesh_io_type) {
   MeshIO mesh_io;
   mesh_io.write(filename, *this, mesh_io_type);
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "Mesh [" << std::endl;
   stream << space << " + id                : " << getID() << std::endl;
   stream << space << " + spatial dimension : " << this->spatial_dimension
          << std::endl;
   stream << space << " + nodes [" << std::endl;
   nodes->printself(stream, indent + 2);
   stream << space << " + connectivities [" << std::endl;
   connectivities.printself(stream, indent + 2);
   stream << space << " ]" << std::endl;
 
   GroupManager::printself(stream, indent + 1);
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::computeBoundingBox() {
   AKANTU_DEBUG_IN();
   for (UInt k = 0; k < spatial_dimension; ++k) {
     local_lower_bounds(k) = std::numeric_limits<double>::max();
     local_upper_bounds(k) = -std::numeric_limits<double>::max();
   }
 
   for (UInt i = 0; i < nodes->size(); ++i) {
     //    if(!isPureGhostNode(i))
     for (UInt k = 0; k < spatial_dimension; ++k) {
       local_lower_bounds(k) = std::min(local_lower_bounds[k], (*nodes)(i, k));
       local_upper_bounds(k) = std::max(local_upper_bounds[k], (*nodes)(i, k));
     }
   }
 
   if (this->is_distributed) {
     Matrix<Real> reduce_bounds(spatial_dimension, 2);
     for (UInt k = 0; k < spatial_dimension; ++k) {
       reduce_bounds(k, 0) = local_lower_bounds(k);
       reduce_bounds(k, 1) = -local_upper_bounds(k);
     }
 
     communicator->allReduce(reduce_bounds, SynchronizerOperation::_min);
 
     for (UInt k = 0; k < spatial_dimension; ++k) {
       lower_bounds(k) = reduce_bounds(k, 0);
       upper_bounds(k) = -reduce_bounds(k, 1);
     }
   } else {
     this->lower_bounds = this->local_lower_bounds;
     this->upper_bounds = this->local_upper_bounds;
   }
 
   size = upper_bounds - lower_bounds;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::initNormals() {
   normals.initialize(*this, _nb_component = spatial_dimension,
                      _spatial_dimension = spatial_dimension,
                      _element_kind = _ek_not_defined);
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::getGlobalConnectivity(
     ElementTypeMapArray<UInt> & global_connectivity) {
   AKANTU_DEBUG_IN();
 
   for (auto && ghost_type : ghost_types) {
     for (auto type :
              global_connectivity.elementTypes(_spatial_dimension = _all_dimensions,
                                               _element_kind = _ek_not_defined,
                                               _ghost_type = ghost_type)) {
       if (not connectivities.exists(type, ghost_type))
         continue;
 
       auto & local_conn = connectivities(type, ghost_type);
       auto & g_connectivity = global_connectivity(type, ghost_type);
 
       UInt nb_nodes = local_conn.size() * local_conn.getNbComponent();
 
       if (not nodes_global_ids && is_mesh_facets) {
         std::transform(
             local_conn.begin_reinterpret(nb_nodes),
             local_conn.end_reinterpret(nb_nodes),
             g_connectivity.begin_reinterpret(nb_nodes),
             [& node_ids = *mesh_parent->nodes_global_ids](UInt l)->UInt {
               return node_ids(l);
             });
       } else {
         std::transform(local_conn.begin_reinterpret(nb_nodes),
                        local_conn.end_reinterpret(nb_nodes),
                        g_connectivity.begin_reinterpret(nb_nodes),
                        [& node_ids = *nodes_global_ids](UInt l)->UInt {
                          return node_ids(l);
                        });
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 DumperIOHelper & Mesh::getGroupDumper(const std::string & dumper_name,
                                       const std::string & group_name) {
   if (group_name == "all")
     return this->getDumper(dumper_name);
   else
     return element_groups[group_name]->getDumper(dumper_name);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 ElementTypeMap<UInt> Mesh::getNbDataPerElem(ElementTypeMapArray<T> & arrays,
                                             const ElementKind & element_kind) {
   ElementTypeMap<UInt> nb_data_per_elem;
 
   for (auto type : elementTypes(spatial_dimension, _not_ghost, element_kind)) {
     UInt nb_elements = this->getNbElement(type);
     auto & array = arrays(type);
 
     nb_data_per_elem(type) = array.getNbComponent() * array.size();
     nb_data_per_elem(type) /= nb_elements;
   }
 
   return nb_data_per_elem;
 }
 
 /* -------------------------------------------------------------------------- */
 template ElementTypeMap<UInt>
 Mesh::getNbDataPerElem(ElementTypeMapArray<Real> & array,
                        const ElementKind & element_kind);
 
 template ElementTypeMap<UInt>
 Mesh::getNbDataPerElem(ElementTypeMapArray<UInt> & array,
                        const ElementKind & element_kind);
 
 /* -------------------------------------------------------------------------- */
 #ifdef AKANTU_USE_IOHELPER
 template <typename T>
 dumper::Field *
 Mesh::createFieldFromAttachedData(const std::string & field_id,
                                   const std::string & group_name,
                                   const ElementKind & element_kind) {
 
   dumper::Field * field = nullptr;
   ElementTypeMapArray<T> * internal = nullptr;
   try {
     internal = &(this->getData<T>(field_id));
   } catch (...) {
     return nullptr;
   }
 
   ElementTypeMap<UInt> nb_data_per_elem =
       this->getNbDataPerElem(*internal, element_kind);
 
   field = this->createElementalField<T, dumper::InternalMaterialField>(
       *internal, group_name, this->spatial_dimension, element_kind,
       nb_data_per_elem);
 
   return field;
 }
 
 template dumper::Field *
 Mesh::createFieldFromAttachedData<Real>(const std::string & field_id,
                                         const std::string & group_name,
                                         const ElementKind & element_kind);
 
 template dumper::Field *
 Mesh::createFieldFromAttachedData<UInt>(const std::string & field_id,
                                         const std::string & group_name,
                                         const ElementKind & element_kind);
 #endif
 
 /* -------------------------------------------------------------------------- */
 void Mesh::distribute() {
   this->distribute(Communicator::getStaticCommunicator());
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::distribute(Communicator & communicator) {
   AKANTU_DEBUG_ASSERT(is_distributed == false,
                       "This mesh is already distribute");
   this->communicator = &communicator;
 
   this->element_synchronizer = std::make_unique<ElementSynchronizer>(
       *this, this->getID() + ":element_synchronizer", this->getMemoryID(),
       true);
 
   this->node_synchronizer = std::make_unique<NodeSynchronizer>(
       *this, this->getID() + ":node_synchronizer", this->getMemoryID(), true);
 
   Int psize = this->communicator->getNbProc();
 #ifdef AKANTU_USE_SCOTCH
   Int prank = this->communicator->whoAmI();
   if (prank == 0) {
     MeshPartitionScotch partition(*this, spatial_dimension);
     partition.partitionate(psize);
 
     MeshUtilsDistribution::distributeMeshCentralized(*this, 0, partition);
   } else {
     MeshUtilsDistribution::distributeMeshCentralized(*this, 0);
   }
 #else
   if (!(psize == 1)) {
-    AKANTU_DEBUG_ERROR("Cannot distribute a mesh without a partitioning tool");
+    AKANTU_ERROR("Cannot distribute a mesh without a partitioning tool");
   }
 #endif
 
   this->is_distributed = true;
   this->computeBoundingBox();
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::getAssociatedElements(const Array<UInt> & node_list,
                                  Array<Element> & elements) {
   for (const auto & node : node_list)
     for (const auto & element : *nodes_to_elements[node])
       elements.push_back(element);
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::fillNodesToElements() {
   Element e;
 
   UInt nb_nodes = nodes->size();
   for (UInt n = 0; n < nb_nodes; ++n) {
     if (this->nodes_to_elements[n])
       this->nodes_to_elements[n]->clear();
     else
       this->nodes_to_elements[n] = std::make_unique<std::set<Element>>();
   }
 
   for (auto ghost_type : ghost_types) {
     e.ghost_type = ghost_type;
     for (const auto & type :
          elementTypes(spatial_dimension, ghost_type, _ek_not_defined)) {
       e.type = type;
 
       UInt nb_element = this->getNbElement(type, ghost_type);
       Array<UInt>::const_iterator<Vector<UInt>> conn_it =
           connectivities(type, ghost_type)
               .begin(Mesh::getNbNodesPerElement(type));
 
       for (UInt el = 0; el < nb_element; ++el, ++conn_it) {
         e.element = el;
         const Vector<UInt> & conn = *conn_it;
         for (UInt n = 0; n < conn.size(); ++n)
           nodes_to_elements[conn(n)]->insert(e);
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::eraseElements(const Array<Element> & elements) {
   ElementTypeMap<UInt> last_element;
 
   RemovedElementsEvent event(*this);
   auto & remove_list = event.getList();
   auto & new_numbering = event.getNewNumbering();
 
   for (auto && el : elements) {
     if (el.ghost_type != _not_ghost) {
       auto & count = ghosts_counters(el);
       --count;
       if (count > 0)
         continue;
     }
 
     remove_list.push_back(el);
     if (not last_element.exists(el.type, el.ghost_type)) {
       UInt nb_element = mesh.getNbElement(el.type, el.ghost_type);
       last_element(nb_element - 1, el.type, el.ghost_type);
       auto & numbering =
           new_numbering.alloc(nb_element, 1, el.type, el.ghost_type);
       for (auto && pair : enumerate(numbering)) {
         std::get<1>(pair) = std::get<0>(pair);
       }
     }
 
     UInt & pos = last_element(el.type, el.ghost_type);
     auto & numbering = new_numbering(el.type, el.ghost_type);
 
     numbering(el.element) = UInt(-1);
     numbering(pos) = el.element;
     --pos;
   }
 
   this->sendEvent(event);
 }
 
 } // namespace akantu
diff --git a/src/mesh/mesh_data_tmpl.hh b/src/mesh/mesh_data_tmpl.hh
index 2ec591f4f..99c7103ca 100644
--- a/src/mesh/mesh_data_tmpl.hh
+++ b/src/mesh/mesh_data_tmpl.hh
@@ -1,276 +1,276 @@
 /**
  * @file   mesh_data_tmpl.hh
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri May 03 2013
  * @date last modification: Thu Nov 05 2015
  *
  * @brief  Stores generic data loaded from the mesh file
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 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 "mesh_data.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MESH_DATA_TMPL_HH__
 #define __AKANTU_MESH_DATA_TMPL_HH__
 
 namespace akantu {
 
 #define MESH_DATA_GET_TYPE(r, data, type)                                      \
   template <>                                                                  \
   inline MeshDataTypeCode                                                      \
   MeshData::getTypeCode<BOOST_PP_TUPLE_ELEM(2, 1, type)>() const {             \
     return BOOST_PP_TUPLE_ELEM(2, 0, type);                                    \
   }
 
 /* -------------------------------------------------------------------------- */
 // get the type of the data stored in elemental_data
 template <typename T> inline MeshDataTypeCode MeshData::getTypeCode() const {
-  AKANTU_DEBUG_ERROR("Type " << debug::demangle(typeid(T).name())
+  AKANTU_ERROR("Type " << debug::demangle(typeid(T).name())
                              << "not implemented by MeshData.");
 }
 
 /* -------------------------------------------------------------------------- */
 BOOST_PP_SEQ_FOR_EACH(MESH_DATA_GET_TYPE, void, AKANTU_MESH_DATA_TYPES)
 #undef MESH_DATA_GET_TYPE
 
 inline MeshDataTypeCode MeshData::getTypeCode(const ID & name) const {
   auto it = typecode_map.find(name);
   if (it == typecode_map.end())
     AKANTU_EXCEPTION("No dataset named " << name << " found.");
   return it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 //  Register new elemental data templated (and alloc data) with check if the
 //  name is new
 template <typename T> void MeshData::registerElementalData(const ID & name) {
   auto it = elemental_data.find(name);
   if (it == elemental_data.end()) {
     allocElementalData<T>(name);
   } else {
     AKANTU_DEBUG_INFO("Data named " << name << " already registered.");
   }
 }
 
 /* -------------------------------------------------------------------------- */
   //  Register new elemental data of a given MeshDataTypeCode with check if the
   //  name is new
 #define AKANTU_MESH_DATA_CASE_MACRO(r, name, elem)                             \
   case BOOST_PP_TUPLE_ELEM(2, 0, elem): {                                      \
     registerElementalData<BOOST_PP_TUPLE_ELEM(2, 1, elem)>(name);              \
     break;                                                                     \
   }
 
 inline void MeshData::registerElementalData(const ID & name,
                                             MeshDataTypeCode type) {
   switch (type) {
     BOOST_PP_SEQ_FOR_EACH(AKANTU_MESH_DATA_CASE_MACRO, name,
                           AKANTU_MESH_DATA_TYPES)
   default:
-    AKANTU_DEBUG_ERROR("Type " << type << "not implemented by MeshData.");
+    AKANTU_ERROR("Type " << type << "not implemented by MeshData.");
   }
 }
 #undef AKANTU_MESH_DATA_CASE_MACRO
 
 /* -------------------------------------------------------------------------- */
 /// Register new elemental data (and alloc data)
 template <typename T>
 ElementTypeMapArray<T> * MeshData::allocElementalData(const ID & name) {
   auto * dataset = new ElementTypeMapArray<T>(name, id, memory_id);
   elemental_data[name] = dataset;
   typecode_map[name] = getTypeCode<T>();
   return dataset;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 const ElementTypeMapArray<T> &
 MeshData::getElementalData(const ID & name) const {
   auto it = elemental_data.find(name);
   if (it == elemental_data.end())
     AKANTU_EXCEPTION("No dataset named " << name << " found.");
   return dynamic_cast<const ElementTypeMapArray<T> &>(*(it->second));
 }
 
 /* -------------------------------------------------------------------------- */
 // Get an existing elemental data
 template <typename T>
 ElementTypeMapArray<T> & MeshData::getElementalData(const ID & name) {
   auto it = elemental_data.find(name);
   if (it == elemental_data.end())
     AKANTU_EXCEPTION("No dataset named " << name << " found.");
   return dynamic_cast<ElementTypeMapArray<T> &>(*(it->second));
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 bool MeshData::hasDataArray(const ID & name, const ElementType & elem_type,
                             const GhostType & ghost_type) const {
   auto it = elemental_data.find(name);
   if (it == elemental_data.end())
     return false;
 
   auto & elem_map = dynamic_cast<const ElementTypeMapArray<T> &>(*(it->second));
   return elem_map.exists(elem_type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool MeshData::hasData(const ID & name) const {
   auto it = elemental_data.find(name);
   return (it != elemental_data.end());
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 const Array<T> &
 MeshData::getElementalDataArray(const ID & name, const ElementType & elem_type,
                                 const GhostType & ghost_type) const {
   auto it = elemental_data.find(name);
   if (it == elemental_data.end()) {
     AKANTU_EXCEPTION("Data named " << name
                                    << " not registered for type: " << elem_type
                                    << " - ghost_type:" << ghost_type << "!");
   }
   return dynamic_cast<const ElementTypeMapArray<T> &>(*(it->second))(
       elem_type, ghost_type);
 }
 
 template <typename T>
 Array<T> & MeshData::getElementalDataArray(const ID & name,
                                            const ElementType & elem_type,
                                            const GhostType & ghost_type) {
   auto it = elemental_data.find(name);
   if (it == elemental_data.end()) {
     AKANTU_EXCEPTION("Data named " << name
                                    << " not registered for type: " << elem_type
                                    << " - ghost_type:" << ghost_type << "!");
   }
   return dynamic_cast<ElementTypeMapArray<T> &>(*(it->second))(elem_type,
                                                                ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 // Get an elemental data array, if it does not exist: allocate it
 template <typename T>
 Array<T> & MeshData::getElementalDataArrayAlloc(const ID & name,
                                                 const ElementType & elem_type,
                                                 const GhostType & ghost_type,
                                                 UInt nb_component) {
   auto it = elemental_data.find(name);
   ElementTypeMapArray<T> * dataset;
   if (it == elemental_data.end()) {
     dataset = allocElementalData<T>(name);
   } else {
     dataset = dynamic_cast<ElementTypeMapArray<T> *>(it->second);
   }
   AKANTU_DEBUG_ASSERT(
       getTypeCode<T>() == typecode_map.find(name)->second,
       "Function getElementalDataArrayAlloc called with the wrong type!");
   if (!(dataset->exists(elem_type, ghost_type))) {
     dataset->alloc(0, nb_component, elem_type, ghost_type);
   }
   return (*dataset)(elem_type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 #define AKANTU_MESH_DATA_CASE_MACRO(r, name, elem)                             \
   case BOOST_PP_TUPLE_ELEM(2, 0, elem): {                                      \
     nb_comp = getNbComponentTemplated<BOOST_PP_TUPLE_ELEM(2, 1, elem)>(        \
         name, el_type, ghost_type);                                            \
     break;                                                                     \
   }
 
 inline UInt MeshData::getNbComponent(const ID & name,
                                      const ElementType & el_type,
                                      const GhostType & ghost_type) const {
   auto it = typecode_map.find(name);
   UInt nb_comp(0);
   if (it == typecode_map.end()) {
     AKANTU_EXCEPTION("Could not determine the type held in dataset "
                      << name << " for type: " << el_type
                      << " - ghost_type:" << ghost_type << ".");
   }
   MeshDataTypeCode type = it->second;
   switch (type) {
     BOOST_PP_SEQ_FOR_EACH(AKANTU_MESH_DATA_CASE_MACRO, name,
                           AKANTU_MESH_DATA_TYPES)
   default:
-    AKANTU_DEBUG_ERROR(
+    AKANTU_ERROR(
         "Could not call the correct instance of getNbComponentTemplated.");
     break;
   }
   return nb_comp;
 }
 #undef AKANTU_MESH_DATA_CASE_MACRO
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline UInt
 MeshData::getNbComponentTemplated(const ID & name, const ElementType & el_type,
                                   const GhostType & ghost_type) const {
   return getElementalDataArray<T>(name, el_type, ghost_type).getNbComponent();
 }
 
 /* -------------------------------------------------------------------------- */
 // get the names of the data stored in elemental_data
 #define AKANTU_MESH_DATA_CASE_MACRO(r, name, elem)                             \
   case BOOST_PP_TUPLE_ELEM(2, 0, elem): {                                      \
     ElementTypeMapArray<BOOST_PP_TUPLE_ELEM(2, 1, elem)> * dataset;            \
     dataset =                                                                  \
         dynamic_cast<ElementTypeMapArray<BOOST_PP_TUPLE_ELEM(2, 1, elem)> *>(  \
             it->second);                                                       \
     exists = dataset->exists(el_type, ghost_type);                             \
     break;                                                                     \
   }
 
 inline void MeshData::getTagNames(StringVector & tags,
                                   const ElementType & el_type,
                                   const GhostType & ghost_type) const {
   tags.clear();
   bool exists(false);
 
   auto it = elemental_data.begin();
   auto it_end = elemental_data.end();
   for (; it != it_end; ++it) {
     MeshDataTypeCode type = getTypeCode(it->first);
     switch (type) {
       BOOST_PP_SEQ_FOR_EACH(AKANTU_MESH_DATA_CASE_MACRO, ,
                             AKANTU_MESH_DATA_TYPES)
     default:
-      AKANTU_DEBUG_ERROR(
+      AKANTU_ERROR(
           "Could not determine the proper type to (dynamic-)cast.");
       break;
     }
     if (exists) {
       tags.push_back(it->first);
     }
   }
 }
 #undef AKANTU_MESH_DATA_CASE_MACRO
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
 
 #endif /* __AKANTU_MESH_DATA_TMPL_HH__ */
diff --git a/src/mesh/mesh_events.hh b/src/mesh/mesh_events.hh
index 471d63709..684de1e56 100644
--- a/src/mesh/mesh_events.hh
+++ b/src/mesh/mesh_events.hh
@@ -1,199 +1,199 @@
 /**
  * @file   mesh_events.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Feb 20 2015
  * @date last modification: Mon Dec 07 2015
  *
  * @brief  Classes corresponding to mesh events type
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 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 <utility>
 
 #include "aka_array.hh"
 #include "element.hh"
 #include "element_type_map.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MESH_EVENTS_HH__
 #define __AKANTU_MESH_EVENTS_HH__
 
 
 namespace akantu {
 
 /// akantu::MeshEvent is the base event for meshes
 template <class Entity> class MeshEvent {
 public:
   virtual ~MeshEvent() = default;
   /// Get the list of entity modified by the event nodes or elements
   const Array<Entity> & getList() const { return list; }
   /// Get the list of entity modified by the event nodes or elements
   Array<Entity> & getList() { return list; }
 
 protected:
   Array<Entity> list;
 };
 
 class Mesh;
 
 /// akantu::MeshEvent related to new nodes in the mesh
 class NewNodesEvent : public MeshEvent<UInt> {
 public:
   ~NewNodesEvent() override = default;
 };
 
 /// akantu::MeshEvent related to nodes removed from the mesh
 class RemovedNodesEvent : public MeshEvent<UInt> {
 public:
   ~RemovedNodesEvent() override = default;
   inline RemovedNodesEvent(const Mesh & mesh);
   /// Get the new numbering following suppression of nodes from nodes arrays
   AKANTU_GET_MACRO_NOT_CONST(NewNumbering, new_numbering, Array<UInt> &);
   /// Get the new numbering following suppression of nodes from nodes arrays
   AKANTU_GET_MACRO(NewNumbering, new_numbering, const Array<UInt> &);
 
 private:
   Array<UInt> new_numbering;
 };
 
 /// akantu::MeshEvent related to new elements in the mesh
 class NewElementsEvent : public MeshEvent<Element> {
 public:
   ~NewElementsEvent() override = default;
 };
 
 /// akantu::MeshEvent related to elements removed from the mesh
 class RemovedElementsEvent : public MeshEvent<Element> {
 public:
   ~RemovedElementsEvent() override = default;
   inline RemovedElementsEvent(const Mesh & mesh,
                               const ID & new_numbering_id = "new_numbering");
   /// Get the new numbering following suppression of elements from elements
   /// arrays
   AKANTU_GET_MACRO(NewNumbering, new_numbering,
                    const ElementTypeMapArray<UInt> &);
   /// Get the new numbering following suppression of elements from elements
   /// arrays
   AKANTU_GET_MACRO_NOT_CONST(NewNumbering, new_numbering,
                              ElementTypeMapArray<UInt> &);
   /// Get the new numbering following suppression of elements from elements
   /// arrays
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(NewNumbering, new_numbering, UInt);
   /// Get the new numbering following suppression of elements from elements
   /// arrays
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(NewNumbering, new_numbering, UInt);
 
 protected:
   ElementTypeMapArray<UInt> new_numbering;
 };
 
 /// akantu::MeshEvent for element that changed in some sort, can be seen as a
 /// combination of removed and added elements
 class ChangedElementsEvent : public RemovedElementsEvent {
 public:
   ~ChangedElementsEvent() override = default;
   inline ChangedElementsEvent(
       const Mesh & mesh, ID new_numbering_id = "changed_event:new_numbering")
       : RemovedElementsEvent(mesh, std::move(new_numbering_id)){};
   AKANTU_GET_MACRO(ListOld, list, const Array<Element> &);
   AKANTU_GET_MACRO_NOT_CONST(ListOld, list, Array<Element> &);
   AKANTU_GET_MACRO(ListNew, new_list, const Array<Element> &);
   AKANTU_GET_MACRO_NOT_CONST(ListNew, new_list, Array<Element> &);
 
 protected:
   Array<Element> new_list;
 };
 
 /* -------------------------------------------------------------------------- */
 
 class MeshEventHandler {
 public:
   virtual ~MeshEventHandler() = default;
   /* ------------------------------------------------------------------------ */
   /* Internal code                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// send a akantu::NewNodesEvent
   inline void sendEvent(const NewNodesEvent & event) {
     onNodesAdded(event.getList(), event);
   }
   /// send a akantu::RemovedNodesEvent
   inline void sendEvent(const RemovedNodesEvent & event) {
     onNodesRemoved(event.getList(), event.getNewNumbering(), event);
   }
   /// send a akantu::NewElementsEvent
   inline void sendEvent(const NewElementsEvent & event) {
     onElementsAdded(event.getList(), event);
   }
   /// send a akantu::RemovedElementsEvent
   inline void sendEvent(const RemovedElementsEvent & event) {
     onElementsRemoved(event.getList(), event.getNewNumbering(), event);
   }
   /// send a akantu::ChangedElementsEvent
   inline void sendEvent(const ChangedElementsEvent & event) {
     onElementsChanged(event.getListOld(), event.getListNew(),
                       event.getNewNumbering(), event);
   }
   template <class EventHandler> friend class EventHandlerManager;
 
   /* ------------------------------------------------------------------------ */
   /* Interface                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// function to implement to react on  akantu::NewNodesEvent
   virtual void onNodesAdded(const Array<UInt> & /*nodes_list*/,
                             const NewNodesEvent & /*event*/) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
   /// function to implement to react on  akantu::RemovedNodesEvent
   virtual void onNodesRemoved(const Array<UInt> & /*nodes_list*/,
                               const Array<UInt> & /*new_numbering*/,
                               const RemovedNodesEvent & /*event*/) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
   /// function to implement to react on  akantu::NewElementsEvent
   virtual void onElementsAdded(const Array<Element> & /*elements_list*/,
                                const NewElementsEvent & /*event*/) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
   /// function to implement to react on  akantu::RemovedElementsEvent
   virtual void
   onElementsRemoved(const Array<Element> & /*elements_list*/,
                     const ElementTypeMapArray<UInt> & /*new_numbering*/,
                     const RemovedElementsEvent & /*event*/) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
   /// function to implement to react on  akantu::ChangedElementsEvent
   virtual void
   onElementsChanged(const Array<Element> & /*old_elements_list*/,
                     const Array<Element> & /*new_elements_list*/,
                     const ElementTypeMapArray<UInt> & /*new_numbering*/,
                     const ChangedElementsEvent & /*event*/) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 };
 
 } // akantu
 
 #endif /* __AKANTU_MESH_EVENTS_HH__ */
diff --git a/src/mesh/mesh_filter.hh b/src/mesh/mesh_filter.hh
index 9b812fbe4..213325536 100644
--- a/src/mesh/mesh_filter.hh
+++ b/src/mesh/mesh_filter.hh
@@ -1,75 +1,75 @@
 /**
  * @file   mesh_filter.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri Dec 18 2015
  *
  * @brief  the class representing the meshes
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __AKANTU_MESH_FILTER_HH__
 #define __AKANTU_MESH_FILTER_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "element.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* Filter Functors                                                            */
 /* -------------------------------------------------------------------------- */
 
 /// struct for the possible filter functors
 struct FilterFunctor {
   enum Type { _node_filter_functor, _element_filter_functor };
 };
 
 /// class (functor) for the node filter
 class NodeFilterFunctor : public FilterFunctor {
 public:
   bool operator()(__attribute__((unused)) UInt node) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
 public:
   static const Type type = _node_filter_functor;
 };
 
 /// class (functor) for the element filter
 class ElementFilterFunctor : public FilterFunctor {
 public:
   bool operator()(__attribute__((unused)) const Element & element) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
 public:
   static const Type type = _element_filter_functor;
 };
 
 } // akantu
 
 #endif /* __AKANTU_MESH_FILTER_HH__ */
diff --git a/src/mesh_utils/mesh_partition/mesh_partition_mesh_data.cc b/src/mesh_utils/mesh_partition/mesh_partition_mesh_data.cc
index b54222c4d..6e87f6869 100644
--- a/src/mesh_utils/mesh_partition/mesh_partition_mesh_data.cc
+++ b/src/mesh_utils/mesh_partition/mesh_partition_mesh_data.cc
@@ -1,141 +1,141 @@
 /**
  * @file   mesh_partition_mesh_data.cc
  *
  * @author Dana Christen <dana.christen@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri May 03 2013
  * @date last modification: Wed Nov 11 2015
  *
  * @brief  implementation of the MeshPartitionMeshData class
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 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 "mesh_partition_mesh_data.hh"
 #if !defined(AKANTU_NDEBUG)
 #include <set>
 #endif
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 MeshPartitionMeshData::MeshPartitionMeshData(const Mesh & mesh,
                                              UInt spatial_dimension,
                                              const ID & id,
                                              const MemoryID & memory_id)
     : MeshPartition(mesh, spatial_dimension, id, memory_id) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 MeshPartitionMeshData::MeshPartitionMeshData(
     const Mesh & mesh, const ElementTypeMapArray<UInt> & mapping,
     UInt spatial_dimension, const ID & id, const MemoryID & memory_id)
     : MeshPartition(mesh, spatial_dimension, id, memory_id),
       partition_mapping(&mapping) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshPartitionMeshData::partitionate(UInt nb_part,
                                          __attribute__((unused))
                                          const EdgeLoadFunctor & edge_load_func,
                                          const Array<UInt> & pairs) {
   AKANTU_DEBUG_IN();
 
   tweakConnectivity(pairs);
 
   nb_partitions = nb_part;
   GhostType ghost_type = _not_ghost;
   UInt spatial_dimension = mesh.getSpatialDimension();
   Mesh::type_iterator it =
       mesh.firstType(spatial_dimension, ghost_type, _ek_not_defined);
   Mesh::type_iterator end =
       mesh.lastType(spatial_dimension, ghost_type, _ek_not_defined);
 
   UInt linearized_el = 0;
   UInt nb_elements = mesh.getNbElement(mesh.getSpatialDimension(), ghost_type);
   auto * partition_list = new Int[nb_elements];
 
 #if !defined(AKANTU_NDEBUG)
   std::set<UInt> partitions;
 #endif
   for (; it != end; ++it) {
     ElementType type = *it;
     const Array<UInt> & partition_array =
         (*partition_mapping)(type, ghost_type);
     Array<UInt>::const_iterator<Vector<UInt> > p_it = partition_array.begin(1);
     Array<UInt>::const_iterator<Vector<UInt> > p_end = partition_array.end(1);
     AKANTU_DEBUG_ASSERT(UInt(p_end - p_it) ==
                             mesh.getNbElement(type, ghost_type),
                         "The partition mapping does not have the right number "
                             << "of entries for type " << type
                             << " and ghost type " << ghost_type << "."
                             << " Tags=" << p_end - p_it
                             << " Mesh=" << mesh.getNbElement(type, ghost_type));
     for (; p_it != p_end; ++p_it, ++linearized_el) {
       partition_list[linearized_el] = (*p_it)(0);
 #if !defined(AKANTU_NDEBUG)
       partitions.insert((*p_it)(0));
 #endif
     }
   }
 
 #if !defined(AKANTU_NDEBUG)
   AKANTU_DEBUG_ASSERT(partitions.size() == nb_part,
                       "The number of real partitions does not match with the "
                       "number of asked partitions");
 #endif
 
   fillPartitionInformation(mesh, partition_list);
 
   delete[] partition_list;
 
   restoreConnectivity();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
-void MeshPartitionMeshData::reorder() { AKANTU_DEBUG_TO_IMPLEMENT(); }
+void MeshPartitionMeshData::reorder() { AKANTU_TO_IMPLEMENT(); }
 
 /* -------------------------------------------------------------------------- */
 void MeshPartitionMeshData::setPartitionMapping(
     const ElementTypeMapArray<UInt> & mapping) {
   partition_mapping = &mapping;
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshPartitionMeshData::setPartitionMappingFromMeshData(
     const std::string & data_name) {
   partition_mapping = &(mesh.getData<UInt>(data_name));
 }
 
 } // akantu
diff --git a/src/model/boundary_condition_functor.hh b/src/model/boundary_condition_functor.hh
index 743bd322d..84cc245e3 100644
--- a/src/model/boundary_condition_functor.hh
+++ b/src/model/boundary_condition_functor.hh
@@ -1,217 +1,217 @@
 /**
  * @file   boundary_condition_functor.hh
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri May 03 2013
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Definitions of the functors to apply boundary conditions
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 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 "aka_common.hh"
 #include "fe_engine.hh"
 #include "integration_point.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_BOUNDARY_CONDITION_FUNCTOR_HH__
 #define __AKANTU_BOUNDARY_CONDITION_FUNCTOR_HH__
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 namespace BC {
   using Axis = ::akantu::SpacialDirection;
 
   struct Functor {
     enum Type { _dirichlet, _neumann };
   };
 
   /* ------------------------------------------------------------------------ */
   /* Dirichlet                                                                */
   /* ------------------------------------------------------------------------ */
   namespace Dirichlet {
     /* ---------------------------------------------------------------------- */
     class DirichletFunctor : public Functor {
     protected:
       DirichletFunctor() = default;
       explicit DirichletFunctor(Axis ax) : axis(ax) {}
 
     public:
       void operator()(__attribute__((unused)) UInt node,
                       __attribute__((unused)) Vector<bool> & flags,
                       __attribute__((unused)) Vector<Real> & primal,
                       __attribute__((unused))
                       const Vector<Real> & coord) const {
-        AKANTU_DEBUG_TO_IMPLEMENT();
+        AKANTU_TO_IMPLEMENT();
       }
 
     public:
       static const Type type = _dirichlet;
 
     protected:
       Axis axis{_x};
     };
 
     /* ---------------------------------------------------------------------- */
     class FlagOnly : public DirichletFunctor {
     public:
       explicit FlagOnly(Axis ax = _x) : DirichletFunctor(ax) {}
 
     public:
       inline void operator()(UInt node, Vector<bool> & flags,
                              Vector<Real> & primal,
                              const Vector<Real> & coord) const;
     };
 
     /* ---------------------------------------------------------------------- */
     class FreeBoundary : public DirichletFunctor {
     public:
       explicit FreeBoundary(Axis ax = _x) : DirichletFunctor(ax) {}
 
     public:
       inline void operator()(UInt node, Vector<bool> & flags,
                              Vector<Real> & primal,
                              const Vector<Real> & coord) const;
     };
 
     /* ---------------------------------------------------------------------- */
     class FixedValue : public DirichletFunctor {
     public:
       FixedValue(Real val, Axis ax = _x) : DirichletFunctor(ax), value(val) {}
 
     public:
       inline void operator()(UInt node, Vector<bool> & flags,
                              Vector<Real> & primal,
                              const Vector<Real> & coord) const;
 
     protected:
       Real value;
     };
 
     /* ---------------------------------------------------------------------- */
     class IncrementValue : public DirichletFunctor {
     public:
       IncrementValue(Real val, Axis ax = _x)
           : DirichletFunctor(ax), value(val) {}
 
     public:
       inline void operator()(UInt node, Vector<bool> & flags,
                              Vector<Real> & primal,
                              const Vector<Real> & coord) const;
 
       inline void setIncrement(Real val) { this->value = val; }
 
     protected:
       Real value;
     };
 
     /* ---------------------------------------------------------------------- */
     class Increment : public DirichletFunctor {
     public:
       explicit Increment(const Vector<Real> & val)
           : DirichletFunctor(_x), value(val) {}
 
     public:
       inline void operator()(UInt node, Vector<bool> & flags,
                              Vector<Real> & primal,
                              const Vector<Real> & coord) const;
 
       inline void setIncrement(const Vector<Real> & val) { this->value = val; }
 
     protected:
       Vector<Real> value;
     };
 
   } // end namespace Dirichlet
 
   /* ------------------------------------------------------------------------ */
   /* Neumann                                                                  */
   /* ------------------------------------------------------------------------ */
   namespace Neumann {
     /* ---------------------------------------------------------------------- */
     class NeumannFunctor : public Functor {
 
     protected:
       NeumannFunctor() = default;
 
     public:
       virtual void operator()(const IntegrationPoint & quad_point,
                               Vector<Real> & dual, const Vector<Real> & coord,
                               const Vector<Real> & normals) const = 0;
 
       virtual ~NeumannFunctor() = default;
 
     public:
       static const Type type = _neumann;
     };
 
     /* ---------------------------------------------------------------------- */
     class FromHigherDim : public NeumannFunctor {
     public:
       explicit FromHigherDim(const Matrix<Real> & mat) : bc_data(mat) {}
       ~FromHigherDim() override = default;
 
     public:
       inline void operator()(const IntegrationPoint & quad_point,
                              Vector<Real> & dual, const Vector<Real> & coord,
                              const Vector<Real> & normals) const override;
 
     protected:
       Matrix<Real> bc_data;
     };
 
     /* ---------------------------------------------------------------------- */
     class FromSameDim : public NeumannFunctor {
     public:
       explicit FromSameDim(const Vector<Real> & vec) : bc_data(vec) {}
       ~FromSameDim() override = default;
 
     public:
       inline void operator()(const IntegrationPoint & quad_point,
                              Vector<Real> & dual, const Vector<Real> & coord,
                              const Vector<Real> & normals) const override;
 
     protected:
       Vector<Real> bc_data;
     };
 
     /* ---------------------------------------------------------------------- */
     class FreeBoundary : public NeumannFunctor {
     public:
       inline void operator()(const IntegrationPoint & quad_point,
                              Vector<Real> & dual, const Vector<Real> & coord,
                              const Vector<Real> & normals) const override;
     };
   } // end namespace Neumann
 } // end namespace BC
 
 } // akantu
 
 #include "boundary_condition_functor_inline_impl.cc"
 
 #endif /* __AKANTU_BOUNDARY_CONDITION_FUNCTOR_HH__ */
diff --git a/src/model/boundary_condition_tmpl.hh b/src/model/boundary_condition_tmpl.hh
index 08c3e5fd6..db3c01212 100644
--- a/src/model/boundary_condition_tmpl.hh
+++ b/src/model/boundary_condition_tmpl.hh
@@ -1,255 +1,255 @@
 /**
  * @file   boundary_condition_tmpl.hh
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri May 03 2013
  * @date last modification: Fri Oct 16 2015
  *
  * @brief  implementation of the applyBC
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 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 "element_group.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_BOUNDARY_CONDITION_TMPL_HH__
 #define __AKANTU_BOUNDARY_CONDITION_TMPL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 void BoundaryCondition<ModelType>::initBC(ModelType & model,
                                           Array<Real> & primal,
                                           Array<Real> & dual) {
   this->model = &model;
   this->primal = &primal;
   this->dual = &dual;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 void BoundaryCondition<ModelType>::initBC(ModelType & model,
                                           Array<Real> & primal,
                                           Array<Real> & primal_increment,
                                           Array<Real> & dual) {
   this->initBC(model, primal, dual);
   this->primal_increment = &primal_increment;
 }
 
 /* -------------------------------------------------------------------------- */
 /* Partial specialization for DIRICHLET functors */
 template <typename ModelType>
 template <typename FunctorType>
 struct BoundaryCondition<ModelType>::TemplateFunctionWrapper<
     FunctorType, BC::Functor::_dirichlet> {
   static inline void applyBC(const FunctorType & func,
                              const ElementGroup & group,
                              BoundaryCondition<ModelType> & bc_instance) {
     auto & model = bc_instance.getModel();
     auto & primal = bc_instance.getPrimal();
 
     const auto & coords = model.getMesh().getNodes();
     auto & boundary_flags = model.getBlockedDOFs();
     UInt dim = model.getMesh().getSpatialDimension();
 
     auto primal_iter = primal.begin(primal.getNbComponent());
     auto coords_iter = coords.begin(dim);
     auto flags_iter = boundary_flags.begin(boundary_flags.getNbComponent());
 
     for (auto n : group.getNodeGroup()) {
       Vector<bool> flag(flags_iter[n]);
       Vector<Real> primal(primal_iter[n]);
       Vector<Real> coords(coords_iter[n]);
       func(n, flag, primal, coords);
     }
   }
 };
 
 /* -------------------------------------------------------------------------- */
 /* Partial specialization for NEUMANN functors */
 template <typename ModelType>
 template <typename FunctorType>
 struct BoundaryCondition<ModelType>::TemplateFunctionWrapper<
     FunctorType, BC::Functor::_neumann> {
   static inline void applyBC(const FunctorType & func,
                              const ElementGroup & group,
                              BoundaryCondition<ModelType> & bc_instance) {
     UInt dim = bc_instance.getModel().getSpatialDimension();
     switch (dim) {
     case 1: {
-      AKANTU_DEBUG_TO_IMPLEMENT();
+      AKANTU_TO_IMPLEMENT();
       break;
     }
     case 2:
     case 3: {
       applyBC(func, group, bc_instance, _not_ghost);
       applyBC(func, group, bc_instance, _ghost);
       break;
     }
     }
   }
 
   static inline void applyBC(const FunctorType & func,
                              const ElementGroup & group,
                              BoundaryCondition<ModelType> & bc_instance,
                              GhostType ghost_type) {
     auto & model = bc_instance.getModel();
     auto & dual = bc_instance.getDual();
     const auto & mesh = model.getMesh();
     const auto & nodes_coords = mesh.getNodes();
     const auto & fem_boundary = model.getFEEngineBoundary();
 
     UInt dim = model.getSpatialDimension();
     UInt nb_degree_of_freedom = dual.getNbComponent();
 
     IntegrationPoint quad_point;
     quad_point.ghost_type = ghost_type;
 
     // Loop over the boundary element types
     for (auto && type : group.elementTypes(dim - 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 = new Array<Real>(
           nb_elements * nb_quad_points, nb_degree_of_freedom, 0.);
       Array<Real> * quad_coords =
           new Array<Real>(nb_elements * nb_quad_points, dim);
 
       const auto & normals_on_quad =
           fem_boundary.getNormalsOnIntegrationPoints(type, ghost_type);
 
       fem_boundary.interpolateOnIntegrationPoints(
           nodes_coords, *quad_coords, dim, type, ghost_type, element_ids);
       auto normals_begin = normals_on_quad.begin(dim);
       decltype(normals_begin) normals_iter;
       auto quad_coords_iter = quad_coords->begin(dim);
       auto dual_iter = dual_before_integ->begin(nb_degree_of_freedom);
 
       quad_point.type = type;
       for (auto el : element_ids) {
         quad_point.element = el;
         normals_iter = normals_begin + el * nb_quad_points;
         for (auto && q : arange(nb_quad_points)) {
           quad_point.num_point = q;
           func(quad_point, *dual_iter, *quad_coords_iter, *normals_iter);
           ++dual_iter;
           ++quad_coords_iter;
           ++normals_iter;
         }
       }
 
       delete quad_coords;
 
       /* -------------------------------------------------------------------- */
       // Initialization of iterators
       auto dual_iter_mat = dual_before_integ->begin(nb_degree_of_freedom, 1);
       auto shapes_iter_begin = fem_boundary.getShapes(type, ghost_type)
                                    .begin(1, nb_nodes_per_element);
 
       Array<Real> * dual_by_shapes =
           new Array<Real>(nb_elements * nb_quad_points,
                           nb_degree_of_freedom * nb_nodes_per_element);
 
       auto dual_by_shapes_iter =
           dual_by_shapes->begin(nb_degree_of_freedom, nb_nodes_per_element);
 
       /* -------------------------------------------------------------------- */
       // Loop computing dual x shapes
       for (auto el : element_ids) {
         auto shapes_iter = shapes_iter_begin + el * nb_quad_points;
 
         for (UInt q(0); q < nb_quad_points;
              ++q, ++dual_iter_mat, ++dual_by_shapes_iter, ++shapes_iter) {
           dual_by_shapes_iter->template mul<false, false>(*dual_iter_mat, *shapes_iter);
         }
       }
 
       delete dual_before_integ;
 
       Array<Real> * dual_by_shapes_integ = new Array<Real>(
           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);
       delete dual_by_shapes;
 
       // assemble the result into force vector
       model.getDOFManager().assembleElementalArrayLocalArray(
           *dual_by_shapes_integ, dual, type, ghost_type, 1., element_ids);
       delete dual_by_shapes_integ;
     }
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 template <typename FunctorType>
 inline void BoundaryCondition<ModelType>::applyBC(const FunctorType & func) {
   auto bit = model->getMesh().getGroupManager().element_group_begin();
   auto bend = model->getMesh().getGroupManager().element_group_end();
   for (; bit != bend; ++bit)
     applyBC(func, *bit);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 template <typename FunctorType>
 inline void
 BoundaryCondition<ModelType>::applyBC(const FunctorType & func,
                                       const std::string & group_name) {
   try {
     const ElementGroup & element_group =
         model->getMesh().getElementGroup(group_name);
     applyBC(func, element_group);
   } catch (akantu::debug::Exception e) {
     AKANTU_EXCEPTION("Error applying a boundary condition onto \""
                      << group_name << "\"! [" << e.what() << "]");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 template <typename FunctorType>
 inline void
 BoundaryCondition<ModelType>::applyBC(const FunctorType & func,
                                       const ElementGroup & element_group) {
 #if !defined(AKANTU_NDEBUG)
   if (element_group.getDimension() != model->getSpatialDimension() - 1)
     AKANTU_DEBUG_WARNING("The group "
                          << element_group.getName()
                          << " does not contain only boundaries elements");
 #endif
 
   TemplateFunctionWrapper<FunctorType>::applyBC(func, element_group, *this);
 }
 
 #endif /* __AKANTU_BOUNDARY_CONDITION_TMPL_HH__ */
 
 } // namespace akantu
diff --git a/src/model/common/non_local_toolbox/non_local_neighborhood_base.hh b/src/model/common/non_local_toolbox/non_local_neighborhood_base.hh
index 547766016..467869e69 100644
--- a/src/model/common/non_local_toolbox/non_local_neighborhood_base.hh
+++ b/src/model/common/non_local_toolbox/non_local_neighborhood_base.hh
@@ -1,130 +1,130 @@
 /**
  * @file   non_local_neighborhood_base.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sat Sep 26 2015
  * @date last modification: Wed Nov 25 2015
  *
  * @brief  Non-local neighborhood base class
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 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 "neighborhood_base.hh"
 #include "parsable.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_NON_LOCAL_NEIGHBORHOOD_BASE_HH__
 #define __AKANTU_NON_LOCAL_NEIGHBORHOOD_BASE_HH__
 
 namespace akantu {
 class Model;
 }
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
 class NonLocalNeighborhoodBase : public NeighborhoodBase, public Parsable {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   NonLocalNeighborhoodBase(Model & model,
                            const ElementTypeMapReal & quad_coordinates,
                            const ID & id = "non_local_neighborhood",
                            const MemoryID & memory_id = 0);
   ~NonLocalNeighborhoodBase() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// create grid synchronizer and exchange ghost cells
   void createGridSynchronizer() override;
 
   void synchronize(DataAccessor<Element> & data_accessor,
                    const SynchronizationTag & tag) override;
 
   /// compute weights, for instance needed for non-local damage computation
   virtual void computeWeights(){};
 
   // compute the non-local counter part for a given element type map
   virtual void
   weightedAverageOnNeighbours(const ElementTypeMapReal & to_accumulate,
                               ElementTypeMapReal & accumulated,
                               UInt nb_degree_of_freedom,
                               const GhostType & ghost_type2) const = 0;
 
   /// update the weights for the non-local averaging
   virtual void updateWeights() = 0;
 
   /// update the weights for the non-local averaging
   virtual void saveWeights(const std::string &) const {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// register a new non-local variable in the neighborhood
   virtual void registerNonLocalVariable(const ID & id);
 
   /// clean up the unneccessary ghosts
   void cleanupExtraGhostElements(std::set<Element> & relevant_ghost_elements);
 
 protected:
   /// create the grid
   void createGrid();
 
   /* --------------------------------------------------------------------------
    */
   /* DataAccessor inherited members */
   /* --------------------------------------------------------------------------
    */
 public:
   inline UInt getNbData(const Array<Element> &,
                         const SynchronizationTag &) const override {
     return 0;
   }
 
   inline void packData(CommunicationBuffer &, const Array<Element> &,
                        const SynchronizationTag &) const override {}
 
   inline void unpackData(CommunicationBuffer &, const Array<Element> &,
                          const SynchronizationTag &) override {}
 
   /* --------------------------------------------------------------------------
    */
   /* Accessors */
   /* --------------------------------------------------------------------------
    */
 public:
   AKANTU_GET_MACRO(NonLocalVariables, non_local_variables,
                    const std::set<ID> &);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// list of non-local variables associated to the neighborhood
   std::set<ID> non_local_variables;
 };
 
 } // namespace akantu
 
 #endif /* __AKANTU_NON_LOCAL_NEIGHBORHOOD_BASE_HH__ */
diff --git a/src/model/dof_manager.cc b/src/model/dof_manager.cc
index 6e28f5d79..7b574f25a 100644
--- a/src/model/dof_manager.cc
+++ b/src/model/dof_manager.cc
@@ -1,592 +1,592 @@
 /**
  * @file   dof_manager.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Aug 12 09:52:30 2015
  *
  * @brief  Implementation of the common parts of the DOFManagers
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 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 "dof_manager.hh"
 #include "element_group.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 #include "node_group.hh"
 #include "non_linear_solver.hh"
 #include "sparse_matrix.hh"
 #include "communicator.hh"
 #include "time_step_solver.hh"
 /* -------------------------------------------------------------------------- */
 #include <memory>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFManager(const ID & id, const MemoryID & memory_id)
     : Memory(id, memory_id),
       communicator(Communicator::getStaticCommunicator()) {}
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFManager(Mesh & mesh, const ID & id, const MemoryID & memory_id)
     : Memory(id, memory_id), mesh(&mesh), local_system_size(0),
       pure_local_system_size(0), system_size(0),
       communicator(mesh.getCommunicator()) {
   this->mesh->registerEventHandler(*this, _ehp_dof_manager);
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManager::~DOFManager() = default;
 
 /* -------------------------------------------------------------------------- */
 // void DOFManager::getEquationsNumbers(const ID &, Array<UInt> &) {
-//   AKANTU_DEBUG_TO_IMPLEMENT();
+//   AKANTU_TO_IMPLEMENT();
 // }
 
 /* -------------------------------------------------------------------------- */
 std::vector<ID> DOFManager::getDOFIDs() const {
   std::vector<ID> keys;
   for (const auto & dof_data : this->dofs)
     keys.push_back(dof_data.first);
 
   return keys;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::assembleElementalArrayLocalArray(
     const Array<Real> & elementary_vect, Array<Real> & array_assembeled,
     const ElementType & type, const GhostType & ghost_type, Real scale_factor,
     const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   UInt nb_element;
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_degree_of_freedom =
       elementary_vect.getNbComponent() / nb_nodes_per_element;
 
   UInt * filter_it = nullptr;
   if (filter_elements != empty_filter) {
     nb_element = filter_elements.size();
     filter_it = filter_elements.storage();
   } else {
     nb_element = this->mesh->getNbElement(type, ghost_type);
   }
 
   AKANTU_DEBUG_ASSERT(elementary_vect.size() == nb_element,
                       "The vector elementary_vect("
                           << elementary_vect.getID()
                           << ") has not the good size.");
 
   const Array<UInt> & connectivity =
       this->mesh->getConnectivity(type, ghost_type);
   // Array<UInt>::const_vector_iterator conn_begin =
   //     connectivity.begin(nb_nodes_per_element);
   // Array<UInt>::const_vector_iterator conn_it = conn_begin;
 
   Array<Real>::const_matrix_iterator elem_it =
       elementary_vect.begin(nb_degree_of_freedom, nb_nodes_per_element);
 
   for (UInt el = 0; el < nb_element; ++el, ++elem_it) {
     UInt element = el;
     if (filter_it != nullptr) {
       // conn_it = conn_begin + *filter_it;
       element = *filter_it;
     }
 
     // const Vector<UInt> & conn = *conn_it;
     const Matrix<Real> & elemental_val = *elem_it;
     for (UInt n = 0; n < nb_nodes_per_element; ++n) {
       UInt offset_node = connectivity(element, n) * nb_degree_of_freedom;
       Vector<Real> assemble(array_assembeled.storage() + offset_node,
                             nb_degree_of_freedom);
       Vector<Real> elem_val = elemental_val(n);
       assemble.aXplusY(elem_val, scale_factor);
     }
 
     if (filter_it != nullptr)
       ++filter_it;
     //    else
     //      ++conn_it;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::assembleElementalArrayToResidual(
     const ID & dof_id, const Array<Real> & elementary_vect,
     const ElementType & type, const GhostType & ghost_type, Real scale_factor,
     const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_degree_of_freedom =
       elementary_vect.getNbComponent() / nb_nodes_per_element;
   Array<Real> array_localy_assembeled(this->mesh->getNbNodes(),
                                       nb_degree_of_freedom);
 
   array_localy_assembeled.clear();
 
   this->assembleElementalArrayLocalArray(
       elementary_vect, array_localy_assembeled, type, ghost_type, scale_factor,
       filter_elements);
 
   this->assembleToResidual(dof_id, array_localy_assembeled, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::assembleElementalArrayToLumpedMatrix(
     const ID & dof_id, const Array<Real> & elementary_vect,
     const ID & lumped_mtx, const ElementType & type,
     const GhostType & ghost_type, Real scale_factor,
     const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_degree_of_freedom =
       elementary_vect.getNbComponent() / nb_nodes_per_element;
   Array<Real> array_localy_assembeled(this->mesh->getNbNodes(),
                                       nb_degree_of_freedom);
 
   array_localy_assembeled.clear();
 
   this->assembleElementalArrayLocalArray(
       elementary_vect, array_localy_assembeled, type, ghost_type, scale_factor,
       filter_elements);
 
   this->assembleToLumpedMatrix(dof_id, array_localy_assembeled, lumped_mtx, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFData::DOFData(const ID & dof_id)
     : support_type(_dst_generic), group_support("__mesh__"), dof(nullptr),
       blocked_dofs(nullptr), increment(nullptr), previous(nullptr),
       solution(0, 1, dof_id + ":solution"),
       local_equation_number(0, 1, dof_id + ":local_equation_number") {}
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFData::~DOFData() = default;
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFData & DOFManager::getNewDOFData(const ID & dof_id) {
   auto it = this->dofs.find(dof_id);
   if (it != this->dofs.end()) {
     AKANTU_EXCEPTION("This dof array has already been registered");
   }
 
   std::unique_ptr<DOFData> dofs_storage = std::make_unique<DOFData>(dof_id);
   this->dofs[dof_id] = std::move(dofs_storage);
   return *dofs_storage;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFsInternal(const ID & dof_id,
                                       Array<Real> & dofs_array) {
   DOFData & dofs_storage = this->getDOFData(dof_id);
   dofs_storage.dof = &dofs_array;
 
   UInt nb_local_dofs = 0;
   UInt nb_pure_local = 0;
 
   const DOFSupportType & support_type = dofs_storage.support_type;
 
   switch (support_type) {
   case _dst_nodal: {
     UInt nb_nodes = 0;
     const ID & group = dofs_storage.group_support;
 
     NodeGroup * node_group = nullptr;
     if (group == "__mesh__") {
       nb_nodes = this->mesh->getNbNodes();
     } else {
       node_group = &this->mesh->getElementGroup(group).getNodeGroup();
       nb_nodes = node_group->size();
     }
 
     nb_local_dofs = nb_nodes;
     AKANTU_DEBUG_ASSERT(
         dofs_array.size() == nb_local_dofs,
         "The array of dof is too shot to be associated to nodes.");
 
     for (UInt n = 0; n < nb_nodes; ++n) {
       UInt node = n;
       if (node_group)
         node = node_group->getNodes()(n);
 
       nb_pure_local += this->mesh->isLocalOrMasterNode(node) ? 1 : 0;
     }
 
     nb_pure_local *= dofs_array.getNbComponent();
     nb_local_dofs *= dofs_array.getNbComponent();
     break;
   }
   case _dst_generic: {
     nb_local_dofs = nb_pure_local =
         dofs_array.size() * dofs_array.getNbComponent();
     break;
   }
   default: { AKANTU_EXCEPTION("This type of dofs is not handled yet."); }
   }
 
   this->pure_local_system_size += nb_pure_local;
   this->local_system_size += nb_local_dofs;
 
   communicator.allReduce(nb_pure_local, SynchronizerOperation::_sum);
 
   this->system_size += nb_pure_local;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFs(const ID & dof_id, Array<Real> & dofs_array,
                               const DOFSupportType & support_type) {
   DOFData & dofs_storage = this->getNewDOFData(dof_id);
   dofs_storage.support_type = support_type;
 
   this->registerDOFsInternal(dof_id, dofs_array);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFs(const ID & dof_id, Array<Real> & dofs_array,
                               const ID & support_group) {
   DOFData & dofs_storage = this->getNewDOFData(dof_id);
   dofs_storage.support_type = _dst_nodal;
   dofs_storage.group_support = support_group;
 
   this->registerDOFsInternal(dof_id, dofs_array);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFsPrevious(const ID & dof_id, Array<Real> & array) {
   DOFData & dof = this->getDOFData(dof_id);
 
   if (dof.previous != nullptr) {
     AKANTU_EXCEPTION("The previous dofs array for "
                      << dof_id << " has already been registered");
   }
 
   dof.previous = &array;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFsIncrement(const ID & dof_id, Array<Real> & array) {
   DOFData & dof = this->getDOFData(dof_id);
 
   if (dof.increment != nullptr) {
     AKANTU_EXCEPTION("The dofs increment array for "
                      << dof_id << " has already been registered");
   }
 
   dof.increment = &array;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFsDerivative(const ID & dof_id, UInt order,
                                         Array<Real> & dofs_derivative) {
   DOFData & dof = this->getDOFData(dof_id);
   std::vector<Array<Real> *> & derivatives = dof.dof_derivatives;
 
   if (derivatives.size() < order) {
     derivatives.resize(order, nullptr);
   } else {
     if (derivatives[order - 1] != nullptr) {
       AKANTU_EXCEPTION("The dof derivatives of order "
                        << order << " already been registered for this dof ("
                        << dof_id << ")");
     }
   }
 
   derivatives[order - 1] = &dofs_derivative;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerBlockedDOFs(const ID & dof_id,
                                      Array<bool> & blocked_dofs) {
   DOFData & dof = this->getDOFData(dof_id);
 
   if (dof.blocked_dofs != nullptr) {
     AKANTU_EXCEPTION("The blocked dofs array for "
                      << dof_id << " has already been registered");
   }
 
   dof.blocked_dofs = &blocked_dofs;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::splitSolutionPerDOFs() {
   auto it = this->dofs.begin();
   auto end = this->dofs.end();
 
   for (; it != end; ++it) {
     DOFData & dof_data = *it->second;
     dof_data.solution.resize(dof_data.dof->size() *
                              dof_data.dof->getNbComponent());
     this->getSolutionPerDOFs(it->first, dof_data.solution);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix &
 DOFManager::registerSparseMatrix(const ID & matrix_id,
                                  std::unique_ptr<SparseMatrix> & matrix) {
   SparseMatricesMap::const_iterator it = this->matrices.find(matrix_id);
   if (it != this->matrices.end()) {
     AKANTU_EXCEPTION("The matrix " << matrix_id << " already exists in "
                                    << this->id);
   }
 
   SparseMatrix & ret = *matrix;
   this->matrices[matrix_id] = std::move(matrix);
   return ret;
 }
 
 /* -------------------------------------------------------------------------- */
 /// Get an instance of a new SparseMatrix
 Array<Real> & DOFManager::getNewLumpedMatrix(const ID & id) {
   ID matrix_id = this->id + ":lumped_mtx:" + id;
   LumpedMatricesMap::const_iterator it = this->lumped_matrices.find(matrix_id);
   if (it != this->lumped_matrices.end()) {
     AKANTU_EXCEPTION("The lumped matrix " << matrix_id << " already exists in "
                                           << this->id);
   }
 
   auto mtx =
       std::make_unique<Array<Real>>(this->local_system_size, 1, matrix_id);
   this->lumped_matrices[matrix_id] = std::move(mtx);
   return *this->lumped_matrices[matrix_id];
 }
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolver & DOFManager::registerNonLinearSolver(
     const ID & non_linear_solver_id,
     std::unique_ptr<NonLinearSolver> & non_linear_solver) {
   NonLinearSolversMap::const_iterator it =
       this->non_linear_solvers.find(non_linear_solver_id);
   if (it != this->non_linear_solvers.end()) {
     AKANTU_EXCEPTION("The non linear solver " << non_linear_solver_id
                                               << " already exists in "
                                               << this->id);
   }
 
   NonLinearSolver & ret = *non_linear_solver;
   this->non_linear_solvers[non_linear_solver_id] = std::move(non_linear_solver);
 
   return ret;
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolver & DOFManager::registerTimeStepSolver(
     const ID & time_step_solver_id,
     std::unique_ptr<TimeStepSolver> & time_step_solver) {
   TimeStepSolversMap::const_iterator it =
       this->time_step_solvers.find(time_step_solver_id);
   if (it != this->time_step_solvers.end()) {
     AKANTU_EXCEPTION("The non linear solver " << time_step_solver_id
                                               << " already exists in "
                                               << this->id);
   }
 
   TimeStepSolver & ret = *time_step_solver;
   this->time_step_solvers[time_step_solver_id] = std::move(time_step_solver);
   return ret;
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix & DOFManager::getMatrix(const ID & id) {
   ID matrix_id = this->id + ":mtx:" + id;
   SparseMatricesMap::const_iterator it = this->matrices.find(matrix_id);
   if (it == this->matrices.end()) {
     AKANTU_SILENT_EXCEPTION("The matrix " << matrix_id << " does not exists in "
                                           << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFManager::hasMatrix(const ID & id) const {
   ID mtx_id = this->id + ":mtx:" + id;
   auto it = this->matrices.find(mtx_id);
   return it != this->matrices.end();
 }
 
 /* -------------------------------------------------------------------------- */
 Array<Real> & DOFManager::getLumpedMatrix(const ID & id) {
   ID matrix_id = this->id + ":lumped_mtx:" + id;
   LumpedMatricesMap::const_iterator it = this->lumped_matrices.find(matrix_id);
   if (it == this->lumped_matrices.end()) {
     AKANTU_SILENT_EXCEPTION("The lumped matrix "
                             << matrix_id << " does not exists in " << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 const Array<Real> & DOFManager::getLumpedMatrix(const ID & id) const {
   ID matrix_id = this->id + ":lumped_mtx:" + id;
   auto it = this->lumped_matrices.find(matrix_id);
   if (it == this->lumped_matrices.end()) {
     AKANTU_SILENT_EXCEPTION("The lumped matrix "
                             << matrix_id << " does not exists in " << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFManager::hasLumpedMatrix(const ID & id) const {
   ID mtx_id = this->id + ":lumped_mtx:" + id;
   auto it = this->lumped_matrices.find(mtx_id);
   return it != this->lumped_matrices.end();
 }
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolver & DOFManager::getNonLinearSolver(const ID & id) {
   ID non_linear_solver_id = this->id + ":nls:" + id;
   NonLinearSolversMap::const_iterator it =
       this->non_linear_solvers.find(non_linear_solver_id);
   if (it == this->non_linear_solvers.end()) {
     AKANTU_EXCEPTION("The non linear solver " << non_linear_solver_id
                                               << " does not exists in "
                                               << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFManager::hasNonLinearSolver(const ID & id) const {
   ID solver_id = this->id + ":nls:" + id;
   auto it = this->non_linear_solvers.find(solver_id);
   return it != this->non_linear_solvers.end();
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolver & DOFManager::getTimeStepSolver(const ID & id) {
   ID time_step_solver_id = this->id + ":tss:" + id;
   TimeStepSolversMap::const_iterator it =
       this->time_step_solvers.find(time_step_solver_id);
   if (it == this->time_step_solvers.end()) {
     AKANTU_EXCEPTION("The non linear solver " << time_step_solver_id
                                               << " does not exists in "
                                               << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFManager::hasTimeStepSolver(const ID & solver_id) const {
   ID time_step_solver_id = this->id + ":tss:" + solver_id;
   auto it = this->time_step_solvers.find(time_step_solver_id);
   return it != this->time_step_solvers.end();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::savePreviousDOFs(const ID & dofs_id) {
   this->getPreviousDOFs(dofs_id).copy(this->getDOFs(dofs_id));
 }
 
 /* -------------------------------------------------------------------------- */
 /* Mesh Events                                                                */
 /* -------------------------------------------------------------------------- */
 std::pair<UInt, UInt>
 DOFManager::updateNodalDOFs(const ID & dof_id, const Array<UInt> & nodes_list) {
   auto & dof_data = this->getDOFData(dof_id);
   UInt nb_new_local_dofs = 0;
   UInt nb_new_pure_local = 0;
 
   nb_new_local_dofs = nodes_list.size();
   for (const auto & node : nodes_list) {
     nb_new_pure_local += this->mesh->isLocalOrMasterNode(node) ? 1 : 0;
   }
 
   const auto & dof_array = *dof_data.dof;
   nb_new_pure_local *= dof_array.getNbComponent();
   nb_new_local_dofs *= dof_array.getNbComponent();
 
   this->pure_local_system_size += nb_new_pure_local;
   this->local_system_size += nb_new_local_dofs;
 
   UInt nb_new_global = nb_new_pure_local;
   communicator.allReduce(nb_new_global, SynchronizerOperation::_sum);
 
   this->system_size += nb_new_global;
 
   return std::make_pair(nb_new_local_dofs, nb_new_pure_local);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::onNodesAdded(const Array<UInt> & nodes_list,
                               const NewNodesEvent &) {
   for (auto & pair : this->dofs) {
     const auto & dof_id = pair.first;
     auto & dof_data = this->getDOFData(dof_id);
     if (dof_data.support_type != _dst_nodal)
       continue;
 
     const auto & group = dof_data.group_support;
 
     if (group == "__mesh__") {
       this->updateNodalDOFs(dof_id, nodes_list);
     } else {
       const auto & node_group =
           this->mesh->getElementGroup(group).getNodeGroup();
       Array<UInt> new_nodes_list;
       for (const auto & node : nodes_list) {
         if (node_group.find(node) != UInt(-1))
           new_nodes_list.push_back(node);
       }
 
       this->updateNodalDOFs(dof_id, new_nodes_list);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::onNodesRemoved(const Array<UInt> &, const Array<UInt> &,
                                 const RemovedNodesEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::onElementsAdded(const Array<Element> &,
                                  const NewElementsEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::onElementsRemoved(const Array<Element> &,
                                    const ElementTypeMapArray<UInt> &,
                                    const RemovedElementsEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::onElementsChanged(const Array<Element> &,
                                    const Array<Element> &,
                                    const ElementTypeMapArray<UInt> &,
                                    const ChangedElementsEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/model/dof_manager_petsc.cc b/src/model/dof_manager_petsc.cc
index b34b3d7b5..d0d982bf1 100644
--- a/src/model/dof_manager_petsc.cc
+++ b/src/model/dof_manager_petsc.cc
@@ -1,396 +1,396 @@
 /**
  * @file   dof_manager_petsc.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Mon Oct  5 21:19:58 2015
  *
  * @brief  DOFManaterPETSc is the PETSc implementation of the DOFManager
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 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 "dof_manager_petsc.hh"
 
 #include "cppargparse.hh"
 
 #if defined(AKANTU_USE_MPI)
 #include "static_communicator.hh"
 #include "mpi_type_wrapper.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 #include <petscsys.h>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 #if not defined(PETSC_CLANGUAGE_CXX)
 /// small hack to use the c binding of petsc when the cxx binding does notation
 /// exists
 int aka_PETScError(int ierr) {
   CHKERRQ(ierr);
   return 0;
 }
 #endif
 
 UInt DOFManagerPETSc::petsc_dof_manager_instances = 0;
 
 /// Error handler to make PETSc errors caught by Akantu
 #if PETSC_VERSION_MAJOR >= 3 && PETSC_VERSION_MINOR >= 5
 static PetscErrorCode PETScErrorHandler(MPI_Comm, int line, const char * dir,
                                         const char * file,
                                         PetscErrorCode number,
                                         PetscErrorType type,
                                         const char * message, void *) {
-  AKANTU_DEBUG_ERROR("An error occured in PETSc in file \""
+  AKANTU_ERROR("An error occured in PETSc in file \""
                      << file << ":" << line << "\" - PetscErrorCode " << number
                      << " - \"" << message << "\"");
 }
 #else
 static PetscErrorCode PETScErrorHandler(MPI_Comm, int line, const char * func,
                                         const char * dir, const char * file,
                                         PetscErrorCode number,
                                         PetscErrorType type,
                                         const char * message, void *) {
-  AKANTU_DEBUG_ERROR("An error occured in PETSc in file \""
+  AKANTU_ERROR("An error occured in PETSc in file \""
                      << file << ":" << line << "\" - PetscErrorCode " << number
                      << " - \"" << message << "\"");
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 DOFManagerPETSc::DOFManagerPETSc(const ID & id,
                                  const MemoryID & memory_id)
     : DOFManager(id, memory_id) {
 
 // check if the akantu types and PETSc one are consistant
 #if __cplusplus > 199711L
   static_assert(sizeof(Int) == sizeof(PetscInt),
                 "The integer type of Akantu does not match the one from PETSc");
   static_assert(sizeof(Real) == sizeof(PetscReal),
                 "The integer type of Akantu does not match the one from PETSc");
 #else
   AKANTU_DEBUG_ASSERT(
       sizeof(Int) == sizeof(PetscInt),
       "The integer type of Akantu does not match the one from PETSc");
   AKANTU_DEBUG_ASSERT(
       sizeof(Real) == sizeof(PetscReal),
       "The integer type of Akantu does not match the one from PETSc");
 #endif
 
   if (this->petsc_dof_manager_instances == 0) {
 #if defined(AKANTU_USE_MPI)
     StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
     const StaticCommunicatorMPI & mpi_st_comm =
         dynamic_cast<const StaticCommunicatorMPI &>(
             comm.getRealStaticCommunicator());
 
     this->mpi_communicator = mpi_st_comm.getMPITypeWrapper().getMPICommunicator();
 #else
     this->mpi_communicator = PETSC_COMM_SELF;
 #endif
 
     cppargparse::ArgumentParser & argparser = getStaticArgumentParser();
     int & argc = argparser.getArgC();
     char **& argv = argparser.getArgV();
 
     PetscErrorCode petsc_error = PetscInitialize(&argc, &argv, NULL, NULL);
 
     if (petsc_error != 0) {
-      AKANTU_DEBUG_ERROR(
+      AKANTU_ERROR(
           "An error occured while initializing Petsc (PetscErrorCode "
           << petsc_error << ")");
     }
 
     PetscPushErrorHandler(PETScErrorHandler, NULL);
     this->petsc_dof_manager_instances++;
   }
 
   VecCreate(PETSC_COMM_WORLD, &this->residual);
   VecCreate(PETSC_COMM_WORLD, &this->solution);
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManagerPETSc::~DOFManagerPETSc() {
   PetscErrorCode ierr;
   ierr = VecDestroy(&(this->residual));
   CHKERRXX(ierr);
 
   ierr = VecDestroy(&(this->solution));
   CHKERRXX(ierr);
 
   this->petsc_dof_manager_instances--;
   if (this->petsc_dof_manager_instances == 0) {
     PetscFinalize();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerPETSc::registerDOFs(const ID & dof_id, Array<Real> & dofs_array,
                                    DOFSupportType & support_type) {
   DOFManager::registerDOFs(dof_id, dofs_array, support_type);
 
   PetscErrorCode ierr;
 
   PetscInt current_size;
   ierr = VecGetSize(this->residual, &current_size);
   CHKERRXX(ierr);
 
   if (current_size == 0) { // first time vector is set
     PetscInt local_size = this->pure_local_system_size;
     ierr = VecSetSizes(this->residual, local_size, PETSC_DECIDE);
     CHKERRXX(ierr);
 
     ierr = VecSetFromOptions(this->residual);
     CHKERRXX(ierr);
 
 #ifndef AKANTU_NDEBUG
     PetscInt global_size;
     ierr = VecGetSize(this->residual, &global_size);
     CHKERRXX(ierr);
     AKANTU_DEBUG_ASSERT(this->system_size == UInt(global_size),
                         "The local value of the system size does not match the "
                         "one determined by PETSc");
 #endif
     PetscInt start_dof, end_dof;
     VecGetOwnershipRange(this->residual, &start_dof, &end_dof);
 
     PetscInt * global_indices = new PetscInt[local_size];
     global_indices[0] = start_dof;
 
     for (PetscInt d = 0; d < local_size; d++)
       global_indices[d + 1] = global_indices[d] + 1;
 
 // To be change if we switch to a block definition
 #if PETSC_VERSION_MAJOR >= 3 && PETSC_VERSION_MINOR >= 5
     ISLocalToGlobalMappingCreate(this->communicator, 1, local_size,
                                  global_indices, PETSC_COPY_VALUES,
                                  &this->is_ltog);
 
 #else
     ISLocalToGlobalMappingCreate(this->communicator, local_size, global_indices,
                                  PETSC_COPY_VALUES, &this->is_ltog);
 #endif
 
     VecSetLocalToGlobalMapping(this->residual, this->is_ltog);
     delete[] global_indices;
 
     ierr = VecDuplicate(this->residual, &this->solution);
     CHKERRXX(ierr);
 
   } else { // this is an update of the object already created
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// set the solution to zero
   // ierr = VecZeroEntries(this->solution);
   // CHKERRXX(ierr);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * This function creates the non-zero pattern of the PETSc matrix. In
  * PETSc the parallel matrix is partitioned across processors such
  * that the first m0 rows belong to process 0, the next m1 rows belong
  * to process 1, the next m2 rows belong to process 2 etc.. where
  * m0,m1,m2,.. are the input parameter 'm'. i.e each processor stores
  * values corresponding to [m x N] submatrix
  * (http://www.mcs.anl.gov/petsc/).
  * @param mesh mesh discretizing the domain we want to analyze
  * @param dof_synchronizer dof synchronizer that maps the local
  * dofs to the global dofs and the equation numbers, i.e., the
  * position at which the dof is assembled in the matrix
  */
 
 // void SparseMatrixPETSc::buildProfile(const Mesh & mesh,
 //                                      const DOFSynchronizer &
 //                                      dof_synchronizer,
 //                                      UInt nb_degree_of_freedom) {
 //   AKANTU_DEBUG_IN();
 
 //   // clearProfile();
 //   this->dof_synchronizer = &const_cast<DOFSynchronizer &>(dof_synchronizer);
 //   this->setSize();
 //   PetscErrorCode ierr;
 
 //   /// resize arrays to store the number of nonzeros in each row
 //   this->d_nnz.resize(this->local_size);
 //   this->o_nnz.resize(this->local_size);
 
 //   /// set arrays to zero everywhere
 //   this->d_nnz.set(0);
 //   this->o_nnz.set(0);
 
 //   // if(irn_jcn_to_k) delete irn_jcn_to_k;
 //   // irn_jcn_to_k = new std::map<std::pair<UInt, UInt>, UInt>;
 
 //   coordinate_list_map::iterator irn_jcn_k_it;
 
 //   Int * eq_nb_val = dof_synchronizer.getGlobalDOFEquationNumbers().storage();
 //   UInt nb_global_dofs = dof_synchronizer.getNbGlobalDOFs();
 //   Array<Int> index_pair(2);
 
 //   /// Loop over all the ghost types
 //   for (ghost_type_t::iterator gt = ghost_type_t::begin();
 //        gt != ghost_type_t::end(); ++gt) {
 //     const GhostType & ghost_type = *gt;
 //     Mesh::type_iterator it =
 //         mesh.firstType(mesh.getSpatialDimension(), ghost_type,
 //         _ek_not_defined);
 //     Mesh::type_iterator end =
 //         mesh.lastType(mesh.getSpatialDimension(), ghost_type,
 //         _ek_not_defined);
 //     for (; it != end; ++it) {
 //       UInt nb_element = mesh.getNbElement(*it, ghost_type);
 //       UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(*it);
 //       UInt size_mat = nb_nodes_per_element * nb_degree_of_freedom;
 
 //       UInt * conn_val = mesh.getConnectivity(*it, ghost_type).storage();
 //       Int * local_eq_nb_val =
 //           new Int[nb_degree_of_freedom * nb_nodes_per_element];
 
 //       for (UInt e = 0; e < nb_element; ++e) {
 //         Int * tmp_local_eq_nb_val = local_eq_nb_val;
 //         for (UInt i = 0; i < nb_nodes_per_element; ++i) {
 //           UInt n = conn_val[i];
 //           for (UInt d = 0; d < nb_degree_of_freedom; ++d) {
 //             /**
 //              * !!!!!!Careful!!!!!! This is a ugly fix. @todo this is a
 //              * very ugly fix, because the offset for the global
 //              * equation number, where the dof will be assembled, is
 //              * hardcoded. In the future a class dof manager has to be
 //              * added to Akantu to handle the mapping between the dofs
 //              * and the equation numbers
 //              *
 //              */
 
 //             *tmp_local_eq_nb_val++ =
 //                 eq_nb_val[n * nb_degree_of_freedom + d] -
 //                 (dof_synchronizer.isPureGhostDOF(n * nb_degree_of_freedom +
 //                 d)
 //                      ? nb_global_dofs
 //                      : 0);
 //           }
 //         }
 
 //         for (UInt i = 0; i < size_mat; ++i) {
 //           Int c_irn = local_eq_nb_val[i];
 //           UInt j_start = 0;
 //           for (UInt j = j_start; j < size_mat; ++j) {
 //             Int c_jcn = local_eq_nb_val[j];
 //             index_pair(0) = c_irn;
 //             index_pair(1) = c_jcn;
 //             AOApplicationToPetsc(this->petsc_matrix_wrapper->ao, 2,
 //                                  index_pair.storage());
 //             if (index_pair(0) >= first_global_index &&
 //                 index_pair(0) < first_global_index + this->local_size) {
 //               KeyCOO irn_jcn = keyPETSc(c_irn, c_jcn);
 //               irn_jcn_k_it = irn_jcn_k.find(irn_jcn);
 
 //               if (irn_jcn_k_it == irn_jcn_k.end()) {
 //                 irn_jcn_k[irn_jcn] = nb_non_zero;
 
 //                 // check if node is slave node
 //                 if (index_pair(1) >= first_global_index &&
 //                     index_pair(1) < first_global_index + this->local_size)
 //                   this->d_nnz(index_pair(0) - first_global_index) += 1;
 //                 else
 //                   this->o_nnz(index_pair(0) - first_global_index) += 1;
 //                 nb_non_zero++;
 //               }
 //             }
 //           }
 //         }
 //         conn_val += nb_nodes_per_element;
 //       }
 
 //       delete[] local_eq_nb_val;
 //     }
 //   }
 
 //   // /// for pbc @todo correct it for parallel
 //   // if(StaticCommunicator::getStaticCommunicator().getNbProc() == 1) {
 //   //   for (UInt i = 0; i < size; ++i) {
 //   //    KeyCOO irn_jcn = key(i, i);
 //   //    irn_jcn_k_it = irn_jcn_k.find(irn_jcn);
 //   //    if(irn_jcn_k_it == irn_jcn_k.end()) {
 //   //      irn_jcn_k[irn_jcn] = nb_non_zero;
 //   //      irn.push_back(i + 1);
 //   //      jcn.push_back(i + 1);
 //   //      nb_non_zero++;
 //   //    }
 //   //   }
 //   // }
 
 //   // std::string mat_type;
 //   // mat_type.resize(20, 'a');
 //   // std::cout << "MatType: " << mat_type << std::endl;
 //   // const char * mat_type_ptr = mat_type.c_str();
 //   MatType type;
 //   MatGetType(this->petsc_matrix_wrapper->mat, &type);
 //   /// std::cout << "the matrix type is: " << type << std::endl;
 //   /**
 //    * PETSc will use only one of the following preallocation commands
 //    * depending on the matrix type and ignore the rest. Note that for
 //    * the block matrix format a block size of 1 is used. This might
 //    * result in bad performance. @todo For better results implement
 //    * buildProfile() with larger block size.
 //    *
 //    */
 //   /// build profile:
 //   if (strcmp(type, MATSEQAIJ) == 0) {
 //     ierr = MatSeqAIJSetPreallocation(this->petsc_matrix_wrapper->mat, 0,
 //                                      d_nnz.storage());
 //     CHKERRXX(ierr);
 //   } else if ((strcmp(type, MATMPIAIJ) == 0)) {
 //     ierr = MatMPIAIJSetPreallocation(this->petsc_matrix_wrapper->mat, 0,
 //                                      d_nnz.storage(), 0, o_nnz.storage());
 //     CHKERRXX(ierr);
 //   } else {
-//     AKANTU_DEBUG_ERROR("The type " << type
+//     AKANTU_ERROR("The type " << type
 //                                    << " of PETSc matrix is not handled by"
 //                                    << " akantu in the preallocation step");
 //   }
 
 //   // ierr =  MatSeqSBAIJSetPreallocation(this->petsc_matrix_wrapper->mat, 1,
 //   //                                  0, d_nnz.storage()); CHKERRXX(ierr);
 
 //   if (this->sparse_matrix_type == _symmetric) {
 //     /// set flag for symmetry to enable ICC/Cholesky preconditioner
 //     ierr = MatSetOption(this->petsc_matrix_wrapper->mat, MAT_SYMMETRIC,
 //                         PETSC_TRUE);
 //     CHKERRXX(ierr);
 //     /// set flag for symmetric positive definite
 //     ierr = MatSetOption(this->petsc_matrix_wrapper->mat, MAT_SPD,
 //     PETSC_TRUE);
 //     CHKERRXX(ierr);
 //   }
 //   /// once the profile has been build ignore any new nonzero locations
 //   ierr = MatSetOption(this->petsc_matrix_wrapper->mat,
 //                       MAT_NEW_NONZERO_LOCATIONS, PETSC_TRUE);
 //   CHKERRXX(ierr);
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/model/heat_transfer/heat_transfer_model.cc b/src/model/heat_transfer/heat_transfer_model.cc
index f9b05bc17..283da8b0c 100644
--- a/src/model/heat_transfer/heat_transfer_model.cc
+++ b/src/model/heat_transfer/heat_transfer_model.cc
@@ -1,971 +1,971 @@
 /**
  * @file   heat_transfer_model.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Srinivasa Babu Ramisetti <srinivasa.ramisetti@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Rui Wang <rui.wang@epfl.ch>
  *
  * @date creation: Sun May 01 2011
  * @date last modification: Mon Nov 30 2015
  *
  * @brief  Implementation of HeatTransferModel class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "heat_transfer_model.hh"
 #include "dumpable_inline_impl.hh"
 #include "element_synchronizer.hh"
 #include "fe_engine_template.hh"
 #include "generalized_trapezoidal.hh"
 #include "group_manager_inline_impl.cc"
 #include "integrator_gauss.hh"
 #include "mesh.hh"
 #include "parser.hh"
 #include "shape_lagrange.hh"
 
 #ifdef AKANTU_USE_IOHELPER
 #include "dumper_element_partition.hh"
 #include "dumper_elemental_field.hh"
 #include "dumper_internal_material_field.hh"
 #include "dumper_iohelper_paraview.hh"
 #endif
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
 namespace heat_transfer {
   namespace details {
     class ComputeRhoFunctor {
     public:
       ComputeRhoFunctor(const HeatTransferModel & model) : model(model){};
 
       void operator()(Matrix<Real> & rho, const Element &) const {
         rho.set(model.getCapacity());
       }
 
     private:
       const HeatTransferModel & model;
     };
   }
 }
 
 /* -------------------------------------------------------------------------- */
 HeatTransferModel::HeatTransferModel(Mesh & mesh, UInt dim, const ID & id,
                                      const MemoryID & memory_id)
     : Model(mesh, ModelType::_heat_transfer_model, dim, id, memory_id),
       temperature_gradient("temperature_gradient", id),
       temperature_on_qpoints("temperature_on_qpoints", id),
       conductivity_on_qpoints("conductivity_on_qpoints", id),
       k_gradt_on_qpoints("k_gradt_on_qpoints", id) {
   AKANTU_DEBUG_IN();
 
   conductivity = Matrix<Real>(this->spatial_dimension, this->spatial_dimension);
 
   this->initDOFManager();
 
   this->registerDataAccessor(*this);
 
   if (this->mesh.isDistributed()) {
     auto & synchronizer = this->mesh.getElementSynchronizer();
     this->registerSynchronizer(synchronizer, _gst_htm_capacity);
     this->registerSynchronizer(synchronizer, _gst_htm_temperature);
     this->registerSynchronizer(synchronizer, _gst_htm_gradient_temperature);
   }
 
   registerFEEngineObject<FEEngineType>(id + ":fem", mesh, spatial_dimension);
 
 #ifdef AKANTU_USE_IOHELPER
   this->mesh.registerDumper<DumperParaview>("heat_transfer", id, true);
   this->mesh.addDumpMesh(mesh, spatial_dimension, _not_ghost, _ek_regular);
 #endif
 
   this->registerParam("conductivity", conductivity, _pat_parsmod);
   this->registerParam("conductivity_variation", conductivity_variation, 0.,
                       _pat_parsmod);
   this->registerParam("temperature_reference", T_ref, 0., _pat_parsmod);
   this->registerParam("capacity", capacity, _pat_parsmod);
   this->registerParam("density", density, _pat_parsmod);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::initModel() {
   auto & fem = this->getFEEngine();
   fem.initShapeFunctions(_not_ghost);
   fem.initShapeFunctions(_ghost);
 
   temperature_on_qpoints.initialize(fem, _nb_component = 1);
   temperature_gradient.initialize(fem, _nb_component = spatial_dimension);
   conductivity_on_qpoints.initialize(
       fem, _nb_component = spatial_dimension * spatial_dimension);
   k_gradt_on_qpoints.initialize(fem, _nb_component = spatial_dimension);
 }
 
 /* -------------------------------------------------------------------------- */
 FEEngine & HeatTransferModel::getFEEngineBoundary(const ID & name) {
   return dynamic_cast<FEEngine &>(getFEEngineClassBoundary<FEEngineType>(name));
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void HeatTransferModel::allocNodalField(Array<T> *& array, const ID & name) {
   if (array == nullptr) {
     UInt nb_nodes = mesh.getNbNodes();
     std::stringstream sstr_disp;
     sstr_disp << id << ":" << name;
 
     array = &(alloc<T>(sstr_disp.str(), nb_nodes, 1, T()));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 HeatTransferModel::~HeatTransferModel() = default;
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleCapacityLumped(const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   auto & fem = getFEEngineClass<FEEngineType>();
   heat_transfer::details::ComputeRhoFunctor compute_rho(*this);
 
   for (auto & type : mesh.elementTypes(spatial_dimension, ghost_type)) {
     fem.assembleFieldLumped(compute_rho, "M", "temperature",
                             this->getDOFManager(), type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 MatrixType HeatTransferModel::getMatrixType(const ID & matrix_id) {
   if (matrix_id == "K" or matrix_id == "M") {
     return _symmetric;
   }
 
   return _mt_not_defined;
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleMatrix(const ID & matrix_id) {
   if (matrix_id == "K") {
     this->assembleConductivityMatrix();
   } else if (matrix_id == "M") {
     this->assembleCapacity();
   } else {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleLumpedMatrix(const ID & matrix_id) {
   if (matrix_id == "M") {
     this->assembleCapacityLumped();
   } else {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleResidual() {
   AKANTU_DEBUG_IN();
 
   this->assembleInternalHeatRate();
 
   this->getDOFManager().assembleToResidual("temperature",
                                            *this->external_heat_rate, 1);
   this->getDOFManager().assembleToResidual("temperature",
                                            *this->internal_heat_rate, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::predictor() { ++temperature_release; }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleCapacityLumped() {
   AKANTU_DEBUG_IN();
 
   if (!this->getDOFManager().hasLumpedMatrix("M")) {
     this->getDOFManager().getNewLumpedMatrix("M");
   }
 
   this->getDOFManager().clearLumpedMatrix("M");
 
   assembleCapacityLumped(_not_ghost);
   assembleCapacityLumped(_ghost);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::initSolver(TimeStepSolverType time_step_solver_type,
                                    NonLinearSolverType) {
   DOFManager & dof_manager = this->getDOFManager();
 
   this->allocNodalField(this->temperature, "temperature");
   this->allocNodalField(this->external_heat_rate, "external_heat_rate");
   this->allocNodalField(this->internal_heat_rate, "internal_heat_rate");
   this->allocNodalField(this->blocked_dofs, "blocked_dofs");
 
   if (!dof_manager.hasDOFs("temperature")) {
     dof_manager.registerDOFs("temperature", *this->temperature, _dst_nodal);
     dof_manager.registerBlockedDOFs("temperature", *this->blocked_dofs);
   }
 
   if (time_step_solver_type == _tsst_dynamic ||
       time_step_solver_type == _tsst_dynamic_lumped) {
     this->allocNodalField(this->temperature_rate, "temperature_rate");
 
     if (!dof_manager.hasDOFsDerivatives("temperature", 1)) {
       dof_manager.registerDOFsDerivative("temperature", 1,
                                          *this->temperature_rate);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 std::tuple<ID, TimeStepSolverType>
 HeatTransferModel::getDefaultSolverID(const AnalysisMethod & method) {
   switch (method) {
   case _explicit_lumped_mass: {
     return std::make_tuple("explicit_lumped", _tsst_dynamic_lumped);
   }
   case _static: {
     return std::make_tuple("static", _tsst_static);
   }
   case _implicit_dynamic: {
     return std::make_tuple("implicit", _tsst_dynamic);
   }
   default:
     return std::make_tuple("unknown", _tsst_not_defined);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 ModelSolverOptions HeatTransferModel::getDefaultSolverOptions(
     const TimeStepSolverType & type) const {
   ModelSolverOptions options;
 
   switch (type) {
   case _tsst_dynamic_lumped: {
     options.non_linear_solver_type = _nls_lumped;
     options.integration_scheme_type["temperature"] = _ist_forward_euler;
     options.solution_type["temperature"] = IntegrationScheme::_temperature_rate;
     break;
   }
   case _tsst_static: {
     options.non_linear_solver_type = _nls_newton_raphson;
     options.integration_scheme_type["temperature"] = _ist_pseudo_time;
     options.solution_type["temperature"] = IntegrationScheme::_not_defined;
     break;
   }
   case _tsst_dynamic: {
     if (this->method == _explicit_consistent_mass) {
       options.non_linear_solver_type = _nls_newton_raphson;
       options.integration_scheme_type["temperature"] = _ist_forward_euler;
       options.solution_type["temperature"] =
           IntegrationScheme::_temperature_rate;
     } else {
       options.non_linear_solver_type = _nls_newton_raphson;
       options.integration_scheme_type["temperature"] = _ist_trapezoidal_rule_1;
       options.solution_type["temperature"] = IntegrationScheme::_temperature;
     }
     break;
   }
   default:
     AKANTU_EXCEPTION(type << " is not a valid time step solver type");
   }
 
   return options;
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleConductivityMatrix() {
   AKANTU_DEBUG_IN();
 
   this->computeConductivityOnQuadPoints(_not_ghost);
   if (conductivity_release[_not_ghost] == conductivity_matrix_release)
     return;
 
   if (!this->getDOFManager().hasMatrix("K")) {
     this->getDOFManager().getNewMatrix("K", getMatrixType("K"));
   }
   this->getDOFManager().clearMatrix("K");
 
   switch (mesh.getSpatialDimension()) {
   case 1:
     this->assembleConductivityMatrix<1>(_not_ghost);
     break;
   case 2:
     this->assembleConductivityMatrix<2>(_not_ghost);
     break;
   case 3:
     this->assembleConductivityMatrix<3>(_not_ghost);
     break;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void HeatTransferModel::assembleConductivityMatrix(
     const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   auto & fem = this->getFEEngine();
 
   for (auto && type : mesh.elementTypes(spatial_dimension, ghost_type)) {
     auto nb_element = mesh.getNbElement(type, ghost_type);
     auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
     auto nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
     auto bt_d_b = std::make_unique<Array<Real>>(
         nb_element * nb_quadrature_points,
         nb_nodes_per_element * nb_nodes_per_element, "B^t*D*B");
 
     fem.computeBtDB(conductivity_on_qpoints(type, ghost_type), *bt_d_b, 2, type,
                     ghost_type);
 
     /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
     auto K_e = std::make_unique<Array<Real>>(
         nb_element, nb_nodes_per_element * nb_nodes_per_element, "K_e");
 
     fem.integrate(*bt_d_b, *K_e, nb_nodes_per_element * nb_nodes_per_element,
                   type, ghost_type);
 
     this->getDOFManager().assembleElementalMatricesToMatrix(
         "K", "temperature", *K_e, type, ghost_type, _symmetric);
   }
 
   conductivity_matrix_release = conductivity_release[ghost_type];
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::computeConductivityOnQuadPoints(
     const GhostType & ghost_type) {
   // if already computed once check if need to compute
   if (not initial_conductivity[ghost_type]) {
     // if temperature did not change, condictivity will not vary
     if (temperature_release == conductivity_release[ghost_type])
       return;
 
     // if conductivity_variation is 0 no need to recompute
     if (conductivity_variation == 0.)
       return;
   }
 
   for (auto & type : mesh.elementTypes(spatial_dimension, ghost_type)) {
     auto & temperature_interpolated = temperature_on_qpoints(type, ghost_type);
 
     // compute the temperature on quadrature points
     this->getFEEngine().interpolateOnIntegrationPoints(
         *temperature, temperature_interpolated, 1, type, ghost_type);
 
     auto & cond = conductivity_on_qpoints(type, ghost_type);
     for (auto && tuple :
          zip(make_view(cond, spatial_dimension, spatial_dimension),
              temperature_interpolated)) {
       auto & C = std::get<0>(tuple);
       auto & T = std::get<1>(tuple);
       C = conductivity;
 
       Matrix<Real> variation(spatial_dimension, spatial_dimension,
                              conductivity_variation * (T - T_ref));
       // @TODO: Guillaume are you sure ? why due you compute variation then ?
       C += conductivity_variation;
     }
   }
 
   conductivity_release[ghost_type] = temperature_release;
   initial_conductivity[ghost_type] = false;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::computeKgradT(const GhostType & ghost_type) {
   computeConductivityOnQuadPoints(ghost_type);
 
   for (auto & type : mesh.elementTypes(spatial_dimension, ghost_type)) {
     auto & gradient = temperature_gradient(type, ghost_type);
     this->getFEEngine().gradientOnIntegrationPoints(*temperature, gradient, 1,
                                                     type, ghost_type);
 
     for (auto && values :
          zip(make_view(conductivity_on_qpoints(type, ghost_type),
                        spatial_dimension, spatial_dimension),
              make_view(gradient, spatial_dimension),
              make_view(k_gradt_on_qpoints(type, ghost_type),
                        spatial_dimension))) {
       const auto & C = std::get<0>(values);
       const auto & BT = std::get<1>(values);
       auto & k_BT = std::get<2>(values);
 
       k_BT.mul<false>(C, BT);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleInternalHeatRate() {
   AKANTU_DEBUG_IN();
 
   this->internal_heat_rate->clear();
 
   this->synchronize(_gst_htm_temperature);
   auto & fem = this->getFEEngine();
 
   for (auto ghost_type : ghost_types) {
     // compute k \grad T
     computeKgradT(ghost_type);
 
     for (auto type : mesh.elementTypes(spatial_dimension, ghost_type)) {
       UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
       auto & k_gradt_on_qpoints_vect = k_gradt_on_qpoints(type, ghost_type);
 
       UInt nb_quad_points = k_gradt_on_qpoints_vect.size();
       Array<Real> bt_k_gT(nb_quad_points, nb_nodes_per_element);
       fem.computeBtD(k_gradt_on_qpoints_vect, bt_k_gT, type, ghost_type);
 
       UInt nb_elements = mesh.getNbElement(type, ghost_type);
       Array<Real> int_bt_k_gT(nb_elements, nb_nodes_per_element);
 
       fem.integrate(bt_k_gT, int_bt_k_gT, nb_nodes_per_element, type,
                     ghost_type);
 
       this->getDOFManager().assembleElementalArrayLocalArray(
           int_bt_k_gT, *this->internal_heat_rate, type, ghost_type, -1);
     }
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::getStableTimeStep() {
   AKANTU_DEBUG_IN();
 
   Real el_size;
   Real min_el_size = std::numeric_limits<Real>::max();
   Real conductivitymax = conductivity(0, 0);
 
   // get the biggest parameter from k11 until k33//
   for (UInt i = 0; i < spatial_dimension; i++)
     for (UInt j = 0; j < spatial_dimension; j++)
       conductivitymax = std::max(conductivity(i, j), conductivitymax);
 
   for (auto & type : mesh.elementTypes(spatial_dimension, _not_ghost)) {
 
     UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
 
     Array<Real> coord(0, nb_nodes_per_element * spatial_dimension);
     FEEngine::extractNodalToElementField(mesh, mesh.getNodes(), coord, type,
                                          _not_ghost);
 
     auto el_coord = coord.begin(spatial_dimension, nb_nodes_per_element);
     UInt nb_element = mesh.getNbElement(type);
 
     for (UInt el = 0; el < nb_element; ++el, ++el_coord) {
       el_size = getFEEngine().getElementInradius(*el_coord, type);
       min_el_size = std::min(min_el_size, el_size);
     }
 
     AKANTU_DEBUG_INFO("The minimum element size : "
                       << min_el_size
                       << " and the max conductivity is : " << conductivitymax);
   }
 
   Real min_dt =
       2 * min_el_size * min_el_size * density * capacity / conductivitymax;
 
   mesh.getCommunicator().allReduce(min_dt, SynchronizerOperation::_min);
 
   AKANTU_DEBUG_OUT();
 
   return min_dt;
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::readMaterials() {
   auto sect = this->getParserSection();
 
   if (not std::get<1>(sect)) {
     const auto & section = std::get<0>(sect);
     this->parseSection(section);
   }
 
   conductivity_on_qpoints.set(conductivity);
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::initFullImpl(const ModelOptions & options) {
   Model::initFullImpl(options);
 
   readMaterials();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleCapacity() {
   AKANTU_DEBUG_IN();
   auto ghost_type = _not_ghost;
 
   auto & fem = getFEEngineClass<FEEngineType>();
 
   heat_transfer::details::ComputeRhoFunctor rho_functor(*this);
 
   for (auto && type : mesh.elementTypes(spatial_dimension, ghost_type)) {
     fem.assembleFieldMatrix(rho_functor, "M", "temperature",
                             this->getDOFManager(), type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::computeRho(Array<Real> & rho, ElementType type,
                                    GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   FEEngine & fem = this->getFEEngine();
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
   rho.resize(nb_element * nb_quadrature_points);
   rho.set(this->capacity);
 
   // Real * rho_1_val = rho.storage();
   // /// compute @f$ rho @f$ for each nodes of each element
   // for (UInt el = 0; el < nb_element; ++el) {
   //   for (UInt n = 0; n < nb_quadrature_points; ++n) {
   //     *rho_1_val++ = this->capacity;
   //   }
   // }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::computeThermalEnergyByNode() {
   AKANTU_DEBUG_IN();
 
   Real ethermal = 0.;
 
   for (auto && pair : enumerate(make_view(
            *internal_heat_rate, internal_heat_rate->getNbComponent()))) {
     auto n = std::get<0>(pair);
     auto & heat_rate = std::get<1>(pair);
 
     Real heat = 0.;
     bool is_local_node = mesh.isLocalOrMasterNode(n);
     bool is_not_pbc_slave_node = !isPBCSlaveNode(n);
     bool count_node = is_local_node && is_not_pbc_slave_node;
 
     for (UInt i = 0; i < heat_rate.size(); ++i) {
       if (count_node)
         heat += heat_rate[i] * time_step;
     }
     ethermal += heat;
   }
 
   mesh.getCommunicator().allReduce(ethermal, SynchronizerOperation::_sum);
 
   AKANTU_DEBUG_OUT();
   return ethermal;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class iterator>
 void HeatTransferModel::getThermalEnergy(
     iterator Eth, Array<Real>::const_iterator<Real> T_it,
     Array<Real>::const_iterator<Real> T_end) const {
   for (; T_it != T_end; ++T_it, ++Eth) {
     *Eth = capacity * density * *T_it;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::getThermalEnergy(const ElementType & type, UInt index) {
   AKANTU_DEBUG_IN();
 
   UInt nb_quadrature_points = getFEEngine().getNbIntegrationPoints(type);
   Vector<Real> Eth_on_quarature_points(nb_quadrature_points);
 
   auto T_it = this->temperature_on_qpoints(type).begin();
   T_it += index * nb_quadrature_points;
 
   auto T_end = T_it + nb_quadrature_points;
 
   getThermalEnergy(Eth_on_quarature_points.storage(), T_it, T_end);
 
   return getFEEngine().integrate(Eth_on_quarature_points, type, index);
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::getThermalEnergy() {
   Real Eth = 0;
 
   auto & fem = getFEEngine();
 
   for (auto && type : mesh.elementTypes(spatial_dimension)) {
     auto nb_element = mesh.getNbElement(type, _not_ghost);
     auto nb_quadrature_points = fem.getNbIntegrationPoints(type, _not_ghost);
     Array<Real> Eth_per_quad(nb_element * nb_quadrature_points, 1);
 
     auto & temperature_interpolated = temperature_on_qpoints(type);
 
     // compute the temperature on quadrature points
     this->getFEEngine().interpolateOnIntegrationPoints(
         *temperature, temperature_interpolated, 1, type);
 
     auto T_it = temperature_interpolated.begin();
     auto T_end = temperature_interpolated.end();
     getThermalEnergy(Eth_per_quad.begin(), T_it, T_end);
 
     Eth += fem.integrate(Eth_per_quad, type);
   }
 
   return Eth;
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::getEnergy(const std::string & id) {
   AKANTU_DEBUG_IN();
   Real energy = 0;
 
   if (id == "thermal")
     energy = getThermalEnergy();
 
   // reduction sum over all processors
   mesh.getCommunicator().allReduce(energy, SynchronizerOperation::_sum);
 
   AKANTU_DEBUG_OUT();
   return energy;
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::getEnergy(const std::string & id,
                                   const ElementType & type, UInt index) {
   AKANTU_DEBUG_IN();
 
   Real energy = 0.;
 
   if (id == "thermal")
     energy = getThermalEnergy(type, index);
 
   AKANTU_DEBUG_OUT();
   return energy;
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 #ifdef AKANTU_USE_IOHELPER
 
 dumper::Field * HeatTransferModel::createNodalFieldBool(
     const std::string & field_name, const std::string & group_name,
     __attribute__((unused)) bool padding_flag) {
 
   std::map<std::string, Array<bool> *> uint_nodal_fields;
   uint_nodal_fields["blocked_dofs"] = blocked_dofs;
 
   dumper::Field * field = nullptr;
   field = mesh.createNodalField(uint_nodal_fields[field_name], group_name);
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 dumper::Field * HeatTransferModel::createNodalFieldReal(
     const std::string & field_name, const std::string & group_name,
     __attribute__((unused)) bool padding_flag) {
 
   std::map<std::string, Array<Real> *> real_nodal_fields;
   real_nodal_fields["temperature"] = temperature;
   real_nodal_fields["temperature_rate"] = temperature_rate;
   real_nodal_fields["external_heat_rate"] = external_heat_rate;
   real_nodal_fields["internal_heat_rate"] = internal_heat_rate;
   real_nodal_fields["capacity_lumped"] = capacity_lumped;
   real_nodal_fields["increment"] = increment;
 
   dumper::Field * field =
       mesh.createNodalField(real_nodal_fields[field_name], group_name);
 
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 dumper::Field * HeatTransferModel::createElementalField(
     const std::string & field_name, const std::string & group_name,
     __attribute__((unused)) bool padding_flag,
     __attribute__((unused)) const UInt & spatial_dimension,
     const ElementKind & element_kind) {
 
   dumper::Field * field = nullptr;
 
   if (field_name == "partitions")
     field = mesh.createElementalField<UInt, dumper::ElementPartitionField>(
         mesh.getConnectivities(), group_name, this->spatial_dimension,
         element_kind);
   else if (field_name == "temperature_gradient") {
     ElementTypeMap<UInt> nb_data_per_elem =
         this->mesh.getNbDataPerElem(temperature_gradient, element_kind);
 
     field = mesh.createElementalField<Real, dumper::InternalMaterialField>(
         temperature_gradient, group_name, this->spatial_dimension, element_kind,
         nb_data_per_elem);
   } else if (field_name == "conductivity") {
     ElementTypeMap<UInt> nb_data_per_elem =
         this->mesh.getNbDataPerElem(conductivity_on_qpoints, element_kind);
 
     field = mesh.createElementalField<Real, dumper::InternalMaterialField>(
         conductivity_on_qpoints, group_name, this->spatial_dimension,
         element_kind, nb_data_per_elem);
   }
 
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 #else
 /* -------------------------------------------------------------------------- */
 dumper::Field * HeatTransferModel::createElementalField(
     __attribute__((unused)) const std::string & field_name,
     __attribute__((unused)) const std::string & group_name,
     __attribute__((unused)) bool padding_flag,
     __attribute__((unused)) const ElementKind & element_kind) {
   return nullptr;
 }
 
 /* -------------------------------------------------------------------------- */
 dumper::Field * HeatTransferModel::createNodalFieldBool(
     __attribute__((unused)) const std::string & field_name,
     __attribute__((unused)) const std::string & group_name,
     __attribute__((unused)) bool padding_flag) {
   return nullptr;
 }
 
 /* -------------------------------------------------------------------------- */
 dumper::Field * HeatTransferModel::createNodalFieldReal(
     __attribute__((unused)) const std::string & field_name,
     __attribute__((unused)) const std::string & group_name,
     __attribute__((unused)) bool padding_flag) {
   return nullptr;
 }
 #endif
 
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::dump(const std::string & dumper_name) {
   mesh.dump(dumper_name);
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::dump(const std::string & dumper_name, UInt step) {
   mesh.dump(dumper_name, step);
 }
 
 /* ------------------------------------------------------------------------- */
 void HeatTransferModel::dump(const std::string & dumper_name, Real time,
                              UInt step) {
   mesh.dump(dumper_name, time, step);
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::dump() { mesh.dump(); }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::dump(UInt step) { mesh.dump(step); }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::dump(Real time, UInt step) { mesh.dump(time, step); }
 
 /* -------------------------------------------------------------------------- */
 inline UInt HeatTransferModel::getNbData(const Array<UInt> & indexes,
                                          const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
   UInt nb_nodes = indexes.size();
 
   switch (tag) {
   case _gst_htm_capacity:
   case _gst_htm_temperature: {
     size += nb_nodes * sizeof(Real);
     break;
   }
   default: {
-    AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
+    AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   AKANTU_DEBUG_OUT();
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void HeatTransferModel::packData(CommunicationBuffer & buffer,
                                         const Array<UInt> & indexes,
                                         const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   for (auto index : indexes) {
     switch (tag) {
     case _gst_htm_capacity:
       buffer << (*capacity_lumped)(index);
       break;
     case _gst_htm_temperature: {
       buffer << (*temperature)(index);
       break;
     }
     default: {
-      AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
+      AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
     }
     }
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 inline void HeatTransferModel::unpackData(CommunicationBuffer & buffer,
                                           const Array<UInt> & indexes,
                                           const SynchronizationTag & tag) {
   AKANTU_DEBUG_IN();
 
   for (auto index : indexes) {
     switch (tag) {
     case _gst_htm_capacity: {
       buffer >> (*capacity_lumped)(index);
       break;
     }
     case _gst_htm_temperature: {
       buffer >> (*temperature)(index);
       break;
     }
     default: {
-      AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
+      AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
     }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt HeatTransferModel::getNbData(const Array<Element> & elements,
                                          const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
   UInt nb_nodes_per_element = 0;
   Array<Element>::const_iterator<Element> it = elements.begin();
   Array<Element>::const_iterator<Element> end = elements.end();
   for (; it != end; ++it) {
     const Element & el = *it;
     nb_nodes_per_element += Mesh::getNbNodesPerElement(el.type);
   }
 
   switch (tag) {
   case _gst_htm_capacity: {
     size += nb_nodes_per_element * sizeof(Real); // capacity vector
     break;
   }
   case _gst_htm_temperature: {
     size += nb_nodes_per_element * sizeof(Real); // temperature
     break;
   }
   case _gst_htm_gradient_temperature: {
     // temperature gradient
     size += getNbIntegrationPoints(elements) * spatial_dimension * sizeof(Real);
     size += nb_nodes_per_element * sizeof(Real); // nodal temperatures
     break;
   }
   default: {
-    AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
+    AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   AKANTU_DEBUG_OUT();
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void HeatTransferModel::packData(CommunicationBuffer & buffer,
                                         const Array<Element> & elements,
                                         const SynchronizationTag & tag) const {
   switch (tag) {
   case _gst_htm_capacity: {
     packNodalDataHelper(*capacity_lumped, buffer, elements, mesh);
     break;
   }
   case _gst_htm_temperature: {
     packNodalDataHelper(*temperature, buffer, elements, mesh);
     break;
   }
   case _gst_htm_gradient_temperature: {
     packElementalDataHelper(temperature_gradient, buffer, elements, true,
                             getFEEngine());
     packNodalDataHelper(*temperature, buffer, elements, mesh);
     break;
   }
   default: {
-    AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
+    AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void HeatTransferModel::unpackData(CommunicationBuffer & buffer,
                                           const Array<Element> & elements,
                                           const SynchronizationTag & tag) {
   switch (tag) {
   case _gst_htm_capacity: {
     unpackNodalDataHelper(*capacity_lumped, buffer, elements, mesh);
     break;
   }
   case _gst_htm_temperature: {
     unpackNodalDataHelper(*temperature, buffer, elements, mesh);
     break;
   }
   case _gst_htm_gradient_temperature: {
     unpackElementalDataHelper(temperature_gradient, buffer, elements, true,
                               getFEEngine());
     unpackNodalDataHelper(*temperature, buffer, elements, mesh);
 
     break;
   }
   default: {
-    AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
+    AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 } // akantu
diff --git a/src/model/model.hh b/src/model/model.hh
index 2011bd11b..f79ade1eb 100644
--- a/src/model/model.hh
+++ b/src/model/model.hh
@@ -1,377 +1,377 @@
 /**
  * @file   model.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri Oct 16 2015
  *
  * @brief  Interface of a model
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "aka_common.hh"
 #include "aka_memory.hh"
 #include "aka_named_argument.hh"
 #include "fe_engine.hh"
 #include "mesh.hh"
 #include "model_options.hh"
 #include "model_solver.hh"
 /* -------------------------------------------------------------------------- */
 #include <typeindex>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MODEL_HH__
 #define __AKANTU_MODEL_HH__
 
 namespace akantu {
 class SynchronizerRegistry;
 class Parser;
 class DumperIOHelper;
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
 class Model : public Memory, public ModelSolver, public MeshEventHandler {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   Model(Mesh & mesh, const ModelType & type,
         UInt spatial_dimension = _all_dimensions, const ID & id = "model",
         const MemoryID & memory_id = 0);
 
   ~Model() override;
 
   using FEEngineMap = std::map<std::string, std::unique_ptr<FEEngine>>;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 protected:
   virtual void initFullImpl(const ModelOptions & options);
 
 public:
 
 #ifndef SWIG
 
   template <typename... pack>
   std::enable_if_t<are_named_argument<pack...>::value>
   initFull(pack &&... _pack) {
     switch (this->model_type) {
 #ifdef AKANTU_SOLID_MECHANICS
     case ModelType::_solid_mechanics_model:
       this->initFullImpl(SolidMechanicsModelOptions{
           use_named_args, std::forward<decltype(_pack)>(_pack)...});
       break;
 #endif
 #ifdef AKANTU_COHESIVE_ELEMENT
     case ModelType::_solid_mechanics_model_cohesive:
       this->initFullImpl(SolidMechanicsModelCohesiveOptions{
           use_named_args, std::forward<decltype(_pack)>(_pack)...});
       break;
 #endif
 #ifdef AKANTU_HEAT_TRANSFER
     case ModelType::_heat_transfer_model:
       this->initFullImpl(HeatTransferModelOptions{
           use_named_args, std::forward<decltype(_pack)>(_pack)...});
       break;
 #endif
 #ifdef AKANTU_EMBEDDED
     case ModelType::_embedded_model:
       this->initFullImpl(EmbeddedInterfaceModelOptions{
           use_named_args, std::forward<decltype(_pack)>(_pack)...});
       break;
 #endif
     default:
       this->initFullImpl(ModelOptions{use_named_args,
                                       std::forward<decltype(_pack)>(_pack)...});
     }
   }
 
   template <typename... pack>
   std::enable_if_t<not are_named_argument<pack...>::value>
   initFull(pack &&... _pack) {
     this->initFullImpl(std::forward<decltype(_pack)>(_pack)...);
   }
 #endif
 
   /// initialize a new solver if needed
   void initNewSolver(const AnalysisMethod & method);
 
 protected:
   /// get some default values for derived classes
   virtual std::tuple<ID, TimeStepSolverType>
   getDefaultSolverID(const AnalysisMethod & method) = 0;
 
   virtual void initModel() = 0;
 
   virtual void initFEEngineBoundary();
 
   // /// change local equation number so that PBC is assembled properly
   // void changeLocalEquationNumberForPBC(std::map<UInt, UInt> & pbc_pair,
   //                                      UInt dimension);
   /// function to print the containt of the class
   void printself(std::ostream &, int = 0) const override{};
 
   // /// initialize the model for PBC
   // void setPBC(UInt x, UInt y, UInt z);
   // void setPBC(SurfacePairList & surface_pairs);
 public:
   virtual void initPBC();
 
   /// set the parser to use
   // void setParser(Parser & parser);
 
   /* ------------------------------------------------------------------------ */
   /* Access to the dumpable interface of the boundaries                       */
   /* ------------------------------------------------------------------------ */
   /// Dump the data for a given group
   void dumpGroup(const std::string & group_name);
   void dumpGroup(const std::string & group_name,
                  const std::string & dumper_name);
   /// Dump the data for all boundaries
   void dumpGroup();
   /// Set the directory for a given group
   void setGroupDirectory(const std::string & directory,
                          const std::string & group_name);
   /// Set the directory for all boundaries
   void setGroupDirectory(const std::string & directory);
   /// Set the base name for a given group
   void setGroupBaseName(const std::string & basename,
                         const std::string & group_name);
   /// Get the internal dumper of a given group
   DumperIOHelper & getGroupDumper(const std::string & group_name);
 
   /* ------------------------------------------------------------------------ */
   /* Function for non local capabilities                                      */
   /* ------------------------------------------------------------------------ */
   virtual void updateDataForNonLocalCriterion(__attribute__((unused))
                                               ElementTypeMapReal & criterion) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
 protected:
   template <typename T>
   void allocNodalField(Array<T> *& array, UInt nb_component, const ID & name);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors */
   /* ------------------------------------------------------------------------ */
 public:
   /// get id of model
   AKANTU_GET_MACRO(ID, id, const ID)
 
   /// get the number of surfaces
   AKANTU_GET_MACRO(Mesh, mesh, Mesh &)
 
   /// synchronize the boundary in case of parallel run
   virtual void synchronizeBoundaries(){};
 
   /// return the fem object associated with a provided name
   inline FEEngine & getFEEngine(const ID & name = "") const;
 
   /// return the fem boundary object associated with a provided name
   virtual FEEngine & getFEEngineBoundary(const ID & name = "");
 
   /// register a fem object associated with name
   template <typename FEEngineClass>
   inline void registerFEEngineObject(const std::string & name, Mesh & mesh,
                                      UInt spatial_dimension);
   /// unregister a fem object associated with name
   inline void unRegisterFEEngineObject(const std::string & name);
 
   /// return the synchronizer registry
   SynchronizerRegistry & getSynchronizerRegistry();
 
   /// return the fem object associated with a provided name
   template <typename FEEngineClass>
   inline FEEngineClass & getFEEngineClass(std::string name = "") const;
 
   /// return the fem boundary object associated with a provided name
   template <typename FEEngineClass>
   inline FEEngineClass & getFEEngineClassBoundary(std::string name = "");
 
   /// get the pbc pairs
   std::map<UInt, UInt> & getPBCPairs() { return pbc_pair; };
 
   /// returns if node is slave in pbc
   inline bool isPBCSlaveNode(const UInt) const {
     throw;
     return false; /* TODO repair PBC*/
   }
 
   /// returns the array of pbc slave nodes (boolean information)
   AKANTU_GET_MACRO(IsPBCSlaveNode, is_pbc_slave_node, const Array<bool> &)
 
   /// Get the type of analysis method used
   AKANTU_GET_MACRO(AnalysisMethod, method, AnalysisMethod);
 
   /* ------------------------------------------------------------------------ */
   /* Pack and unpack helper functions                                         */
   /* ------------------------------------------------------------------------ */
 public:
   inline UInt getNbIntegrationPoints(const Array<Element> & elements,
                                      const ID & fem_id = ID()) const;
 
   /* ------------------------------------------------------------------------ */
   /* Dumpable interface (kept for convenience) and dumper relative functions  */
   /* ------------------------------------------------------------------------ */
   void setTextModeToDumper();
 
   virtual void addDumpGroupFieldToDumper(const std::string & field_id,
                                          dumper::Field * field,
                                          DumperIOHelper & dumper);
 
   virtual void addDumpField(const std::string & field_id);
 
   virtual void addDumpFieldVector(const std::string & field_id);
 
   virtual void addDumpFieldToDumper(const std::string & dumper_name,
                                     const std::string & field_id);
 
   virtual void addDumpFieldVectorToDumper(const std::string & dumper_name,
                                           const std::string & field_id);
 
   virtual void addDumpFieldTensorToDumper(const std::string & dumper_name,
                                           const std::string & field_id);
 
   virtual void addDumpFieldTensor(const std::string & field_id);
 
   virtual void setBaseName(const std::string & basename);
 
   virtual void setBaseNameToDumper(const std::string & dumper_name,
                                    const std::string & basename);
 
   virtual void addDumpGroupField(const std::string & field_id,
                                  const std::string & group_name);
 
   virtual void addDumpGroupFieldToDumper(const std::string & dumper_name,
                                          const std::string & field_id,
                                          const std::string & group_name,
                                          const ElementKind & element_kind,
                                          bool padding_flag);
 
   virtual void addDumpGroupFieldToDumper(const std::string & dumper_name,
                                          const std::string & field_id,
                                          const std::string & group_name,
                                          UInt spatial_dimension,
                                          const ElementKind & element_kind,
                                          bool padding_flag);
 
   virtual void removeDumpGroupField(const std::string & field_id,
                                     const std::string & group_name);
   virtual void removeDumpGroupFieldFromDumper(const std::string & dumper_name,
                                               const std::string & field_id,
                                               const std::string & group_name);
 
   virtual void addDumpGroupFieldVector(const std::string & field_id,
                                        const std::string & group_name);
 
   virtual void addDumpGroupFieldVectorToDumper(const std::string & dumper_name,
                                                const std::string & field_id,
                                                const std::string & group_name);
 
   virtual dumper::Field *
   createNodalFieldReal(__attribute__((unused)) const std::string & field_name,
                        __attribute__((unused)) const std::string & group_name,
                        __attribute__((unused)) bool padding_flag) {
     return nullptr;
   }
 
   virtual dumper::Field *
   createNodalFieldUInt(__attribute__((unused)) const std::string & field_name,
                        __attribute__((unused)) const std::string & group_name,
                        __attribute__((unused)) bool padding_flag) {
     return nullptr;
   }
 
   virtual dumper::Field *
   createNodalFieldBool(__attribute__((unused)) const std::string & field_name,
                        __attribute__((unused)) const std::string & group_name,
                        __attribute__((unused)) bool padding_flag) {
     return nullptr;
   }
 
   virtual dumper::Field *
   createElementalField(__attribute__((unused)) const std::string & field_name,
                        __attribute__((unused)) const std::string & group_name,
                        __attribute__((unused)) bool padding_flag,
                        __attribute__((unused)) const UInt & spatial_dimension,
                        __attribute__((unused)) const ElementKind & kind) {
     return nullptr;
   }
 
   void setDirectory(const std::string & directory);
   void setDirectoryToDumper(const std::string & dumper_name,
                             const std::string & directory);
 
   virtual void dump();
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   friend std::ostream & operator<<(std::ostream &, const Model &);
 
   /// analysis method check the list in akantu::AnalysisMethod
   AnalysisMethod method;
 
   /// Mesh
   Mesh & mesh;
 
   /// Spatial dimension of the problem
   UInt spatial_dimension;
 
   /// the main fem object present in all  models
   FEEngineMap fems;
 
   /// the fem object present in all  models for boundaries
   FEEngineMap fems_boundary;
 
   /// default fem object
   std::string default_fem;
 
   /// pbc pairs
   std::map<UInt, UInt> pbc_pair;
 
   /// flag per node to know is pbc slave
   Array<bool> is_pbc_slave_node;
 
   /// parser to the pointer to use
   Parser & parser;
 };
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream, const Model & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #include "model_inline_impl.cc"
 
 #endif /* __AKANTU_MODEL_HH__ */
diff --git a/src/model/non_linear_solver_callback.hh b/src/model/non_linear_solver_callback.hh
index 9c1950aa4..4b9953d8c 100644
--- a/src/model/non_linear_solver_callback.hh
+++ b/src/model/non_linear_solver_callback.hh
@@ -1,61 +1,61 @@
 /**
  * @file   non_linear_solver_callback.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Mon Sep 28 18:48:21 2015
  *
  * @brief  Interface to implement for the non linear solver to work
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_NON_LINEAR_SOLVER_CALLBACK_HH__
 #define __AKANTU_NON_LINEAR_SOLVER_CALLBACK_HH__
 
 namespace akantu {
 
 class NonLinearSolverCallback {
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// callback to assemble the Jacobian Matrix
-  virtual void assembleJacobian() { AKANTU_DEBUG_TO_IMPLEMENT(); }
+  virtual void assembleJacobian() { AKANTU_TO_IMPLEMENT(); }
 
   /// callback to assemble the residual (rhs)
-  virtual void assembleResidual() { AKANTU_DEBUG_TO_IMPLEMENT(); }
+  virtual void assembleResidual() { AKANTU_TO_IMPLEMENT(); }
 
   /* ------------------------------------------------------------------------ */
   /* Dynamic simulations part                                                 */
   /* ------------------------------------------------------------------------ */
   /// callback for the predictor (in case of dynamic simulation)
-  virtual void predictor() { AKANTU_DEBUG_TO_IMPLEMENT(); }
+  virtual void predictor() { AKANTU_TO_IMPLEMENT(); }
 
   /// callback for the corrector (in case of dynamic simulation)
-  virtual void corrector() { AKANTU_DEBUG_TO_IMPLEMENT(); }
+  virtual void corrector() { AKANTU_TO_IMPLEMENT(); }
 };
 
 } // akantu
 
 
 #endif /* __AKANTU_NON_LINEAR_SOLVER_CALLBACK_HH__ */
diff --git a/src/model/solid_mechanics/material.cc b/src/model/solid_mechanics/material.cc
index 16058656f..0e600c202 100644
--- a/src/model/solid_mechanics/material.cc
+++ b/src/model/solid_mechanics/material.cc
@@ -1,1554 +1,1554 @@
 /**
  * @file   material.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue Jul 27 2010
  * @date last modification: Tue Nov 24 2015
  *
  * @brief  Implementation of the common part of the material class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "material.hh"
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Material::Material(SolidMechanicsModel & model, const ID & id)
     : Memory(id, model.getMemoryID()), Parsable(ParserType::_material, id),
       is_init(false), fem(model.getFEEngine()), finite_deformation(false),
       name(""), model(model),
       spatial_dimension(this->model.getSpatialDimension()),
       element_filter("element_filter", id, this->memory_id),
       stress("stress", *this), eigengradu("eigen_grad_u", *this),
       gradu("grad_u", *this), green_strain("green_strain", *this),
       piola_kirchhoff_2("piola_kirchhoff_2", *this),
       potential_energy("potential_energy", *this), is_non_local(false),
       use_previous_stress(false), use_previous_gradu(false),
       interpolation_inverse_coordinates("interpolation inverse coordinates",
                                         *this),
       interpolation_points_matrices("interpolation points matrices", *this) {
   AKANTU_DEBUG_IN();
 
   /// for each connectivity types allocate the element filer array of the
   /// material
   element_filter.initialize(model.getMesh(),
                             _spatial_dimension = spatial_dimension);
   // model.getMesh().initElementTypeMapArray(element_filter, 1,
   // spatial_dimension,
   //                                         false, _ek_regular);
 
   this->initialize();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Material::Material(SolidMechanicsModel & model, UInt dim, const Mesh & mesh,
                    FEEngine & fe_engine, const ID & id)
     : Memory(id, model.getMemoryID()), Parsable(ParserType::_material, id),
       is_init(false), fem(fe_engine), finite_deformation(false),
       name(""), model(model), spatial_dimension(dim),
       element_filter("element_filter", id, this->memory_id),
       stress("stress", *this, dim, fe_engine, this->element_filter),
       eigengradu("eigen_grad_u", *this, dim, fe_engine, this->element_filter),
       gradu("gradu", *this, dim, fe_engine, this->element_filter),
       green_strain("green_strain", *this, dim, fe_engine, this->element_filter),
       piola_kirchhoff_2("piola_kirchhoff_2", *this, dim, fe_engine,
                         this->element_filter),
       potential_energy("potential_energy", *this, dim, fe_engine,
                        this->element_filter),
       is_non_local(false), use_previous_stress(false),
       use_previous_gradu(false),
       interpolation_inverse_coordinates("interpolation inverse_coordinates",
                                         *this, dim, fe_engine,
                                         this->element_filter),
       interpolation_points_matrices("interpolation points matrices", *this, dim,
                                     fe_engine, this->element_filter) {
 
   AKANTU_DEBUG_IN();
   element_filter.initialize(mesh, _spatial_dimension = spatial_dimension);
   // mesh.initElementTypeMapArray(element_filter, 1, spatial_dimension, false,
   //                              _ek_regular);
 
   this->initialize();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Material::~Material() = default;
 
 /* -------------------------------------------------------------------------- */
 void Material::initialize() {
   registerParam("rho", rho, Real(0.), _pat_parsable | _pat_modifiable,
                 "Density");
   registerParam("name", name, std::string(), _pat_parsable | _pat_readable);
   registerParam("finite_deformation", finite_deformation, false,
                 _pat_parsable | _pat_readable, "Is finite deformation");
   registerParam("inelastic_deformation", inelastic_deformation, false,
                 _pat_internal, "Is inelastic deformation");
 
   /// allocate gradu stress for local elements
   eigengradu.initialize(spatial_dimension * spatial_dimension);
   gradu.initialize(spatial_dimension * spatial_dimension);
   stress.initialize(spatial_dimension * spatial_dimension);
 
   potential_energy.initialize(1);
 
   this->model.registerEventHandler(*this);
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::initMaterial() {
   AKANTU_DEBUG_IN();
 
   if (finite_deformation) {
     this->piola_kirchhoff_2.initialize(spatial_dimension * spatial_dimension);
     if (use_previous_stress)
       this->piola_kirchhoff_2.initializeHistory();
     this->green_strain.initialize(spatial_dimension * spatial_dimension);
   }
 
   if (use_previous_stress)
     this->stress.initializeHistory();
   if (use_previous_gradu)
     this->gradu.initializeHistory();
 
   for (auto it = internal_vectors_real.begin();
        it != internal_vectors_real.end(); ++it)
     it->second->resize();
 
   for (auto it = internal_vectors_uint.begin();
        it != internal_vectors_uint.end(); ++it)
     it->second->resize();
 
   for (auto it = internal_vectors_bool.begin();
        it != internal_vectors_bool.end(); ++it)
     it->second->resize();
 
   is_init = true;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::savePreviousState() {
   AKANTU_DEBUG_IN();
 
   for (auto it = internal_vectors_real.begin();
        it != internal_vectors_real.end(); ++it) {
     if (it->second->hasHistory())
       it->second->saveCurrentValues();
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Compute  the  residual  by  assembling  @f$\int_{e}  \sigma_e  \frac{\partial
  * \varphi}{\partial X} dX @f$
  *
  * @param[in] displacements nodes displacements
  * @param[in] ghost_type compute the residual for _ghost or _not_ghost element
  */
 // void Material::updateResidual(GhostType ghost_type) {
 //   AKANTU_DEBUG_IN();
 
 //   computeAllStresses(ghost_type);
 //   assembleResidual(ghost_type);
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 void Material::assembleInternalForces(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   if (!finite_deformation) {
 
     auto & internal_force = const_cast<Array<Real> &>(model.getInternalForce());
 
     // Mesh & mesh = fem.getMesh();
     for (auto && type :
          element_filter.elementTypes(spatial_dimension, ghost_type)) {
       Array<UInt> & elem_filter = element_filter(type, ghost_type);
       UInt nb_element = elem_filter.size();
 
       if (nb_element == 0)
         continue;
 
       const Array<Real> & shapes_derivatives =
           fem.getShapesDerivatives(type, ghost_type);
 
       UInt size_of_shapes_derivatives = shapes_derivatives.getNbComponent();
       UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
       UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
       /// compute @f$\sigma \frac{\partial \varphi}{\partial X}@f$ by
       /// @f$\mathbf{B}^t \mathbf{\sigma}_q@f$
       Array<Real> * sigma_dphi_dx =
           new Array<Real>(nb_element * nb_quadrature_points,
                           size_of_shapes_derivatives, "sigma_x_dphi_/_dX");
 
       fem.computeBtD(stress(type, ghost_type), *sigma_dphi_dx, type, ghost_type,
                      elem_filter);
 
       // Array<Real> * shapesd_filtered =
       //     new Array<Real>(0, size_of_shapes_derivatives, "filtered shapesd");
 
       // FEEngine::filterElementalData(mesh, shapes_derivatives,
       // *shapesd_filtered,
       //                               *it, ghost_type, elem_filter);
 
       // Array<Real> & stress_vect = this->stress(*it, ghost_type);
 
       // Array<Real>::matrix_iterator sigma =
       //     stress_vect.begin(spatial_dimension, spatial_dimension);
       // Array<Real>::matrix_iterator B =
       //     shapesd_filtered->begin(spatial_dimension, nb_nodes_per_element);
       // Array<Real>::matrix_iterator Bt_sigma_it =
       //     sigma_dphi_dx->begin(spatial_dimension, nb_nodes_per_element);
 
       // for (UInt q = 0; q < nb_element * nb_quadrature_points;
       //      ++q, ++sigma, ++B, ++Bt_sigma_it)
       //   Bt_sigma_it->mul<false, false>(*sigma, *B);
 
       // delete shapesd_filtered;
 
       /**
        * compute @f$\int \sigma  * \frac{\partial \varphi}{\partial X}dX@f$ by
        * @f$ \sum_q \mathbf{B}^t
        * \mathbf{\sigma}_q \overline w_q J_q@f$
        */
       Array<Real> * int_sigma_dphi_dx =
           new Array<Real>(nb_element, nb_nodes_per_element * spatial_dimension,
                           "int_sigma_x_dphi_/_dX");
 
       fem.integrate(*sigma_dphi_dx, *int_sigma_dphi_dx,
                     size_of_shapes_derivatives, type, ghost_type, elem_filter);
       delete sigma_dphi_dx;
 
       /// assemble
       model.getDOFManager().assembleElementalArrayLocalArray(
           *int_sigma_dphi_dx, internal_force, type, ghost_type, -1,
           elem_filter);
       delete int_sigma_dphi_dx;
     }
   } else {
     switch (spatial_dimension) {
     case 1:
       this->assembleInternalForces<1>(ghost_type);
       break;
     case 2:
       this->assembleInternalForces<2>(ghost_type);
       break;
     case 3:
       this->assembleInternalForces<3>(ghost_type);
       break;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Compute  the  stress from the gradu
  *
  * @param[in] current_position nodes postition + displacements
  * @param[in] ghost_type compute the residual for _ghost or _not_ghost element
  */
 void Material::computeAllStresses(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   for (const auto & type :
        element_filter.elementTypes(spatial_dimension, ghost_type)) {
     Array<UInt> & elem_filter = element_filter(type, ghost_type);
 
     if (elem_filter.size() == 0)
       continue;
     Array<Real> & gradu_vect = gradu(type, ghost_type);
 
     /// compute @f$\nabla u@f$
     fem.gradientOnIntegrationPoints(model.getDisplacement(), gradu_vect,
                                     spatial_dimension, type, ghost_type,
                                     elem_filter);
 
     gradu_vect -= eigengradu(type, ghost_type);
 
     /// compute @f$\mathbf{\sigma}_q@f$ from @f$\nabla u@f$
     computeStress(type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::computeAllCauchyStresses(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(finite_deformation, "The Cauchy stress can only be "
                                           "computed if you are working in "
                                           "finite deformation.");
 
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     switch (spatial_dimension) {
     case 1:
       this->computeCauchyStress<1>(type, ghost_type);
       break;
     case 2:
       this->computeCauchyStress<2>(type, ghost_type);
       break;
     case 3:
       this->computeCauchyStress<3>(type, ghost_type);
       break;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::computeCauchyStress(ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Array<Real>::matrix_iterator gradu_it =
       this->gradu(el_type, ghost_type).begin(dim, dim);
 
   Array<Real>::matrix_iterator gradu_end =
       this->gradu(el_type, ghost_type).end(dim, dim);
 
   Array<Real>::matrix_iterator piola_it =
       this->piola_kirchhoff_2(el_type, ghost_type).begin(dim, dim);
 
   Array<Real>::matrix_iterator stress_it =
       this->stress(el_type, ghost_type).begin(dim, dim);
 
   Matrix<Real> F_tensor(dim, dim);
 
   for (; gradu_it != gradu_end; ++gradu_it, ++piola_it, ++stress_it) {
     Matrix<Real> & grad_u = *gradu_it;
     Matrix<Real> & piola = *piola_it;
     Matrix<Real> & sigma = *stress_it;
 
     gradUToF<dim>(grad_u, F_tensor);
     this->computeCauchyStressOnQuad<dim>(F_tensor, piola, sigma);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::setToSteadyState(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   const Array<Real> & displacement = model.getDisplacement();
 
   // resizeInternalArray(gradu);
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     Array<UInt> & elem_filter = element_filter(type, ghost_type);
     Array<Real> & gradu_vect = gradu(type, ghost_type);
 
     /// compute @f$\nabla u@f$
     fem.gradientOnIntegrationPoints(displacement, gradu_vect, spatial_dimension,
                                     type, ghost_type, elem_filter);
 
     setToSteadyState(type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Compute  the stiffness  matrix by  assembling @f$\int_{\omega}  B^t  \times D
  * \times B d\omega @f$
  *
  * @param[in] current_position nodes postition + displacements
  * @param[in] ghost_type compute the residual for _ghost or _not_ghost element
  */
 void Material::assembleStiffnessMatrix(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     if (finite_deformation) {
       switch (spatial_dimension) {
       case 1: {
         assembleStiffnessMatrixNL<1>(type, ghost_type);
         assembleStiffnessMatrixL2<1>(type, ghost_type);
         break;
       }
       case 2: {
         assembleStiffnessMatrixNL<2>(type, ghost_type);
         assembleStiffnessMatrixL2<2>(type, ghost_type);
         break;
       }
       case 3: {
         assembleStiffnessMatrixNL<3>(type, ghost_type);
         assembleStiffnessMatrixL2<3>(type, ghost_type);
         break;
       }
       }
     } else {
       switch (spatial_dimension) {
       case 1: {
         assembleStiffnessMatrix<1>(type, ghost_type);
         break;
       }
       case 2: {
         assembleStiffnessMatrix<2>(type, ghost_type);
         break;
       }
       case 3: {
         assembleStiffnessMatrix<3>(type, ghost_type);
         break;
       }
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::assembleStiffnessMatrix(const ElementType & type,
                                        GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Array<UInt> & elem_filter = element_filter(type, ghost_type);
   if (elem_filter.size() == 0) {
     AKANTU_DEBUG_OUT();
     return;
   }
 
   // const Array<Real> & shapes_derivatives =
   //     fem.getShapesDerivatives(type, ghost_type);
 
   Array<Real> & gradu_vect = gradu(type, ghost_type);
 
   UInt nb_element = elem_filter.size();
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
   gradu_vect.resize(nb_quadrature_points * nb_element);
 
   fem.gradientOnIntegrationPoints(model.getDisplacement(), gradu_vect, dim,
                                   type, ghost_type, elem_filter);
 
   UInt tangent_size = getTangentStiffnessVoigtSize(dim);
 
   Array<Real> * tangent_stiffness_matrix =
       new Array<Real>(nb_element * nb_quadrature_points,
                       tangent_size * tangent_size, "tangent_stiffness_matrix");
 
   tangent_stiffness_matrix->clear();
 
   computeTangentModuli(type, *tangent_stiffness_matrix, ghost_type);
 
   // Array<Real> * shapesd_filtered = new Array<Real>(
   //     nb_element, dim * nb_nodes_per_element, "filtered shapesd");
 
   // fem.filterElementalData(fem.getMesh(), shapes_derivatives,
   //                         *shapesd_filtered, type, ghost_type,
   //                         elem_filter);
 
   /// compute @f$\mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   UInt bt_d_b_size = dim * nb_nodes_per_element;
 
   Array<Real> * bt_d_b = new Array<Real>(nb_element * nb_quadrature_points,
                                          bt_d_b_size * bt_d_b_size, "B^t*D*B");
 
   fem.computeBtDB(*tangent_stiffness_matrix, *bt_d_b, 4, type, ghost_type, elem_filter);
   // Matrix<Real> B(tangent_size, dim * nb_nodes_per_element);
   // Matrix<Real> Bt_D(dim * nb_nodes_per_element, tangent_size);
 
   // Array<Real>::matrix_iterator shapes_derivatives_filtered_it =
   //     shapesd_filtered->begin(dim, nb_nodes_per_element);
 
   // Array<Real>::matrix_iterator Bt_D_B_it =
   //     bt_d_b->begin(dim * nb_nodes_per_element, dim * nb_nodes_per_element);
 
   // Array<Real>::matrix_iterator D_it =
   //     tangent_stiffness_matrix->begin(tangent_size, tangent_size);
 
   // Array<Real>::matrix_iterator D_end =
   //     tangent_stiffness_matrix->end(tangent_size, tangent_size);
 
   // for (; D_it != D_end; ++D_it, ++Bt_D_B_it,
   // ++shapes_derivatives_filtered_it) {
   //   Matrix<Real> & D = *D_it;
   //   Matrix<Real> & Bt_D_B = *Bt_D_B_it;
 
   //   VoigtHelper<dim>::transferBMatrixToSymVoigtBMatrix(
   //       *shapes_derivatives_filtered_it, B, nb_nodes_per_element);
   //   Bt_D.mul<true, false>(B, D);
   //   Bt_D_B.mul<false, false>(Bt_D, B);
   // }
 
   delete tangent_stiffness_matrix;
   // delete shapesd_filtered;
 
   /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   Array<Real> * K_e =
       new Array<Real>(nb_element, bt_d_b_size * bt_d_b_size, "K_e");
 
   fem.integrate(*bt_d_b, *K_e, bt_d_b_size * bt_d_b_size, type, ghost_type,
                 elem_filter);
 
   delete bt_d_b;
 
   model.getDOFManager().assembleElementalMatricesToMatrix(
       "K", "displacement", *K_e, type, ghost_type, _symmetric, elem_filter);
   delete K_e;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::assembleStiffnessMatrixNL(const ElementType & type,
                                          GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   const Array<Real> & shapes_derivatives =
       fem.getShapesDerivatives(type, ghost_type);
 
   Array<UInt> & elem_filter = element_filter(type, ghost_type);
   // Array<Real> & gradu_vect = delta_gradu(type, ghost_type);
 
   UInt nb_element = elem_filter.size();
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
   Array<Real> * shapes_derivatives_filtered = new Array<Real>(
       nb_element * nb_quadrature_points, dim * nb_nodes_per_element,
       "shapes derivatives filtered");
 
   fem.filterElementalData(fem.getMesh(), shapes_derivatives,
                           *shapes_derivatives_filtered, type, ghost_type,
                           elem_filter);
 
   /// compute @f$\mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   UInt bt_s_b_size = dim * nb_nodes_per_element;
 
   Array<Real> * bt_s_b = new Array<Real>(nb_element * nb_quadrature_points,
                                          bt_s_b_size * bt_s_b_size, "B^t*D*B");
 
   UInt piola_matrix_size = getCauchyStressMatrixSize(dim);
 
   Matrix<Real> B(piola_matrix_size, bt_s_b_size);
   Matrix<Real> Bt_S(bt_s_b_size, piola_matrix_size);
   Matrix<Real> S(piola_matrix_size, piola_matrix_size);
 
   auto shapes_derivatives_filtered_it = shapes_derivatives_filtered->begin(
       spatial_dimension, nb_nodes_per_element);
 
   auto Bt_S_B_it = bt_s_b->begin(bt_s_b_size, bt_s_b_size);
   auto Bt_S_B_end = bt_s_b->end(bt_s_b_size, bt_s_b_size);
   auto piola_it = piola_kirchhoff_2(type, ghost_type).begin(dim, dim);
 
   for (; Bt_S_B_it != Bt_S_B_end;
        ++Bt_S_B_it, ++shapes_derivatives_filtered_it, ++piola_it) {
     auto & Bt_S_B = *Bt_S_B_it;
     const auto & Piola_kirchhoff_matrix = *piola_it;
 
     setCauchyStressMatrix<dim>(Piola_kirchhoff_matrix, S);
     VoigtHelper<dim>::transferBMatrixToBNL(*shapes_derivatives_filtered_it, B,
                                            nb_nodes_per_element);
     Bt_S.template mul<true, false>(B, S);
     Bt_S_B.template mul<false, false>(Bt_S, B);
   }
 
   delete shapes_derivatives_filtered;
 
   /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   Array<Real> * K_e =
       new Array<Real>(nb_element, bt_s_b_size * bt_s_b_size, "K_e");
 
   fem.integrate(*bt_s_b, *K_e, bt_s_b_size * bt_s_b_size, type, ghost_type,
                 elem_filter);
 
   delete bt_s_b;
 
   model.getDOFManager().assembleElementalMatricesToMatrix(
       "K", "displacement", *K_e, type, ghost_type, _symmetric, elem_filter);
 
   delete K_e;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::assembleStiffnessMatrixL2(const ElementType & type,
                                          GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   const Array<Real> & shapes_derivatives =
       fem.getShapesDerivatives(type, ghost_type);
 
   Array<UInt> & elem_filter = element_filter(type, ghost_type);
   Array<Real> & gradu_vect = gradu(type, ghost_type);
 
   UInt nb_element = elem_filter.size();
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
   gradu_vect.resize(nb_quadrature_points * nb_element);
 
   fem.gradientOnIntegrationPoints(model.getDisplacement(), gradu_vect, dim,
                                   type, ghost_type, elem_filter);
 
   UInt tangent_size = getTangentStiffnessVoigtSize(dim);
 
   Array<Real> * tangent_stiffness_matrix =
       new Array<Real>(nb_element * nb_quadrature_points,
                       tangent_size * tangent_size, "tangent_stiffness_matrix");
 
   tangent_stiffness_matrix->clear();
 
   computeTangentModuli(type, *tangent_stiffness_matrix, ghost_type);
 
   Array<Real> * shapes_derivatives_filtered = new Array<Real>(
       nb_element * nb_quadrature_points, dim * nb_nodes_per_element,
       "shapes derivatives filtered");
   fem.filterElementalData(fem.getMesh(), shapes_derivatives,
                           *shapes_derivatives_filtered, type, ghost_type,
                           elem_filter);
 
   /// compute @f$\mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   UInt bt_d_b_size = dim * nb_nodes_per_element;
 
   Array<Real> * bt_d_b = new Array<Real>(nb_element * nb_quadrature_points,
                                          bt_d_b_size * bt_d_b_size, "B^t*D*B");
 
   Matrix<Real> B(tangent_size, dim * nb_nodes_per_element);
   Matrix<Real> B2(tangent_size, dim * nb_nodes_per_element);
   Matrix<Real> Bt_D(dim * nb_nodes_per_element, tangent_size);
 
   auto shapes_derivatives_filtered_it = shapes_derivatives_filtered->begin(
       spatial_dimension, nb_nodes_per_element);
 
   auto Bt_D_B_it = bt_d_b->begin(bt_d_b_size, bt_d_b_size);
   auto grad_u_it = gradu_vect.begin(dim, dim);
   auto D_it = tangent_stiffness_matrix->begin(tangent_size, tangent_size);
   auto D_end = tangent_stiffness_matrix->end(tangent_size, tangent_size);
 
   for (; D_it != D_end;
        ++D_it, ++Bt_D_B_it, ++shapes_derivatives_filtered_it, ++grad_u_it) {
     const auto & grad_u = *grad_u_it;
     const auto & D = *D_it;
     auto & Bt_D_B = *Bt_D_B_it;
 
     // transferBMatrixToBL1<dim > (*shapes_derivatives_filtered_it, B,
     // nb_nodes_per_element);
     VoigtHelper<dim>::transferBMatrixToSymVoigtBMatrix(
         *shapes_derivatives_filtered_it, B, nb_nodes_per_element);
     VoigtHelper<dim>::transferBMatrixToBL2(*shapes_derivatives_filtered_it,
                                            grad_u, B2, nb_nodes_per_element);
     B += B2;
     Bt_D.template mul<true, false>(B, D);
     Bt_D_B.template mul<false, false>(Bt_D, B);
   }
 
   delete tangent_stiffness_matrix;
   delete shapes_derivatives_filtered;
 
   /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   Array<Real> * K_e =
       new Array<Real>(nb_element, bt_d_b_size * bt_d_b_size, "K_e");
 
   fem.integrate(*bt_d_b, *K_e, bt_d_b_size * bt_d_b_size, type, ghost_type,
                 elem_filter);
 
   delete bt_d_b;
 
   model.getDOFManager().assembleElementalMatricesToMatrix(
       "K", "displacement", *K_e, type, ghost_type, _symmetric, elem_filter);
   delete K_e;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::assembleInternalForces(GhostType ghost_type) {
 
   AKANTU_DEBUG_IN();
 
   Array<Real> & internal_force = model.getInternalForce();
 
   Mesh & mesh = fem.getMesh();
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     const Array<Real> & shapes_derivatives =
         fem.getShapesDerivatives(type, ghost_type);
 
     Array<UInt> & elem_filter = element_filter(type, ghost_type);
     if (elem_filter.size() == 0)
       continue;
     UInt size_of_shapes_derivatives = shapes_derivatives.getNbComponent();
     UInt nb_element = elem_filter.size();
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
     UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
     Array<Real> * shapesd_filtered = new Array<Real>(
         nb_element, size_of_shapes_derivatives, "filtered shapesd");
 
     fem.filterElementalData(mesh, shapes_derivatives, *shapesd_filtered, type,
                             ghost_type, elem_filter);
 
     Array<Real>::matrix_iterator shapes_derivatives_filtered_it =
         shapesd_filtered->begin(dim, nb_nodes_per_element);
 
     // Set stress vectors
     UInt stress_size = getTangentStiffnessVoigtSize(dim);
 
     // Set matrices B and BNL*
     UInt bt_s_size = dim * nb_nodes_per_element;
 
     auto * bt_s =
         new Array<Real>(nb_element * nb_quadrature_points, bt_s_size, "B^t*S");
 
     auto grad_u_it = this->gradu(type, ghost_type).begin(dim, dim);
     auto grad_u_end = this->gradu(type, ghost_type).end(dim, dim);
     auto stress_it = this->piola_kirchhoff_2(type, ghost_type).begin(dim, dim);
     shapes_derivatives_filtered_it =
         shapesd_filtered->begin(dim, nb_nodes_per_element);
 
     Array<Real>::matrix_iterator bt_s_it = bt_s->begin(bt_s_size, 1);
 
     Matrix<Real> S_vect(stress_size, 1);
     Matrix<Real> B_tensor(stress_size, bt_s_size);
     Matrix<Real> B2_tensor(stress_size, bt_s_size);
 
     for (; grad_u_it != grad_u_end; ++grad_u_it, ++stress_it,
                                     ++shapes_derivatives_filtered_it,
                                     ++bt_s_it) {
       auto & grad_u = *grad_u_it;
       auto & r_it = *bt_s_it;
       auto & S_it = *stress_it;
 
       setCauchyStressArray<dim>(S_it, S_vect);
       VoigtHelper<dim>::transferBMatrixToSymVoigtBMatrix(
           *shapes_derivatives_filtered_it, B_tensor, nb_nodes_per_element);
       VoigtHelper<dim>::transferBMatrixToBL2(*shapes_derivatives_filtered_it,
                                              grad_u, B2_tensor,
                                              nb_nodes_per_element);
 
       B_tensor += B2_tensor;
 
       r_it.template mul<true, false>(B_tensor, S_vect);
     }
 
     delete shapesd_filtered;
 
     /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
     Array<Real> * r_e = new Array<Real>(nb_element, bt_s_size, "r_e");
 
     fem.integrate(*bt_s, *r_e, bt_s_size, type, ghost_type, elem_filter);
 
     delete bt_s;
 
     model.getDOFManager().assembleElementalArrayLocalArray(
         *r_e, internal_force, type, ghost_type, -1., elem_filter);
     delete r_e;
   }
   AKANTU_DEBUG_OUT();
 }
 
 // /* -------------------------------------------------------------------------- */
 // void Material::computeAllStressesFromTangentModuli(GhostType ghost_type) {
 //   AKANTU_DEBUG_IN();
 
 //   UInt spatial_dimension = model.getSpatialDimension();
 
 //   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
 //     switch (spatial_dimension) {
 //     case 1: {
 //       computeAllStressesFromTangentModuli<1>(type, ghost_type);
 //       break;
 //     }
 //     case 2: {
 //       computeAllStressesFromTangentModuli<2>(type, ghost_type);
 //       break;
 //     }
 //     case 3: {
 //       computeAllStressesFromTangentModuli<3>(type, ghost_type);
 //       break;
 //     }
 //     }
 //   }
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 // /* -------------------------------------------------------------------------- */
 // template <UInt dim>
 // void Material::computeAllStressesFromTangentModuli(const ElementType & type,
 //                                                    GhostType ghost_type) {
 //   AKANTU_DEBUG_IN();
 
 //   const Array<Real> & shapes_derivatives =
 //       fem.getShapesDerivatives(type, ghost_type);
 //   Array<UInt> & elem_filter = element_filter(type, ghost_type);
 //   Array<Real> & gradu_vect = gradu(type, ghost_type);
 
 //   UInt nb_element = elem_filter.size();
 //   if (nb_element) {
 //     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 //     UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
 //     gradu_vect.resize(nb_quadrature_points * nb_element);
 
 //     Array<Real> & disp = model.getDisplacement();
 
 //     fem.gradientOnIntegrationPoints(disp, gradu_vect, dim, type, ghost_type,
 //                                     elem_filter);
 
 //     UInt tangent_moduli_size = getTangentStiffnessVoigtSize(dim);
 
 //     Array<Real> * tangent_moduli_tensors = new Array<Real>(
 //         nb_element * nb_quadrature_points,
 //         tangent_moduli_size * tangent_moduli_size, "tangent_moduli_tensors");
 
 //     tangent_moduli_tensors->clear();
 //     computeTangentModuli(type, *tangent_moduli_tensors, ghost_type);
 
 //     Array<Real> * shapesd_filtered = new Array<Real>(
 //         nb_element, dim * nb_nodes_per_element, "filtered shapesd");
 
 //     FEEngine::filterElementalData(fem.getMesh(), shapes_derivatives,
 //                                   *shapesd_filtered, type, ghost_type,
 //                                   elem_filter);
 
 //     Array<Real> filtered_u(nb_element,
 //                            nb_nodes_per_element * spatial_dimension);
 
 //     fem.extractNodalToElementField(fem.getMesh(), disp, filtered_u, type,
 //                                    ghost_type, elem_filter);
 
 //     /// compute @f$\mathbf{D} \mathbf{B} \mathbf{u}@f$
 //     auto shapes_derivatives_filtered_it =
 //         shapesd_filtered->begin(dim, nb_nodes_per_element);
 
 //     auto D_it =
 //         tangent_moduli_tensors->begin(tangent_moduli_size, tangent_moduli_size);
 //     auto sigma_it =
 //         stress(type, ghost_type).begin(spatial_dimension, spatial_dimension);
 //     auto u_it = filtered_u.begin(spatial_dimension * nb_nodes_per_element);
 
 //     Matrix<Real> B(tangent_moduli_size,
 //                    spatial_dimension * nb_nodes_per_element);
 //     Vector<Real> Bu(tangent_moduli_size);
 //     Vector<Real> DBu(tangent_moduli_size);
 
 //     for (UInt e = 0; e < nb_element; ++e, ++u_it) {
 //       for (UInt q = 0; q < nb_quadrature_points;
 //            ++q, ++D_it, ++shapes_derivatives_filtered_it, ++sigma_it) {
 //         const auto & u = *u_it;
 //         const auto & D = *D_it;
 //         auto & sigma = *sigma_it;
 
 //         VoigtHelper<dim>::transferBMatrixToSymVoigtBMatrix(
 //             *shapes_derivatives_filtered_it, B, nb_nodes_per_element);
 
 //         Bu.mul<false>(B, u);
 //         DBu.mul<false>(D, Bu);
 
 //         // Voigt notation to full symmetric tensor
 //         for (UInt i = 0; i < dim; ++i)
 //           sigma(i, i) = DBu(i);
 //         if (dim == 2) {
 //           sigma(0, 1) = sigma(1, 0) = DBu(2);
 //         } else if (dim == 3) {
 //           sigma(1, 2) = sigma(2, 1) = DBu(3);
 //           sigma(0, 2) = sigma(2, 0) = DBu(4);
 //           sigma(0, 1) = sigma(1, 0) = DBu(5);
 //         }
 //       }
 //     }
 //   }
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 void Material::computePotentialEnergyByElements() {
   AKANTU_DEBUG_IN();
 
   for (auto type : element_filter.elementTypes(spatial_dimension, _not_ghost)) {
     computePotentialEnergy(type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::computePotentialEnergy(ElementType, GhostType) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Real Material::getPotentialEnergy() {
   AKANTU_DEBUG_IN();
   Real epot = 0.;
 
   computePotentialEnergyByElements();
 
   /// integrate the potential energy for each type of elements
   for (auto type : element_filter.elementTypes(spatial_dimension, _not_ghost)) {
     epot += fem.integrate(potential_energy(type, _not_ghost), type, _not_ghost,
                           element_filter(type, _not_ghost));
   }
 
   AKANTU_DEBUG_OUT();
   return epot;
 }
 
 /* -------------------------------------------------------------------------- */
 Real Material::getPotentialEnergy(ElementType & type, UInt index) {
   AKANTU_DEBUG_IN();
   Real epot = 0.;
 
   Vector<Real> epot_on_quad_points(fem.getNbIntegrationPoints(type));
 
   computePotentialEnergyByElement(type, index, epot_on_quad_points);
 
   epot = fem.integrate(epot_on_quad_points, type, element_filter(type)(index));
 
   AKANTU_DEBUG_OUT();
   return epot;
 }
 
 /* -------------------------------------------------------------------------- */
 Real Material::getEnergy(const std::string & type) {
   AKANTU_DEBUG_IN();
   if (type == "potential")
     return getPotentialEnergy();
   AKANTU_DEBUG_OUT();
   return 0.;
 }
 
 /* -------------------------------------------------------------------------- */
 Real Material::getEnergy(const std::string & energy_id, ElementType type,
                          UInt index) {
   AKANTU_DEBUG_IN();
   if (energy_id == "potential")
     return getPotentialEnergy(type, index);
   AKANTU_DEBUG_OUT();
   return 0.;
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::initElementalFieldInterpolation(
     const ElementTypeMapArray<Real> & interpolation_points_coordinates) {
   AKANTU_DEBUG_IN();
 
   this->fem.initElementalFieldInterpolationFromIntegrationPoints(
       interpolation_points_coordinates, this->interpolation_points_matrices,
       this->interpolation_inverse_coordinates, &(this->element_filter));
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::interpolateStress(ElementTypeMapArray<Real> & result,
                                  const GhostType ghost_type) {
 
   this->fem.interpolateElementalFieldFromIntegrationPoints(
       this->stress, this->interpolation_points_matrices,
       this->interpolation_inverse_coordinates, result, ghost_type,
       &(this->element_filter));
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::interpolateStressOnFacets(
     ElementTypeMapArray<Real> & result,
     ElementTypeMapArray<Real> & by_elem_result, const GhostType ghost_type) {
 
   interpolateStress(by_elem_result, ghost_type);
 
   UInt stress_size = this->stress.getNbComponent();
 
   const Mesh & mesh = this->model.getMesh();
   const Mesh & mesh_facets = mesh.getMeshFacets();
 
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     Array<UInt> & elem_fil = element_filter(type, ghost_type);
     Array<Real> & by_elem_res = by_elem_result(type, ghost_type);
     UInt nb_element = elem_fil.size();
     UInt nb_element_full = this->model.getMesh().getNbElement(type, ghost_type);
     UInt nb_interpolation_points_per_elem =
         by_elem_res.size() / nb_element_full;
 
     const Array<Element> & facet_to_element =
         mesh_facets.getSubelementToElement(type, ghost_type);
     ElementType type_facet = Mesh::getFacetType(type);
     UInt nb_facet_per_elem = facet_to_element.getNbComponent();
     UInt nb_quad_per_facet =
         nb_interpolation_points_per_elem / nb_facet_per_elem;
     Element element_for_comparison{type, 0, ghost_type};
     const Array<std::vector<Element>> * element_to_facet = nullptr;
     GhostType current_ghost_type = _casper;
     Array<Real> * result_vec = nullptr;
 
     Array<Real>::const_matrix_iterator result_it =
         by_elem_res.begin_reinterpret(
             stress_size, nb_interpolation_points_per_elem, nb_element_full);
 
     for (UInt el = 0; el < nb_element; ++el) {
       UInt global_el = elem_fil(el);
       element_for_comparison.element = global_el;
       for (UInt f = 0; f < nb_facet_per_elem; ++f) {
 
         Element facet_elem = facet_to_element(global_el, f);
         UInt global_facet = facet_elem.element;
         if (facet_elem.ghost_type != current_ghost_type) {
           current_ghost_type = facet_elem.ghost_type;
           element_to_facet = &mesh_facets.getElementToSubelement(
               type_facet, current_ghost_type);
           result_vec = &result(type_facet, current_ghost_type);
         }
 
         bool is_second_element =
             (*element_to_facet)(global_facet)[0] != element_for_comparison;
 
         for (UInt q = 0; q < nb_quad_per_facet; ++q) {
           Vector<Real> result_local(result_vec->storage() +
                                         (global_facet * nb_quad_per_facet + q) *
                                             result_vec->getNbComponent() +
                                         is_second_element * stress_size,
                                     stress_size);
 
           const Matrix<Real> & result_tmp(result_it[global_el]);
           result_local = result_tmp(f * nb_quad_per_facet + q);
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 const Array<T> &
 Material::getArray(__attribute__((unused)) const ID & vect_id,
                    __attribute__((unused)) const ElementType & type,
                    __attribute__((unused)) const GhostType & ghost_type) const {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
   return NULL;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 Array<T> & Material::getArray(__attribute__((unused)) const ID & vect_id,
                               __attribute__((unused)) const ElementType & type,
                               __attribute__((unused))
                               const GhostType & ghost_type) {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
   return NULL;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 const Array<Real> & Material::getArray(const ID & vect_id,
                                        const ElementType & type,
                                        const GhostType & ghost_type) const {
   std::stringstream sstr;
   std::string ghost_id = "";
   if (ghost_type == _ghost)
     ghost_id = ":ghost";
   sstr << getID() << ":" << vect_id << ":" << type << ghost_id;
 
   ID fvect_id = sstr.str();
   try {
     return Memory::getArray<Real>(fvect_id);
   } catch (debug::Exception & e) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain a vector "
                                             << vect_id << "(" << fvect_id
                                             << ") [" << e << "]");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 Array<Real> & Material::getArray(const ID & vect_id, const ElementType & type,
                                  const GhostType & ghost_type) {
   std::stringstream sstr;
   std::string ghost_id = "";
   if (ghost_type == _ghost)
     ghost_id = ":ghost";
   sstr << getID() << ":" << vect_id << ":" << type << ghost_id;
 
   ID fvect_id = sstr.str();
   try {
     return Memory::getArray<Real>(fvect_id);
   } catch (debug::Exception & e) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain a vector "
                                             << vect_id << "(" << fvect_id
                                             << ") [" << e << "]");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 const Array<UInt> & Material::getArray(const ID & vect_id,
                                        const ElementType & type,
                                        const GhostType & ghost_type) const {
   std::stringstream sstr;
   std::string ghost_id = "";
   if (ghost_type == _ghost)
     ghost_id = ":ghost";
   sstr << getID() << ":" << vect_id << ":" << type << ghost_id;
 
   ID fvect_id = sstr.str();
   try {
     return Memory::getArray<UInt>(fvect_id);
   } catch (debug::Exception & e) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain a vector "
                                             << vect_id << "(" << fvect_id
                                             << ") [" << e << "]");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 Array<UInt> & Material::getArray(const ID & vect_id, const ElementType & type,
                                  const GhostType & ghost_type) {
   std::stringstream sstr;
   std::string ghost_id = "";
   if (ghost_type == _ghost)
     ghost_id = ":ghost";
   sstr << getID() << ":" << vect_id << ":" << type << ghost_id;
 
   ID fvect_id = sstr.str();
   try {
     return Memory::getArray<UInt>(fvect_id);
   } catch (debug::Exception & e) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain a vector "
                                             << vect_id << "(" << fvect_id
                                             << ") [" << e << "]");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 const InternalField<T> & Material::getInternal(__attribute__((unused))
                                                const ID & int_id) const {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
   return NULL;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 InternalField<T> & Material::getInternal(__attribute__((unused))
                                          const ID & int_id) {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
   return NULL;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 const InternalField<Real> & Material::getInternal(const ID & int_id) const {
   auto it = internal_vectors_real.find(getID() + ":" + int_id);
   if (it == internal_vectors_real.end()) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain an internal "
                                             << int_id << " ("
                                             << (getID() + ":" + int_id) << ")");
   }
   return *it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <> InternalField<Real> & Material::getInternal(const ID & int_id) {
   auto it = internal_vectors_real.find(getID() + ":" + int_id);
   if (it == internal_vectors_real.end()) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain an internal "
                                             << int_id << " ("
                                             << (getID() + ":" + int_id) << ")");
   }
   return *it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 const InternalField<UInt> & Material::getInternal(const ID & int_id) const {
   auto it = internal_vectors_uint.find(getID() + ":" + int_id);
   if (it == internal_vectors_uint.end()) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain an internal "
                                             << int_id << " ("
                                             << (getID() + ":" + int_id) << ")");
   }
   return *it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <> InternalField<UInt> & Material::getInternal(const ID & int_id) {
   auto it = internal_vectors_uint.find(getID() + ":" + int_id);
   if (it == internal_vectors_uint.end()) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain an internal "
                                             << int_id << " ("
                                             << (getID() + ":" + int_id) << ")");
   }
   return *it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::addElements(const Array<Element> & elements_to_add) {
   AKANTU_DEBUG_IN();
   UInt mat_id = model.getInternalIndexFromID(getID());
   Array<Element>::const_iterator<Element> el_begin = elements_to_add.begin();
   Array<Element>::const_iterator<Element> el_end = elements_to_add.end();
   for (; el_begin != el_end; ++el_begin) {
     const Element & element = *el_begin;
     Array<UInt> & mat_indexes =
         model.getMaterialByElement(element.type, element.ghost_type);
     Array<UInt> & mat_loc_num =
         model.getMaterialLocalNumbering(element.type, element.ghost_type);
 
     UInt index =
         this->addElement(element.type, element.element, element.ghost_type);
     mat_indexes(element.element) = mat_id;
     mat_loc_num(element.element) = index;
   }
 
   this->resizeInternals();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::removeElements(const Array<Element> & elements_to_remove) {
   AKANTU_DEBUG_IN();
 
   Array<Element>::const_iterator<Element> el_begin = elements_to_remove.begin();
   Array<Element>::const_iterator<Element> el_end = elements_to_remove.end();
 
   if (el_begin == el_end)
     return;
 
   ElementTypeMapArray<UInt> material_local_new_numbering(
       "remove mat filter elem", getID(), getMemoryID());
 
   Element element;
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     GhostType ghost_type = *gt;
     element.ghost_type = ghost_type;
 
     ElementTypeMapArray<UInt>::type_iterator it =
         element_filter.firstType(_all_dimensions, ghost_type, _ek_not_defined);
     ElementTypeMapArray<UInt>::type_iterator end =
         element_filter.lastType(_all_dimensions, ghost_type, _ek_not_defined);
 
     for (; it != end; ++it) {
       ElementType type = *it;
       element.type = type;
 
       Array<UInt> & elem_filter = this->element_filter(type, ghost_type);
       Array<UInt> & mat_loc_num =
           this->model.getMaterialLocalNumbering(type, ghost_type);
 
       if (!material_local_new_numbering.exists(type, ghost_type))
         material_local_new_numbering.alloc(elem_filter.size(), 1, type,
                                            ghost_type);
       Array<UInt> & mat_renumbering =
           material_local_new_numbering(type, ghost_type);
 
       UInt nb_element = elem_filter.size();
       Array<UInt> elem_filter_tmp;
 
       UInt new_id = 0;
       for (UInt el = 0; el < nb_element; ++el) {
         element.element = elem_filter(el);
 
         if (std::find(el_begin, el_end, element) == el_end) {
           elem_filter_tmp.push_back(element.element);
 
           mat_renumbering(el) = new_id;
           mat_loc_num(element.element) = new_id;
           ++new_id;
         } else {
           mat_renumbering(el) = UInt(-1);
         }
       }
 
       elem_filter.resize(elem_filter_tmp.size());
       elem_filter.copy(elem_filter_tmp);
     }
   }
 
   for (auto it = internal_vectors_real.begin();
        it != internal_vectors_real.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 
   for (auto it = internal_vectors_uint.begin();
        it != internal_vectors_uint.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 
   for (auto it = internal_vectors_bool.begin();
        it != internal_vectors_bool.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::resizeInternals() {
   AKANTU_DEBUG_IN();
   for (auto it = internal_vectors_real.begin();
        it != internal_vectors_real.end(); ++it)
     it->second->resize();
 
   for (auto it = internal_vectors_uint.begin();
        it != internal_vectors_uint.end(); ++it)
     it->second->resize();
 
   for (auto it = internal_vectors_bool.begin();
        it != internal_vectors_bool.end(); ++it)
     it->second->resize();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::onElementsAdded(const Array<Element> &,
                                const NewElementsEvent &) {
   this->resizeInternals();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::onElementsRemoved(
     const Array<Element> & element_list,
     const ElementTypeMapArray<UInt> & new_numbering,
     __attribute__((unused)) const RemovedElementsEvent & event) {
   UInt my_num = model.getInternalIndexFromID(getID());
 
   ElementTypeMapArray<UInt> material_local_new_numbering(
       "remove mat filter elem", getID(), getMemoryID());
 
   Array<Element>::const_iterator<Element> el_begin = element_list.begin();
   Array<Element>::const_iterator<Element> el_end = element_list.end();
 
   for (ghost_type_t::iterator g = ghost_type_t::begin();
        g != ghost_type_t::end(); ++g) {
     GhostType gt = *g;
 
     ElementTypeMapArray<UInt>::type_iterator it =
         new_numbering.firstType(_all_dimensions, gt, _ek_not_defined);
     ElementTypeMapArray<UInt>::type_iterator end =
         new_numbering.lastType(_all_dimensions, gt, _ek_not_defined);
     for (; it != end; ++it) {
       ElementType type = *it;
       if (element_filter.exists(type, gt) && element_filter(type, gt).size()) {
         Array<UInt> & elem_filter = element_filter(type, gt);
 
         Array<UInt> & mat_indexes = this->model.getMaterialByElement(*it, gt);
         Array<UInt> & mat_loc_num =
             this->model.getMaterialLocalNumbering(*it, gt);
         UInt nb_element = this->model.getMesh().getNbElement(type, gt);
 
         // all materials will resize of the same size...
         mat_indexes.resize(nb_element);
         mat_loc_num.resize(nb_element);
 
         if (!material_local_new_numbering.exists(type, gt))
           material_local_new_numbering.alloc(elem_filter.size(), 1, type, gt);
 
         Array<UInt> & mat_renumbering = material_local_new_numbering(type, gt);
         const Array<UInt> & renumbering = new_numbering(type, gt);
         Array<UInt> elem_filter_tmp;
         UInt ni = 0;
         Element el{type, 0, gt};
 
         for (UInt i = 0; i < elem_filter.size(); ++i) {
           el.element = elem_filter(i);
           if (std::find(el_begin, el_end, el) == el_end) {
             UInt new_el = renumbering(el.element);
             AKANTU_DEBUG_ASSERT(
                 new_el != UInt(-1),
                 "A not removed element as been badly renumbered");
             elem_filter_tmp.push_back(new_el);
             mat_renumbering(i) = ni;
 
             mat_indexes(new_el) = my_num;
             mat_loc_num(new_el) = ni;
             ++ni;
           } else {
             mat_renumbering(i) = UInt(-1);
           }
         }
 
         elem_filter.resize(elem_filter_tmp.size());
         elem_filter.copy(elem_filter_tmp);
       }
     }
   }
 
   for (auto it = internal_vectors_real.begin();
        it != internal_vectors_real.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 
   for (auto it = internal_vectors_uint.begin();
        it != internal_vectors_uint.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 
   for (auto it = internal_vectors_bool.begin();
        it != internal_vectors_bool.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::beforeSolveStep() { this->savePreviousState(); }
 
 /* -------------------------------------------------------------------------- */
 void Material::afterSolveStep() {
   for (auto & type : element_filter.elementTypes(_all_dimensions, _not_ghost,
                                                  _ek_not_defined)) {
     this->updateEnergies(type, _not_ghost);
   }
 }
 /* -------------------------------------------------------------------------- */
 void Material::onDamageIteration() { this->savePreviousState(); }
 
 /* -------------------------------------------------------------------------- */
 void Material::onDamageUpdate() {
   ElementTypeMapArray<UInt>::type_iterator it = this->element_filter.firstType(
       _all_dimensions, _not_ghost, _ek_not_defined);
   ElementTypeMapArray<UInt>::type_iterator end =
       element_filter.lastType(_all_dimensions, _not_ghost, _ek_not_defined);
 
   for (; it != end; ++it) {
     this->updateEnergiesAfterDamage(*it, _not_ghost);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::onDump() {
   if (this->isFiniteDeformation())
     this->computeAllCauchyStresses(_not_ghost);
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   std::string type = getID().substr(getID().find_last_of(':') + 1);
 
   stream << space << "Material " << type << " [" << std::endl;
   Parsable::printself(stream, indent);
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 /// extrapolate internal values
 void Material::extrapolateInternal(const ID & id, const Element & element,
                                    __attribute__((unused))
                                    const Matrix<Real> & point,
                                    Matrix<Real> & extrapolated) {
   if (this->isInternal<Real>(id, element.kind())) {
     UInt nb_element =
         this->element_filter(element.type, element.ghost_type).size();
     const ID name = this->getID() + ":" + id;
     UInt nb_quads =
         this->internal_vectors_real[name]->getFEEngine().getNbIntegrationPoints(
             element.type, element.ghost_type);
     const Array<Real> & internal =
         this->getArray<Real>(id, element.type, element.ghost_type);
     UInt nb_component = internal.getNbComponent();
     Array<Real>::const_matrix_iterator internal_it =
         internal.begin_reinterpret(nb_component, nb_quads, nb_element);
     Element local_element = this->convertToLocalElement(element);
 
     /// instead of really extrapolating, here the value of the first GP
     /// is copied into the result vector. This works only for linear
     /// elements
     /// @todo extrapolate!!!!
     AKANTU_DEBUG_WARNING("This is a fix, values are not truly extrapolated");
 
     const Matrix<Real> & values = internal_it[local_element.element];
     UInt index = 0;
     Vector<Real> tmp(nb_component);
     for (UInt j = 0; j < values.cols(); ++j) {
       tmp = values(j);
       if (tmp.norm() > 0) {
         index = j;
         break;
       }
     }
 
     for (UInt i = 0; i < extrapolated.size(); ++i) {
       extrapolated(i) = values(index);
     }
   } else {
     Matrix<Real> default_values(extrapolated.rows(), extrapolated.cols(), 0.);
     extrapolated = default_values;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::applyEigenGradU(const Matrix<Real> & prescribed_eigen_grad_u,
                                const GhostType ghost_type) {
 
   for (auto && type : element_filter.elementTypes(_all_dimensions, _not_ghost,
                                                   _ek_not_defined)) {
     if (!element_filter(type, ghost_type).size())
       continue;
     auto eigen_it = this->eigengradu(type, ghost_type)
                         .begin(spatial_dimension, spatial_dimension);
     auto eigen_end = this->eigengradu(type, ghost_type)
                          .end(spatial_dimension, spatial_dimension);
     for (; eigen_it != eigen_end; ++eigen_it) {
       auto & current_eigengradu = *eigen_it;
       current_eigengradu = prescribed_eigen_grad_u;
     }
   }
 }
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/material.hh b/src/model/solid_mechanics/material.hh
index a3f68b552..bd0eaa6f6 100644
--- a/src/model/solid_mechanics/material.hh
+++ b/src/model/solid_mechanics/material.hh
@@ -1,683 +1,683 @@
 
 
 /**
  * @file   material.hh
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Wed Nov 25 2015
  *
  * @brief  Mother class for all materials
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "aka_factory.hh"
 #include "aka_voigthelper.hh"
 #include "data_accessor.hh"
 #include "integration_point.hh"
 #include "parsable.hh"
 #include "parser.hh"
 /* -------------------------------------------------------------------------- */
 #include "internal_field.hh"
 #include "random_internal_field.hh"
 /* -------------------------------------------------------------------------- */
 #include "mesh_events.hh"
 #include "solid_mechanics_model_event_handler.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_HH__
 #define __AKANTU_MATERIAL_HH__
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 class Model;
 class SolidMechanicsModel;
 } // namespace akantu
 
 namespace akantu {
 
 /**
  * Interface of all materials
  * Prerequisites for a new material
  * - inherit from this class
  * - implement the following methods:
  * \code
  *  virtual Real getStableTimeStep(Real h, const Element & element =
  * ElementNull);
  *
  *  virtual void computeStress(ElementType el_type,
  *                             GhostType ghost_type = _not_ghost);
  *
  *  virtual void computeTangentStiffness(const ElementType & el_type,
  *                                       Array<Real> & tangent_matrix,
  *                                       GhostType ghost_type = _not_ghost);
  * \endcode
  *
  */
 class Material : public Memory,
                  public DataAccessor<Element>,
                  public Parsable,
                  public MeshEventHandler,
                  protected SolidMechanicsModelEventHandler {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
 #if __cplusplus > 199711L
   Material(const Material & mat) = delete;
   Material & operator=(const Material & mat) = delete;
 #endif
 
   /// Initialize material with defaults
   Material(SolidMechanicsModel & model, const ID & id = "");
 
   /// Initialize material with custom mesh & fe_engine
   Material(SolidMechanicsModel & model, UInt dim, const Mesh & mesh,
            FEEngine & fe_engine, const ID & id = "");
 
   /// Destructor
   ~Material() override;
 
 protected:
   void initialize();
 
   /* ------------------------------------------------------------------------ */
   /* Function that materials can/should reimplement                           */
   /* ------------------------------------------------------------------------ */
 protected:
   /// constitutive law
   virtual void computeStress(__attribute__((unused)) ElementType el_type,
                              __attribute__((unused))
                              GhostType ghost_type = _not_ghost) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// compute the tangent stiffness matrix
   virtual void computeTangentModuli(__attribute__((unused))
                                     const ElementType & el_type,
                                     __attribute__((unused))
                                     Array<Real> & tangent_matrix,
                                     __attribute__((unused))
                                     GhostType ghost_type = _not_ghost) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// compute the potential energy
   virtual void computePotentialEnergy(ElementType el_type,
                                       GhostType ghost_type = _not_ghost);
 
   /// compute the potential energy for an element
   virtual void
   computePotentialEnergyByElement(__attribute__((unused)) ElementType type,
                                   __attribute__((unused)) UInt index,
                                   __attribute__((unused))
                                   Vector<Real> & epot_on_quad_points) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   virtual void updateEnergies(__attribute__((unused)) ElementType el_type,
                               __attribute__((unused))
                               GhostType ghost_type = _not_ghost) {}
 
   virtual void updateEnergiesAfterDamage(__attribute__((unused))
                                          ElementType el_type,
                                          __attribute__((unused))
                                          GhostType ghost_type = _not_ghost) {}
 
   /// set the material to steady state (to be implemented for materials that
   /// need it)
   virtual void setToSteadyState(__attribute__((unused)) ElementType el_type,
                                 __attribute__((unused))
                                 GhostType ghost_type = _not_ghost) {}
 
   /// function called to update the internal parameters when the modifiable
   /// parameters are modified
   virtual void updateInternalParameters() {}
 
 public:
   /// extrapolate internal values
   virtual void extrapolateInternal(const ID & id, const Element & element,
                                    const Matrix<Real> & points,
                                    Matrix<Real> & extrapolated);
 
   /// compute the p-wave speed in the material
   virtual Real getPushWaveSpeed(__attribute__((unused))
                                 const Element & element) const {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// compute the s-wave speed in the material
   virtual Real getShearWaveSpeed(__attribute__((unused))
                                  const Element & element) const {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// get a material celerity to compute the stable time step (default: is the
   /// push wave speed)
   virtual Real getCelerity(const Element & element) const {
     return getPushWaveSpeed(element);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   template <typename T>
   void registerInternal(__attribute__((unused)) InternalField<T> & vect) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   template <typename T>
   void unregisterInternal(__attribute__((unused)) InternalField<T> & vect) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// initialize the material computed parameter
   virtual void initMaterial();
 
   /// compute the residual for this material
   //  virtual void updateResidual(GhostType ghost_type = _not_ghost);
 
   /// assemble the residual for this material
   virtual void assembleInternalForces(GhostType ghost_type);
 
   /// save the stress in the previous_stress if needed
   virtual void savePreviousState();
 
   /// compute the stresses for this material
   virtual void computeAllStresses(GhostType ghost_type = _not_ghost);
   // virtual void
   // computeAllStressesFromTangentModuli(GhostType ghost_type = _not_ghost);
   virtual void computeAllCauchyStresses(GhostType ghost_type = _not_ghost);
 
   /// set material to steady state
   void setToSteadyState(GhostType ghost_type = _not_ghost);
 
   /// compute the stiffness matrix
   virtual void assembleStiffnessMatrix(GhostType ghost_type);
 
   /// add an element to the local mesh filter
   inline UInt addElement(const ElementType & type, UInt element,
                          const GhostType & ghost_type);
   inline UInt addElement(const Element & element);
 
   /// add many elements at once
   void addElements(const Array<Element> & elements_to_add);
 
   /// remove many element at once
   void removeElements(const Array<Element> & elements_to_remove);
 
   /// function to print the contain of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
   /**
    * interpolate stress on given positions for each element by means
    * of a geometrical interpolation on quadrature points
    */
   void interpolateStress(ElementTypeMapArray<Real> & result,
                          const GhostType ghost_type = _not_ghost);
 
   /**
    * interpolate stress on given positions for each element by means
    * of a geometrical interpolation on quadrature points and store the
    * results per facet
    */
   void interpolateStressOnFacets(ElementTypeMapArray<Real> & result,
                                  ElementTypeMapArray<Real> & by_elem_result,
                                  const GhostType ghost_type = _not_ghost);
 
   /**
    * function to initialize the elemental field interpolation
    * function by inverting the quadrature points' coordinates
    */
   void initElementalFieldInterpolation(
       const ElementTypeMapArray<Real> & interpolation_points_coordinates);
 
   /* ------------------------------------------------------------------------ */
   /* Common part                                                              */
   /* ------------------------------------------------------------------------ */
 protected:
   /* ------------------------------------------------------------------------ */
   inline UInt getTangentStiffnessVoigtSize(UInt spatial_dimension) const;
 
   /// compute the potential energy by element
   void computePotentialEnergyByElements();
 
   /// resize the intenals arrays
   virtual void resizeInternals();
 
   /* ------------------------------------------------------------------------ */
   /* Finite deformation functions                                             */
   /* This functions area implementing what is described in the paper of Bathe */
   /* et al, in IJNME, Finite Element Formulations For Large Deformation       */
   /* Dynamic Analysis, Vol 9, 353-386, 1975                                   */
   /* ------------------------------------------------------------------------ */
 protected:
   /// assemble the residual
   template <UInt dim> void assembleInternalForces(GhostType ghost_type);
 
   /// Computation of Cauchy stress tensor in the case of finite deformation from
   /// the 2nd Piola-Kirchhoff for a given element type
   template <UInt dim>
   void computeCauchyStress(ElementType el_type,
                            GhostType ghost_type = _not_ghost);
 
   /// Computation the Cauchy stress the 2nd Piola-Kirchhoff and the deformation
   /// gradient
   template <UInt dim>
   inline void computeCauchyStressOnQuad(const Matrix<Real> & F,
                                         const Matrix<Real> & S,
                                         Matrix<Real> & cauchy,
                                         const Real & C33 = 1.0) const;
 
   template <UInt dim>
   void computeAllStressesFromTangentModuli(const ElementType & type,
                                            GhostType ghost_type);
 
   template <UInt dim>
   void assembleStiffnessMatrix(const ElementType & type, GhostType ghost_type);
 
   /// assembling in finite deformation
   template <UInt dim>
   void assembleStiffnessMatrixNL(const ElementType & type,
                                  GhostType ghost_type);
 
   template <UInt dim>
   void assembleStiffnessMatrixL2(const ElementType & type,
                                  GhostType ghost_type);
 
   /// Size of the Stress matrix for the case of finite deformation see: Bathe et
   /// al, IJNME, Vol 9, 353-386, 1975
   inline UInt getCauchyStressMatrixSize(UInt spatial_dimension) const;
 
   /// Sets the stress matrix according to Bathe et al, IJNME, Vol 9, 353-386,
   /// 1975
   template <UInt dim>
   inline void setCauchyStressMatrix(const Matrix<Real> & S_t,
                                     Matrix<Real> & sigma);
 
   /// write the stress tensor in the Voigt notation.
   template <UInt dim>
   inline void setCauchyStressArray(const Matrix<Real> & S_t,
                                    Matrix<Real> & sigma_voight);
 
   /* ------------------------------------------------------------------------ */
   /* Conversion functions                                                     */
   /* ------------------------------------------------------------------------ */
 public:
   template <UInt dim>
   static inline void gradUToF(const Matrix<Real> & grad_u, Matrix<Real> & F);
   static inline void rightCauchy(const Matrix<Real> & F, Matrix<Real> & C);
   static inline void leftCauchy(const Matrix<Real> & F, Matrix<Real> & B);
 
   template <UInt dim>
   static inline void gradUToEpsilon(const Matrix<Real> & grad_u,
                                     Matrix<Real> & epsilon);
   template <UInt dim>
   static inline void gradUToGreenStrain(const Matrix<Real> & grad_u,
                                         Matrix<Real> & epsilon);
 
   static inline Real stressToVonMises(const Matrix<Real> & stress);
 
 protected:
   /// converts global element to local element
   inline Element convertToLocalElement(const Element & global_element) const;
   /// converts local element to global element
   inline Element convertToGlobalElement(const Element & local_element) const;
 
   /// converts global quadrature point to local quadrature point
   inline IntegrationPoint
   convertToLocalPoint(const IntegrationPoint & global_point) const;
   /// converts local quadrature point to global quadrature point
   inline IntegrationPoint
   convertToGlobalPoint(const IntegrationPoint & local_point) const;
 
   /* ------------------------------------------------------------------------ */
   /* DataAccessor inherited members                                           */
   /* ------------------------------------------------------------------------ */
 public:
   inline UInt getNbData(const Array<Element> & elements,
                         const SynchronizationTag & tag) const override;
 
   inline void packData(CommunicationBuffer & buffer,
                        const Array<Element> & elements,
                        const SynchronizationTag & tag) const override;
 
   inline void unpackData(CommunicationBuffer & buffer,
                          const Array<Element> & elements,
                          const SynchronizationTag & tag) override;
 
   template <typename T>
   inline void packElementDataHelper(const ElementTypeMapArray<T> & data_to_pack,
                                     CommunicationBuffer & buffer,
                                     const Array<Element> & elements,
                                     const ID & fem_id = ID()) const;
 
   template <typename T>
   inline void unpackElementDataHelper(ElementTypeMapArray<T> & data_to_unpack,
                                       CommunicationBuffer & buffer,
                                       const Array<Element> & elements,
                                       const ID & fem_id = ID());
 
   /* ------------------------------------------------------------------------ */
   /* MeshEventHandler inherited members                                       */
   /* ------------------------------------------------------------------------ */
 public:
   /* ------------------------------------------------------------------------ */
   void onNodesAdded(const Array<UInt> &, const NewNodesEvent &) override{};
   void onNodesRemoved(const Array<UInt> &, const Array<UInt> &,
                       const RemovedNodesEvent &) override{};
 
   void onElementsAdded(const Array<Element> & element_list,
                        const NewElementsEvent & event) override;
 
   void onElementsRemoved(const Array<Element> & element_list,
                          const ElementTypeMapArray<UInt> & new_numbering,
                          const RemovedElementsEvent & event) override;
 
   void onElementsChanged(const Array<Element> &, const Array<Element> &,
                          const ElementTypeMapArray<UInt> &,
                          const ChangedElementsEvent &) override{};
 
   /* ------------------------------------------------------------------------ */
   /* SolidMechanicsModelEventHandler inherited members                        */
   /* ------------------------------------------------------------------------ */
 public:
   virtual void beforeSolveStep();
   virtual void afterSolveStep();
 
   void onDamageIteration() override;
   void onDamageUpdate() override;
   void onDump() override;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   AKANTU_GET_MACRO(Name, name, const std::string &);
 
   AKANTU_GET_MACRO(Model, model, const SolidMechanicsModel &)
 
   AKANTU_GET_MACRO(ID, Memory::getID(), const ID &);
   AKANTU_GET_MACRO(Rho, rho, Real);
   AKANTU_SET_MACRO(Rho, rho, Real);
 
   AKANTU_GET_MACRO(SpatialDimension, spatial_dimension, UInt);
 
   /// return the potential energy for the subset of elements contained by the
   /// material
   Real getPotentialEnergy();
   /// return the potential energy for the provided element
   Real getPotentialEnergy(ElementType & type, UInt index);
 
   /// return the energy (identified by id) for the subset of elements contained
   /// by the material
   virtual Real getEnergy(const std::string & energy_id);
   /// return the energy (identified by id) for the provided element
   virtual Real getEnergy(const std::string & energy_id, ElementType type,
                          UInt index);
 
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(ElementFilter, element_filter, UInt);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(GradU, gradu, Real);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Stress, stress, Real);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(PotentialEnergy, potential_energy,
                                          Real);
   AKANTU_GET_MACRO(GradU, gradu, const ElementTypeMapArray<Real> &);
   AKANTU_GET_MACRO(Stress, stress, const ElementTypeMapArray<Real> &);
   AKANTU_GET_MACRO(ElementFilter, element_filter,
                    const ElementTypeMapArray<UInt> &);
   AKANTU_GET_MACRO(FEEngine, fem, FEEngine &);
 
   bool isNonLocal() const { return is_non_local; }
 
   template <typename T>
   const Array<T> & getArray(const ID & id, const ElementType & type,
                             const GhostType & ghost_type = _not_ghost) const;
   template <typename T>
   Array<T> & getArray(const ID & id, const ElementType & type,
                       const GhostType & ghost_type = _not_ghost);
 
   template <typename T>
   const InternalField<T> & getInternal(const ID & id) const;
   template <typename T> InternalField<T> & getInternal(const ID & id);
 
   template <typename T>
   inline bool isInternal(const ID & id, const ElementKind & element_kind) const;
 
   template <typename T>
   ElementTypeMap<UInt>
   getInternalDataPerElem(const ID & id, const ElementKind & element_kind) const;
 
   bool isFiniteDeformation() const { return finite_deformation; }
   bool isInelasticDeformation() const { return inelastic_deformation; }
 
   template <typename T> inline void setParam(const ID & param, T value);
   template <typename T> inline void setParamNoUpdate(const ID & param, T value);
   inline const Parameter & getParam(const ID & param) const;
 
   template <typename T>
   void flattenInternal(const std::string & field_id,
                        ElementTypeMapArray<T> & internal_flat,
                        const GhostType ghost_type = _not_ghost,
                        ElementKind element_kind = _ek_not_defined) const;
 
   /// apply a constant eigengrad_u everywhere in the material
   virtual void applyEigenGradU(const Matrix<Real> & prescribed_eigen_grad_u,
                                const GhostType = _not_ghost);
 
   /// specify if the matrix need to be recomputed for this material
   virtual bool hasStiffnessMatrixChanged() { return true; }
 
 protected:
   bool isInit() const { return is_init; }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// boolean to know if the material has been initialized
   bool is_init;
 
   std::map<ID, InternalField<Real> *> internal_vectors_real;
   std::map<ID, InternalField<UInt> *> internal_vectors_uint;
   std::map<ID, InternalField<bool> *> internal_vectors_bool;
 
 protected:
   /// Link to the fem object in the model
   FEEngine & fem;
 
   /// Finite deformation
   bool finite_deformation;
 
   /// Finite deformation
   bool inelastic_deformation;
 
   /// material name
   std::string name;
 
   /// The model to witch the material belong
   SolidMechanicsModel & model;
 
   /// density : rho
   Real rho;
 
   /// spatial dimension
   UInt spatial_dimension;
 
   /// list of element handled by the material
   ElementTypeMapArray<UInt> element_filter;
 
   /// stresses arrays ordered by element types
   InternalField<Real> stress;
 
   /// eigengrad_u arrays ordered by element types
   InternalField<Real> eigengradu;
 
   /// grad_u arrays ordered by element types
   InternalField<Real> gradu;
 
   /// Green Lagrange strain (Finite deformation)
   InternalField<Real> green_strain;
 
   /// Second Piola-Kirchhoff stress tensor arrays ordered by element types
   /// (Finite deformation)
   InternalField<Real> piola_kirchhoff_2;
 
   /// potential energy by element
   InternalField<Real> potential_energy;
 
   /// tell if using in non local mode or not
   bool is_non_local;
 
   /// tell if the material need the previous stress state
   bool use_previous_stress;
 
   /// tell if the material need the previous strain state
   bool use_previous_gradu;
 
   /// elemental field interpolation coordinates
   InternalField<Real> interpolation_inverse_coordinates;
 
   /// elemental field interpolation points
   InternalField<Real> interpolation_points_matrices;
 
   /// vector that contains the names of all the internals that need to
   /// be transferred when material interfaces move
   std::vector<ID> internals_to_transfer;
 };
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream,
                                  const Material & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #include "material_inline_impl.cc"
 
 #include "internal_field_tmpl.hh"
 #include "random_internal_field_tmpl.hh"
 
 /* -------------------------------------------------------------------------- */
 /* Auto loop                                                                  */
 /* -------------------------------------------------------------------------- */
 /// This can be used to automatically write the loop on quadrature points in
 /// functions such as computeStress. This macro in addition to write the loop
 /// provides two tensors (matrices) sigma and grad_u
 #define MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type)       \
   Array<Real>::matrix_iterator gradu_it =                                      \
       this->gradu(el_type, ghost_type)                                         \
           .begin(this->spatial_dimension, this->spatial_dimension);            \
   Array<Real>::matrix_iterator gradu_end =                                     \
       this->gradu(el_type, ghost_type)                                         \
           .end(this->spatial_dimension, this->spatial_dimension);              \
                                                                                \
   this->stress(el_type, ghost_type)                                            \
       .resize(this->gradu(el_type, ghost_type).size());                        \
                                                                                \
   Array<Real>::iterator<Matrix<Real>> stress_it =                              \
       this->stress(el_type, ghost_type)                                        \
           .begin(this->spatial_dimension, this->spatial_dimension);            \
                                                                                \
   if (this->isFiniteDeformation()) {                                           \
     this->piola_kirchhoff_2(el_type, ghost_type)                               \
         .resize(this->gradu(el_type, ghost_type).size());                      \
     stress_it = this->piola_kirchhoff_2(el_type, ghost_type)                   \
                     .begin(this->spatial_dimension, this->spatial_dimension);  \
   }                                                                            \
                                                                                \
   for (; gradu_it != gradu_end; ++gradu_it, ++stress_it) {                     \
     Matrix<Real> & __attribute__((unused)) grad_u = *gradu_it;                 \
     Matrix<Real> & __attribute__((unused)) sigma = *stress_it
 
 #define MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END }
 
 /// This can be used to automatically write the loop on quadrature points in
 /// functions such as computeTangentModuli. This macro in addition to write the
 /// loop provides two tensors (matrices) sigma_tensor, grad_u, and a matrix
 /// where the elemental tangent moduli should be stored in Voigt Notation
 #define MATERIAL_TANGENT_QUADRATURE_POINT_LOOP_BEGIN(tangent_mat)              \
   Array<Real>::matrix_iterator gradu_it =                                      \
       this->gradu(el_type, ghost_type)                                         \
           .begin(this->spatial_dimension, this->spatial_dimension);            \
   Array<Real>::matrix_iterator gradu_end =                                     \
       this->gradu(el_type, ghost_type)                                         \
           .end(this->spatial_dimension, this->spatial_dimension);              \
   Array<Real>::matrix_iterator sigma_it =                                      \
       this->stress(el_type, ghost_type)                                        \
           .begin(this->spatial_dimension, this->spatial_dimension);            \
                                                                                \
   tangent_mat.resize(this->gradu(el_type, ghost_type).size());                 \
                                                                                \
   UInt tangent_size =                                                          \
       this->getTangentStiffnessVoigtSize(this->spatial_dimension);             \
   Array<Real>::matrix_iterator tangent_it =                                    \
       tangent_mat.begin(tangent_size, tangent_size);                           \
                                                                                \
   for (; gradu_it != gradu_end; ++gradu_it, ++sigma_it, ++tangent_it) {        \
     Matrix<Real> & __attribute__((unused)) grad_u = *gradu_it;                 \
     Matrix<Real> & __attribute__((unused)) sigma_tensor = *sigma_it;           \
     Matrix<Real> & tangent = *tangent_it
 
 #define MATERIAL_TANGENT_QUADRATURE_POINT_LOOP_END }
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 using MaterialFactory =
     Factory<Material, ID, UInt, const ID &, SolidMechanicsModel &, const ID &>;
 } // namespace akantu
 
 #define INSTANTIATE_MATERIAL_ONLY(mat_name)                                    \
   template class mat_name<1>;                                                  \
   template class mat_name<2>;                                                  \
   template class mat_name<3>
 
 #define MATERIAL_DEFAULT_PER_DIM_ALLOCATOR(id, mat_name)                       \
   [](UInt dim, const ID &, SolidMechanicsModel & model,                        \
      const ID & id) -> std::unique_ptr<Material> {                             \
     switch (dim) {                                                             \
     case 1:                                                                    \
       return std::make_unique<mat_name<1>>(model, id);                         \
     case 2:                                                                    \
       return std::make_unique<mat_name<2>>(model, id);                         \
     case 3:                                                                    \
       return std::make_unique<mat_name<3>>(model, id);                         \
     default:                                                                   \
       AKANTU_EXCEPTION("The dimension "                                        \
                        << dim << "is not a valid dimension for the material "  \
                        << #id);                                                \
     }                                                                          \
   }
 
 #define INSTANTIATE_MATERIAL(id, mat_name)                                     \
   INSTANTIATE_MATERIAL_ONLY(mat_name);                                         \
   static bool material_is_alocated_##id [[gnu::unused]] =                      \
       MaterialFactory::getInstance().registerAllocator(                        \
           #id, MATERIAL_DEFAULT_PER_DIM_ALLOCATOR(id, mat_name))
 
 #endif /* __AKANTU_MATERIAL_HH__ */
diff --git a/src/model/solid_mechanics/material_inline_impl.cc b/src/model/solid_mechanics/material_inline_impl.cc
index 1f6d1c0dd..494cda3d8 100644
--- a/src/model/solid_mechanics/material_inline_impl.cc
+++ b/src/model/solid_mechanics/material_inline_impl.cc
@@ -1,475 +1,475 @@
 /**
  * @file   material_inline_impl.cc
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue Jul 27 2010
  * @date last modification: Wed Nov 25 2015
  *
  * @brief  Implementation of the inline functions of the class material
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_INLINE_IMPL_CC__
 #define __AKANTU_MATERIAL_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline UInt Material::addElement(const ElementType & type, UInt element,
                                  const GhostType & ghost_type) {
   Array<UInt> & el_filter = this->element_filter(type, ghost_type);
   el_filter.push_back(element);
   return el_filter.size() - 1;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Material::addElement(const Element & element) {
   return this->addElement(element.type, element.element, element.ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Material::getTangentStiffnessVoigtSize(UInt dim) const {
   return (dim * (dim - 1) / 2 + dim);
 }
 /* -------------------------------------------------------------------------- */
 inline UInt Material::getCauchyStressMatrixSize(UInt dim) const {
   return (dim * dim);
 }
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void Material::gradUToF(const Matrix<Real> & grad_u, Matrix<Real> & F) {
   AKANTU_DEBUG_ASSERT(F.size() >= grad_u.size() && grad_u.size() == dim * dim,
                       "The dimension of the tensor F should be greater or "
                       "equal to the dimension of the tensor grad_u.");
 
   F.eye();
 
   for (UInt i = 0; i < dim; ++i)
     for (UInt j = 0; j < dim; ++j)
       F(i, j) += grad_u(i, j);
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void Material::computeCauchyStressOnQuad(const Matrix<Real> & F,
                                                 const Matrix<Real> & piola,
                                                 Matrix<Real> & sigma,
                                                 const Real & C33) const {
 
   Real J = F.det() * sqrt(C33);
 
   Matrix<Real> F_S(dim, dim);
   F_S.mul<false, false>(F, piola);
   Real constant = J ? 1. / J : 0;
   sigma.mul<false, true>(F_S, F, constant);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Material::rightCauchy(const Matrix<Real> & F, Matrix<Real> & C) {
   C.mul<true, false>(F, F);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Material::leftCauchy(const Matrix<Real> & F, Matrix<Real> & B) {
   B.mul<false, true>(F, F);
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void Material::gradUToEpsilon(const Matrix<Real> & grad_u,
                                      Matrix<Real> & epsilon) {
   for (UInt i = 0; i < dim; ++i)
     for (UInt j = 0; j < dim; ++j)
       epsilon(i, j) = 0.5 * (grad_u(i, j) + grad_u(j, i));
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void Material::gradUToGreenStrain(const Matrix<Real> & grad_u,
                                          Matrix<Real> & epsilon) {
   epsilon.mul<true, false>(grad_u, grad_u, .5);
 
   for (UInt i = 0; i < dim; ++i)
     for (UInt j = 0; j < dim; ++j)
       epsilon(i, j) += 0.5 * (grad_u(i, j) + grad_u(j, i));
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Material::stressToVonMises(const Matrix<Real> & stress) {
   // compute deviatoric stress
   UInt dim = stress.cols();
   Matrix<Real> deviatoric_stress =
       Matrix<Real>::eye(dim, -1. * stress.trace() / 3.);
 
   for (UInt i = 0; i < dim; ++i)
     for (UInt j = 0; j < dim; ++j)
       deviatoric_stress(i, j) += stress(i, j);
 
   // return Von Mises stress
   return std::sqrt(3. * deviatoric_stress.doubleDot(deviatoric_stress) / 2.);
 }
 
 /* ---------------------------------------------------------------------------*/
 template <UInt dim>
 inline void Material::setCauchyStressArray(const Matrix<Real> & S_t,
                                            Matrix<Real> & sigma_voight) {
   AKANTU_DEBUG_IN();
   sigma_voight.clear();
   // see Finite element formulations for large deformation dynamic analysis,
   // Bathe et al. IJNME vol 9, 1975, page 364 ^t\tau
 
   /*
    * 1d: [ s11 ]'
    * 2d: [ s11 s22 s12 ]'
    * 3d: [ s11 s22 s33 s23 s13 s12 ]
    */
   for (UInt i = 0; i < dim; ++i) // diagonal terms
     sigma_voight(i, 0) = S_t(i, i);
 
   for (UInt i = 1; i < dim; ++i) // term s12 in 2D and terms s23 s13 in 3D
     sigma_voight(dim + i - 1, 0) = S_t(dim - i - 1, dim - 1);
 
   for (UInt i = 2; i < dim; ++i) // term s13 in 3D
     sigma_voight(dim + i, 0) = S_t(0, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void Material::setCauchyStressMatrix(const Matrix<Real> & S_t,
                                             Matrix<Real> & sigma) {
   AKANTU_DEBUG_IN();
 
   sigma.clear();
 
   /// see Finite ekement formulations for large deformation dynamic analysis,
   /// Bathe et al. IJNME vol 9, 1975, page 364 ^t\tau
   for (UInt i = 0; i < dim; ++i) {
     for (UInt m = 0; m < dim; ++m) {
       for (UInt n = 0; n < dim; ++n) {
         sigma(i * dim + m, i * dim + n) = S_t(m, n);
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 inline Element
 Material::convertToLocalElement(const Element & global_element) const {
   UInt ge = global_element.element;
 #ifndef AKANTU_NDEBUG
   UInt model_mat_index = this->model.getMaterialByElement(
       global_element.type, global_element.ghost_type)(ge);
 
   UInt mat_index = this->model.getMaterialIndex(this->name);
   AKANTU_DEBUG_ASSERT(model_mat_index == mat_index,
                       "Conversion of a global  element in a local element for "
                       "the wrong material "
                           << this->name << std::endl);
 #endif
   UInt le = this->model.getMaterialLocalNumbering(
       global_element.type, global_element.ghost_type)(ge);
 
   Element tmp_quad{global_element.type, le, global_element.ghost_type};
   return tmp_quad;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Element
 Material::convertToGlobalElement(const Element & local_element) const {
   UInt le = local_element.element;
   UInt ge =
       this->element_filter(local_element.type, local_element.ghost_type)(le);
 
   Element tmp_quad{local_element.type, ge, local_element.ghost_type};
   return tmp_quad;
 }
 
 /* -------------------------------------------------------------------------- */
 inline IntegrationPoint
 Material::convertToLocalPoint(const IntegrationPoint & global_point) const {
   const FEEngine & fem = this->model.getFEEngine();
   UInt nb_quad = fem.getNbIntegrationPoints(global_point.type);
   Element el =
       this->convertToLocalElement(static_cast<const Element &>(global_point));
   IntegrationPoint tmp_quad(el, global_point.num_point, nb_quad);
   return tmp_quad;
 }
 
 /* -------------------------------------------------------------------------- */
 inline IntegrationPoint
 Material::convertToGlobalPoint(const IntegrationPoint & local_point) const {
   const FEEngine & fem = this->model.getFEEngine();
   UInt nb_quad = fem.getNbIntegrationPoints(local_point.type);
   Element el =
       this->convertToGlobalElement(static_cast<const Element &>(local_point));
   IntegrationPoint tmp_quad(el, local_point.num_point, nb_quad);
   return tmp_quad;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Material::getNbData(const Array<Element> & elements,
                                 const SynchronizationTag & tag) const {
   if (tag == _gst_smm_stress) {
     return (this->isFiniteDeformation() ? 3 : 1) * spatial_dimension *
            spatial_dimension * sizeof(Real) *
            this->getModel().getNbIntegrationPoints(elements);
   }
   return 0;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Material::packData(CommunicationBuffer & buffer,
                                const Array<Element> & elements,
                                const SynchronizationTag & tag) const {
   if (tag == _gst_smm_stress) {
     if (this->isFiniteDeformation()) {
       packElementDataHelper(piola_kirchhoff_2, buffer, elements);
       packElementDataHelper(gradu, buffer, elements);
     }
     packElementDataHelper(stress, buffer, elements);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Material::unpackData(CommunicationBuffer & buffer,
                                  const Array<Element> & elements,
                                  const SynchronizationTag & tag) {
   if (tag == _gst_smm_stress) {
     if (this->isFiniteDeformation()) {
       unpackElementDataHelper(piola_kirchhoff_2, buffer, elements);
       unpackElementDataHelper(gradu, buffer, elements);
     }
     unpackElementDataHelper(stress, buffer, elements);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Parameter & Material::getParam(const ID & param) const {
   try {
     return get(param);
   } catch (...) {
     AKANTU_EXCEPTION("No parameter " << param << " in the material "
                                      << getID());
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Material::setParam(const ID & param, T value) {
   try {
     set<T>(param, value);
   } catch (...) {
     AKANTU_EXCEPTION("No parameter " << param << " in the material "
                                      << getID());
   }
   updateInternalParameters();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Material::setParamNoUpdate(const ID & param, T value) {
   try {
     set<T>(param, value);
   } catch (...) {
     AKANTU_EXCEPTION("No parameter " << param << " in the material "
                      << getID());
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Material::packElementDataHelper(
     const ElementTypeMapArray<T> & data_to_pack, CommunicationBuffer & buffer,
     const Array<Element> & elements, const ID & fem_id) const {
   DataAccessor::packElementalDataHelper<T>(data_to_pack, buffer, elements, true,
                                            model.getFEEngine(fem_id));
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Material::unpackElementDataHelper(
     ElementTypeMapArray<T> & data_to_unpack, CommunicationBuffer & buffer,
     const Array<Element> & elements, const ID & fem_id) {
   DataAccessor::unpackElementalDataHelper<T>(data_to_unpack, buffer, elements,
                                              true, model.getFEEngine(fem_id));
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void Material::registerInternal<Real>(InternalField<Real> & vect) {
   internal_vectors_real[vect.getID()] = &vect;
 }
 
 template <>
 inline void Material::registerInternal<UInt>(InternalField<UInt> & vect) {
   internal_vectors_uint[vect.getID()] = &vect;
 }
 
 template <>
 inline void Material::registerInternal<bool>(InternalField<bool> & vect) {
   internal_vectors_bool[vect.getID()] = &vect;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void Material::unregisterInternal<Real>(InternalField<Real> & vect) {
   internal_vectors_real.erase(vect.getID());
 }
 
 template <>
 inline void Material::unregisterInternal<UInt>(InternalField<UInt> & vect) {
   internal_vectors_uint.erase(vect.getID());
 }
 
 template <>
 inline void Material::unregisterInternal<bool>(InternalField<bool> & vect) {
   internal_vectors_bool.erase(vect.getID());
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline bool Material::isInternal(__attribute__((unused)) const ID & id,
                                  __attribute__((unused))
                                  const ElementKind & element_kind) const {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
 }
 
 template <>
 inline bool Material::isInternal<Real>(const ID & id,
                                        const ElementKind & element_kind) const {
   auto internal_array = internal_vectors_real.find(this->getID() + ":" + id);
 
   if (internal_array == internal_vectors_real.end() ||
       internal_array->second->getElementKind() != element_kind)
     return false;
   return true;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline ElementTypeMap<UInt>
 Material::getInternalDataPerElem(const ID & field_id,
                                  const ElementKind & element_kind) const {
 
   if (!this->template isInternal<T>(field_id, element_kind))
     AKANTU_EXCEPTION("Cannot find internal field " << id << " in material "
                                                    << this->name);
 
   const InternalField<T> & internal_field =
       this->template getInternal<T>(field_id);
   const FEEngine & fe_engine = internal_field.getFEEngine();
   UInt nb_data_per_quad = internal_field.getNbComponent();
 
   ElementTypeMap<UInt> res;
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     using type_iterator = typename InternalField<T>::type_iterator;
     type_iterator tit = internal_field.firstType(*gt);
     type_iterator tend = internal_field.lastType(*gt);
 
     for (; tit != tend; ++tit) {
       UInt nb_quadrature_points = fe_engine.getNbIntegrationPoints(*tit, *gt);
       res(*tit, *gt) = nb_data_per_quad * nb_quadrature_points;
     }
   }
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Material::flattenInternal(const std::string & field_id,
                                ElementTypeMapArray<T> & internal_flat,
                                const GhostType ghost_type,
                                ElementKind element_kind) const {
 
   if (!this->template isInternal<T>(field_id, element_kind))
     AKANTU_EXCEPTION("Cannot find internal field " << id << " in material "
                                                    << this->name);
 
   const InternalField<T> & internal_field =
       this->template getInternal<T>(field_id);
 
   const FEEngine & fe_engine = internal_field.getFEEngine();
   const Mesh & mesh = fe_engine.getMesh();
 
   using type_iterator = typename InternalField<T>::filter_type_iterator;
   type_iterator tit = internal_field.filterFirstType(ghost_type);
   type_iterator tend = internal_field.filterLastType(ghost_type);
 
   for (; tit != tend; ++tit) {
     ElementType type = *tit;
 
     const Array<Real> & src_vect = internal_field(type, ghost_type);
     const Array<UInt> & filter = internal_field.getFilter(type, ghost_type);
 
     // total number of elements in the corresponding mesh
     UInt nb_element_dst = mesh.getNbElement(type, ghost_type);
     // number of element in the internal field
     UInt nb_element_src = filter.size();
     // number of quadrature points per elem
     UInt nb_quad_per_elem = fe_engine.getNbIntegrationPoints(type);
     // number of data per quadrature point
     UInt nb_data_per_quad = internal_field.getNbComponent();
 
     if (!internal_flat.exists(type, ghost_type)) {
       internal_flat.alloc(nb_element_dst * nb_quad_per_elem, nb_data_per_quad,
                           type, ghost_type);
     }
 
     if (nb_element_src == 0)
       continue;
 
     // number of data per element
     UInt nb_data = nb_quad_per_elem * nb_data_per_quad;
 
     Array<Real> & dst_vect = internal_flat(type, ghost_type);
     dst_vect.resize(nb_element_dst * nb_quad_per_elem);
 
     Array<UInt>::const_scalar_iterator it = filter.begin();
     Array<UInt>::const_scalar_iterator end = filter.end();
 
     Array<Real>::const_vector_iterator it_src =
         src_vect.begin_reinterpret(nb_data, nb_element_src);
     Array<Real>::vector_iterator it_dst =
         dst_vect.begin_reinterpret(nb_data, nb_element_dst);
 
     for (; it != end; ++it, ++it_src) {
       it_dst[*it] = *it_src;
     }
   }
 }
 
 } // akantu
 
 #endif /* __AKANTU_MATERIAL_INLINE_IMPL_CC__ */
diff --git a/src/model/solid_mechanics/materials/material_elastic_linear_anisotropic.cc b/src/model/solid_mechanics/materials/material_elastic_linear_anisotropic.cc
index 5f08a8369..15dcfb555 100644
--- a/src/model/solid_mechanics/materials/material_elastic_linear_anisotropic.cc
+++ b/src/model/solid_mechanics/materials/material_elastic_linear_anisotropic.cc
@@ -1,266 +1,266 @@
 /**
  * @file   material_elastic_linear_anisotropic.cc
  *
  * @author Till Junge <till.junge@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Sep 25 2013
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Anisotropic elastic material
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 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 "material_elastic_linear_anisotropic.hh"
 #include "solid_mechanics_model.hh"
 #include <algorithm>
 #include <sstream>
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 MaterialElasticLinearAnisotropic<dim>::MaterialElasticLinearAnisotropic(
     SolidMechanicsModel & model, const ID & id, bool symmetric)
     : Material(model, id), rot_mat(dim, dim), Cprime(dim * dim, dim * dim),
       C(voigt_h::size, voigt_h::size), eigC(voigt_h::size),
       symmetric(symmetric), alpha(0), was_stiffness_assembled(false) {
   AKANTU_DEBUG_IN();
 
   this->dir_vecs.push_back(std::make_unique<Vector<Real>>(dim));
   (*this->dir_vecs.back())[0] = 1.;
   this->registerParam("n1", *(this->dir_vecs.back()), _pat_parsmod,
                       "Direction of main material axis");
 
   if (dim > 1) {
     this->dir_vecs.push_back(std::make_unique<Vector<Real>>(dim));
     (*this->dir_vecs.back())[1] = 1.;
     this->registerParam("n2", *(this->dir_vecs.back()), _pat_parsmod,
                         "Direction of secondary material axis");
   }
 
   if (dim > 2) {
     this->dir_vecs.push_back(std::make_unique<Vector<Real>>(dim));
     (*this->dir_vecs.back())[2] = 1.;
     this->registerParam("n3", *(this->dir_vecs.back()), _pat_parsmod,
                         "Direction of tertiary material axis");
   }
 
   for (UInt i = 0; i < voigt_h::size; ++i) {
     UInt start = 0;
     if (this->symmetric) {
       start = i;
     }
     for (UInt j = start; j < voigt_h::size; ++j) {
       std::stringstream param("C");
       param << "C" << i + 1 << j + 1;
       this->registerParam(param.str(), this->Cprime(i, j), Real(0.),
                           _pat_parsmod, "Coefficient " + param.str());
     }
   }
 
   this->registerParam("alpha", this->alpha, _pat_parsmod,
                       "Proportion of viscous stress");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim> void MaterialElasticLinearAnisotropic<dim>::initMaterial() {
   AKANTU_DEBUG_IN();
   Material::initMaterial();
 
   updateInternalParameters();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void MaterialElasticLinearAnisotropic<dim>::updateInternalParameters() {
   Material::updateInternalParameters();
   if (this->symmetric) {
     for (UInt i = 0; i < voigt_h::size; ++i) {
       for (UInt j = i + 1; j < voigt_h::size; ++j) {
         this->Cprime(j, i) = this->Cprime(i, j);
       }
     }
   }
   this->rotateCprime();
   this->C.eig(this->eigC);
 
   this->was_stiffness_assembled = false;
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt Dim> void MaterialElasticLinearAnisotropic<Dim>::rotateCprime() {
   // start by filling the empty parts fo Cprime
   UInt diff = Dim * Dim - voigt_h::size;
   for (UInt i = voigt_h::size; i < Dim * Dim; ++i) {
     for (UInt j = 0; j < Dim * Dim; ++j) {
       this->Cprime(i, j) = this->Cprime(i - diff, j);
     }
   }
   for (UInt i = 0; i < Dim * Dim; ++i) {
     for (UInt j = voigt_h::size; j < Dim * Dim; ++j) {
       this->Cprime(i, j) = this->Cprime(i, j - diff);
     }
   }
   // construction of rotator tensor
   // normalise rotation matrix
   for (UInt j = 0; j < Dim; ++j) {
     Vector<Real> rot_vec = this->rot_mat(j);
     rot_vec = *this->dir_vecs[j];
     rot_vec.normalize();
   }
 
   // make sure the vectors form a right-handed base
   Vector<Real> test_axis(3);
   Vector<Real> v1(3), v2(3), v3(3);
 
   if (Dim == 2) {
     for (UInt i = 0; i < Dim; ++i) {
       v1[i] = this->rot_mat(0, i);
       v2[i] = this->rot_mat(1, i);
       v3[i] = 0.;
     }
     v3[2] = 1.;
     v1[2] = 0.;
     v2[2] = 0.;
   } else if (Dim == 3) {
     v1 = this->rot_mat(0);
     v2 = this->rot_mat(1);
     v3 = this->rot_mat(2);
   }
 
   test_axis.crossProduct(v1, v2);
   test_axis -= v3;
   if (test_axis.norm() > 8 * std::numeric_limits<Real>::epsilon()) {
-    AKANTU_DEBUG_ERROR("The axis vectors do not form a right-handed coordinate "
+    AKANTU_ERROR("The axis vectors do not form a right-handed coordinate "
                        << "system. I. e., ||n1 x n2 - n3|| should be zero, but "
                        << "it is " << test_axis.norm() << ".");
   }
 
   // create the rotator and the reverse rotator
   Matrix<Real> rotator(Dim * Dim, Dim * Dim);
   Matrix<Real> revrotor(Dim * Dim, Dim * Dim);
   for (UInt i = 0; i < Dim; ++i) {
     for (UInt j = 0; j < Dim; ++j) {
       for (UInt k = 0; k < Dim; ++k) {
         for (UInt l = 0; l < Dim; ++l) {
           UInt I = voigt_h::mat[i][j];
           UInt J = voigt_h::mat[k][l];
           rotator(I, J) = this->rot_mat(k, i) * this->rot_mat(l, j);
           revrotor(I, J) = this->rot_mat(i, k) * this->rot_mat(j, l);
         }
       }
     }
   }
 
   // create the full rotated matrix
   Matrix<Real> Cfull(Dim * Dim, Dim * Dim);
   Cfull = rotator * Cprime * revrotor;
 
   for (UInt i = 0; i < voigt_h::size; ++i) {
     for (UInt j = 0; j < voigt_h::size; ++j) {
       this->C(i, j) = Cfull(i, j);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void MaterialElasticLinearAnisotropic<dim>::computeStress(ElementType el_type,
                                                           GhostType ghost_type) {
   // Wikipedia convention:
   // 2*eps_ij (i!=j) = voigt_eps_I
   // http://en.wikipedia.org/wiki/Voigt_notation
   AKANTU_DEBUG_IN();
 
   Matrix<Real> strain(dim, dim);
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
 
   this->computeStressOnQuad(strain,sigma);
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void MaterialElasticLinearAnisotropic<dim>::computeTangentModuli(
     const ElementType & el_type, Array<Real> & tangent_matrix,
     GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   MATERIAL_TANGENT_QUADRATURE_POINT_LOOP_BEGIN(tangent_matrix);
 
   this->computeTangentModuliOnQuad(tangent);
 
   MATERIAL_TANGENT_QUADRATURE_POINT_LOOP_END;
 
   this->was_stiffness_assembled = true;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void MaterialElasticLinearAnisotropic<dim>::computePotentialEnergy(
     ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Material::computePotentialEnergy(el_type, ghost_type);
 
   AKANTU_DEBUG_ASSERT(!this->finite_deformation,
                       "finite deformation not possible in material anisotropic "
                       "(TO BE IMPLEMENTED)");
 
   if (ghost_type != _not_ghost)
     return;
   Array<Real>::scalar_iterator epot =
     this->potential_energy(el_type, ghost_type).begin();
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
 
   computePotentialEnergyOnQuad(grad_u, sigma, *epot);
   ++epot;
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 Real MaterialElasticLinearAnisotropic<dim>::getCelerity(
     __attribute__((unused)) const Element & element) const {
   return std::sqrt(this->eigC(0) / rho);
 }
 
 /* -------------------------------------------------------------------------- */
 
 INSTANTIATE_MATERIAL(elastic_anisotropic, MaterialElasticLinearAnisotropic);
 
 } // akantu
diff --git a/src/model/solid_mechanics/materials/material_elastic_orthotropic.cc b/src/model/solid_mechanics/materials/material_elastic_orthotropic.cc
index 331a25fbe..c14e5784a 100644
--- a/src/model/solid_mechanics/materials/material_elastic_orthotropic.cc
+++ b/src/model/solid_mechanics/materials/material_elastic_orthotropic.cc
@@ -1,168 +1,168 @@
 /**
  * @file   material_elastic_orthotropic.cc
  *
  * @author Till Junge <till.junge@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Orthotropic elastic material
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "material_elastic_orthotropic.hh"
 #include "solid_mechanics_model.hh"
 #include <algorithm>
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <UInt Dim>
 MaterialElasticOrthotropic<Dim>::MaterialElasticOrthotropic(
     SolidMechanicsModel & model, const ID & id)
     : MaterialElasticLinearAnisotropic<Dim>(model, id) {
   AKANTU_DEBUG_IN();
   this->registerParam("E1", E1, Real(0.), _pat_parsmod, "Young's modulus (n1)");
   this->registerParam("E2", E2, Real(0.), _pat_parsmod, "Young's modulus (n2)");
   this->registerParam("nu12", nu12, Real(0.), _pat_parsmod,
                       "Poisson's ratio (12)");
   this->registerParam("G12", G12, Real(0.), _pat_parsmod, "Shear modulus (12)");
 
   if (Dim > 2) {
     this->registerParam("E3", E3, Real(0.), _pat_parsmod,
                         "Young's modulus (n3)");
     this->registerParam("nu13", nu13, Real(0.), _pat_parsmod,
                         "Poisson's ratio (13)");
     this->registerParam("nu23", nu23, Real(0.), _pat_parsmod,
                         "Poisson's ratio (23)");
     this->registerParam("G13", G13, Real(0.), _pat_parsmod,
                         "Shear modulus (13)");
     this->registerParam("G23", G23, Real(0.), _pat_parsmod,
                         "Shear modulus (23)");
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt Dim> void MaterialElasticOrthotropic<Dim>::initMaterial() {
   AKANTU_DEBUG_IN();
   Material::initMaterial();
 
   updateInternalParameters();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt Dim>
 void MaterialElasticOrthotropic<Dim>::updateInternalParameters() {
   /* 1) construction of temporary material frame stiffness tensor------------ */
   // http://solidmechanics.org/Text/Chapter3_2/Chapter3_2.php#Sect3_2_13
   Real nu21 = nu12 * E2 / E1;
   Real nu31 = nu13 * E3 / E1;
   Real nu32 = nu23 * E3 / E2;
 
   // Full (i.e. dim^2 by dim^2) stiffness tensor in material frame
   if (Dim == 1) {
-    AKANTU_DEBUG_ERROR("Dimensions 1 not implemented: makes no sense to have "
+    AKANTU_ERROR("Dimensions 1 not implemented: makes no sense to have "
                        "orthotropy for 1D");
   }
 
   Real Gamma;
 
   if (Dim == 3)
     Gamma = 1 / (1 - nu12 * nu21 - nu23 * nu32 - nu31 * nu13 -
                  2 * nu21 * nu32 * nu13);
 
   if (Dim == 2)
     Gamma = 1 / (1 - nu12 * nu21);
 
   // Lamé's first parameters
   this->Cprime(0, 0) = E1 * (1 - nu23 * nu32) * Gamma;
   this->Cprime(1, 1) = E2 * (1 - nu13 * nu31) * Gamma;
   if (Dim == 3)
     this->Cprime(2, 2) = E3 * (1 - nu12 * nu21) * Gamma;
 
   // normalised poisson's ratio's
   this->Cprime(1, 0) = this->Cprime(0, 1) = E1 * (nu21 + nu31 * nu23) * Gamma;
   if (Dim == 3) {
     this->Cprime(2, 0) = this->Cprime(0, 2) = E1 * (nu31 + nu21 * nu32) * Gamma;
     this->Cprime(2, 1) = this->Cprime(1, 2) = E2 * (nu32 + nu12 * nu31) * Gamma;
   }
 
   // Lamé's second parameters (shear moduli)
   if (Dim == 3) {
     this->Cprime(3, 3) = G23;
     this->Cprime(4, 4) = G13;
     this->Cprime(5, 5) = G12;
   } else
     this->Cprime(2, 2) = G12;
 
   /* 1) rotation of C into the global frame */
   this->rotateCprime();
   this->C.eig(this->eigC);
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialElasticOrthotropic<spatial_dimension>::
     computePotentialEnergyByElement(ElementType type, UInt index,
                                     Vector<Real> & epot_on_quad_points) {
 
   AKANTU_DEBUG_ASSERT(!this->finite_deformation,
                       "finite deformation not possible in material orthotropic "
                       "(TO BE IMPLEMENTED)");
 
   Array<Real>::matrix_iterator gradu_it =
       this->gradu(type).begin(spatial_dimension, spatial_dimension);
   Array<Real>::matrix_iterator gradu_end =
       this->gradu(type).begin(spatial_dimension, spatial_dimension);
   Array<Real>::matrix_iterator stress_it =
       this->stress(type).begin(spatial_dimension, spatial_dimension);
 
   UInt nb_quadrature_points = this->fem.getNbIntegrationPoints(type);
 
   gradu_it += index * nb_quadrature_points;
   gradu_end += (index + 1) * nb_quadrature_points;
   stress_it += index * nb_quadrature_points;
 
   Real * epot_quad = epot_on_quad_points.storage();
 
   Matrix<Real> grad_u(spatial_dimension, spatial_dimension);
 
   for (; gradu_it != gradu_end; ++gradu_it, ++stress_it, ++epot_quad) {
     grad_u.copy(*gradu_it);
 
     this->computePotentialEnergyOnQuad(grad_u, *stress_it, *epot_quad);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 INSTANTIATE_MATERIAL(elastic_orthotropic, MaterialElasticOrthotropic);
 
 } // akantu
diff --git a/src/model/solid_mechanics/materials/plane_stress_toolbox.hh b/src/model/solid_mechanics/materials/plane_stress_toolbox.hh
index d9fe6aca4..146f2d1a3 100644
--- a/src/model/solid_mechanics/materials/plane_stress_toolbox.hh
+++ b/src/model/solid_mechanics/materials/plane_stress_toolbox.hh
@@ -1,103 +1,103 @@
 /**
  * @file   plane_stress_toolbox.hh
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 16 2014
  * @date last modification: Tue Aug 18 2015
  *
  * @brief  Tools to implement the plane stress behavior in a material
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 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 "material.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_PLANE_STRESS_TOOLBOX_HH__
 #define __AKANTU_PLANE_STRESS_TOOLBOX_HH__
 
 namespace akantu {
 class SolidMechanicsModel;
 class FEEngine;
 }  // akantu
 
 
 namespace akantu {
 
 /**
  * Empty class in dimensions different from 2
  * This class is only specialized for 2D in the tmpl file
  */
 template <UInt dim, class ParentMaterial = Material>
 class PlaneStressToolbox : public ParentMaterial {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   PlaneStressToolbox(SolidMechanicsModel & model, const ID & id = "")
       : ParentMaterial(model, id) {}
   PlaneStressToolbox(SolidMechanicsModel & model, UInt spatial_dimension,
                      const Mesh & mesh, FEEngine & fe_engine,
                      const ID & id = "")
       : ParentMaterial(model, spatial_dimension, mesh, fe_engine, id) {}
 
   ~PlaneStressToolbox() override = default;
 
 protected:
   void initialize();
 
 public:
   void computeAllCauchyStresses(GhostType ghost_type = _not_ghost) override {
     ParentMaterial::computeAllCauchyStresses(ghost_type);
   }
 
   virtual void computeCauchyStressPlaneStress(ElementType /*el_type*/,
                                               GhostType /*ghost_type*/) {
     AKANTU_DEBUG_IN();
 
-    AKANTU_DEBUG_ERROR("The function \"computeCauchyStressPlaneStress\" can "
+    AKANTU_ERROR("The function \"computeCauchyStressPlaneStress\" can "
                        "only be used in 2D Plane stress problems, which means "
                        "that you made a mistake somewhere!! ");
 
     AKANTU_DEBUG_OUT();
   }
 
   virtual void computeThirdAxisDeformation(ElementType, GhostType) {}
 
 protected:
   bool initialize_third_axis_deformation{false};
 };
 
 #define AKANTU_PLANE_STRESS_TOOL_SPEC(dim)                                     \
   template <>                                                                  \
   inline PlaneStressToolbox<dim, Material>::PlaneStressToolbox(                \
       SolidMechanicsModel & model, const ID & id)                              \
       : Material(model, id) {}
 
 AKANTU_PLANE_STRESS_TOOL_SPEC(1)
 AKANTU_PLANE_STRESS_TOOL_SPEC(3)
 
 } // namespace akantu
 
 #include "plane_stress_toolbox_tmpl.hh"
 
 #endif /* __AKANTU_PLANE_STRESS_TOOLBOX_HH__ */
diff --git a/src/model/solid_mechanics/solid_mechanics_model.cc b/src/model/solid_mechanics/solid_mechanics_model.cc
index ed881af42..189e4a50d 100644
--- a/src/model/solid_mechanics/solid_mechanics_model.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model.cc
@@ -1,1195 +1,1195 @@
 /**
  * @file   solid_mechanics_model.cc
  *
  * @author Ramin Aghababaei <ramin.aghababaei@epfl.ch>
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Clement Roux <clement.roux@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue Jul 27 2010
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  Implementation of the SolidMechanicsModel class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "solid_mechanics_model.hh"
 #include "integrator_gauss.hh"
 #include "shape_lagrange.hh"
 #include "solid_mechanics_model_tmpl.hh"
 
 #include "communicator.hh"
 #include "element_synchronizer.hh"
 #include "sparse_matrix.hh"
 #include "synchronizer_registry.hh"
 
 #include "dumpable_inline_impl.hh"
 #ifdef AKANTU_USE_IOHELPER
 #include "dumper_iohelper_paraview.hh"
 #endif
 
 #include "material_non_local.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /**
  * A solid mechanics model need a mesh  and a dimension to be created. the model
  * by it  self can not  do a lot,  the good init  functions should be  called in
  * order to configure the model depending on what we want to do.
  *
  * @param  mesh mesh  representing  the model  we  want to  simulate
  * @param dim spatial  dimension of the problem, if dim =  0 (default value) the
  * dimension of the problem is assumed to be the on of the mesh
  * @param id an id to identify the model
  */
 SolidMechanicsModel::SolidMechanicsModel(Mesh & mesh, UInt dim, const ID & id,
                                          const MemoryID & memory_id, const ModelType model_type)
     : Model(mesh, model_type, dim, id, memory_id),
       BoundaryCondition<SolidMechanicsModel>(), f_m2a(1.0),
       displacement(nullptr), previous_displacement(nullptr),
       displacement_increment(nullptr), mass(nullptr), velocity(nullptr),
       acceleration(nullptr), external_force(nullptr), internal_force(nullptr),
       blocked_dofs(nullptr), current_position(nullptr),
       material_index("material index", id, memory_id),
       material_local_numbering("material local numbering", id, memory_id),
       increment_flag(false),
       are_materials_instantiated(false) {
   AKANTU_DEBUG_IN();
 
   this->registerFEEngineObject<MyFEEngineType>("SolidMechanicsFEEngine", mesh,
                                                Model::spatial_dimension);
 
 #if defined(AKANTU_USE_IOHELPER)
   this->mesh.registerDumper<DumperParaview>("paraview_all", id, true);
   this->mesh.addDumpMesh(mesh, Model::spatial_dimension, _not_ghost,
                          _ek_regular);
 #endif
 
   material_selector = std::make_shared<DefaultMaterialSelector>(material_index),
 
   this->initDOFManager();
 
   this->registerDataAccessor(*this);
 
   if (this->mesh.isDistributed()) {
     auto & synchronizer = this->mesh.getElementSynchronizer();
     this->registerSynchronizer(synchronizer, _gst_material_id);
     this->registerSynchronizer(synchronizer, _gst_smm_mass);
     this->registerSynchronizer(synchronizer, _gst_smm_stress);
     this->registerSynchronizer(synchronizer, _gst_smm_boundary);
     this->registerSynchronizer(synchronizer, _gst_for_dump);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 SolidMechanicsModel::~SolidMechanicsModel() {
   AKANTU_DEBUG_IN();
 
   for (auto & internal : this->registered_internals) {
     delete internal.second;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::setTimeStep(Real time_step, const ID & solver_id) {
   Model::setTimeStep(time_step, solver_id);
 
 #if defined(AKANTU_USE_IOHELPER)
   this->mesh.getDumper().setTimeStep(time_step);
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 /* Initialization                                                             */
 /* -------------------------------------------------------------------------- */
 /**
  * This function groups  many of the initialization in on  function. For most of
  * basics  case the  function should  be  enough. The  functions initialize  the
  * model, the internal  vectors, set them to 0, and  depending on the parameters
  * it also initialize the explicit or implicit solver.
  *
  * @param material_file the  file containing the materials to  use
  * @param method the analysis method wanted.  See the akantu::AnalysisMethod for
  * the different possibilities
  */
 void SolidMechanicsModel::initFullImpl(const ModelOptions & options) {
   material_index.initialize(mesh, _element_kind = _ek_not_defined,
                             _default_value = UInt(-1), _with_nb_element = true);
   material_local_numbering.initialize(mesh, _element_kind = _ek_not_defined,
                                       _with_nb_element = true);
 
   Model::initFullImpl(options);
 
   // initialize pbc
   if (this->pbc_pair.size() != 0)
     this->initPBC();
 
   // initialize the materials
   if (this->parser.getLastParsedFile() != "") {
     this->instantiateMaterials();
   }
 
   this->initMaterials();
 
   this->initBC(*this, *displacement, *displacement_increment, *external_force);
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolverType SolidMechanicsModel::getDefaultSolverType() const {
   return _tsst_dynamic_lumped;
 }
 
 /* -------------------------------------------------------------------------- */
 ModelSolverOptions SolidMechanicsModel::getDefaultSolverOptions(
     const TimeStepSolverType & type) const {
   ModelSolverOptions options;
 
   switch (type) {
   case _tsst_dynamic_lumped: {
     options.non_linear_solver_type = _nls_lumped;
     options.integration_scheme_type["displacement"] = _ist_central_difference;
     options.solution_type["displacement"] = IntegrationScheme::_acceleration;
     break;
   }
   case _tsst_static: {
     options.non_linear_solver_type = _nls_newton_raphson;
     options.integration_scheme_type["displacement"] = _ist_pseudo_time;
     options.solution_type["displacement"] = IntegrationScheme::_not_defined;
     break;
   }
   case _tsst_dynamic: {
     if (this->method == _explicit_consistent_mass) {
       options.non_linear_solver_type = _nls_newton_raphson;
       options.integration_scheme_type["displacement"] = _ist_central_difference;
       options.solution_type["displacement"] = IntegrationScheme::_acceleration;
     } else {
       options.non_linear_solver_type = _nls_newton_raphson;
       options.integration_scheme_type["displacement"] = _ist_trapezoidal_rule_2;
       options.solution_type["displacement"] = IntegrationScheme::_displacement;
     }
     break;
   }
   default:
     AKANTU_EXCEPTION(type << " is not a valid time step solver type");
   }
 
   return options;
 }
 
 /* -------------------------------------------------------------------------- */
 std::tuple<ID, TimeStepSolverType>
 SolidMechanicsModel::getDefaultSolverID(const AnalysisMethod & method) {
   switch (method) {
   case _explicit_lumped_mass: {
     return std::make_tuple("explicit_lumped", _tsst_dynamic_lumped);
   }
   case _explicit_consistent_mass: {
     return std::make_tuple("explicit", _tsst_dynamic);
   }
   case _static: {
     return std::make_tuple("static", _tsst_static);
   }
   case _implicit_dynamic: {
     return std::make_tuple("implicit", _tsst_dynamic);
   }
   default:
     return std::make_tuple("unknown", _tsst_not_defined);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::initSolver(TimeStepSolverType time_step_solver_type,
                                      NonLinearSolverType) {
   auto & dof_manager = this->getDOFManager();
 
   /* ------------------------------------------------------------------------ */
   // for alloc type of solvers
   this->allocNodalField(this->displacement, spatial_dimension, "displacement");
   this->allocNodalField(this->previous_displacement, spatial_dimension,
                         "previous_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->blocked_dofs, spatial_dimension, "blocked_dofs");
   this->allocNodalField(this->current_position, spatial_dimension,
                         "current_position");
 
   // initialize the current positions
   this->current_position->copy(this->mesh.getNodes());
 
   /* ------------------------------------------------------------------------ */
   if (!dof_manager.hasDOFs("displacement")) {
     dof_manager.registerDOFs("displacement", *this->displacement, _dst_nodal);
     dof_manager.registerBlockedDOFs("displacement", *this->blocked_dofs);
     dof_manager.registerDOFsIncrement("displacement",
                                       *this->displacement_increment);
     dof_manager.registerDOFsPrevious("displacement",
                                      *this->previous_displacement);
   }
 
   /* ------------------------------------------------------------------------ */
   // for dynamic
   if (time_step_solver_type == _tsst_dynamic ||
       time_step_solver_type == _tsst_dynamic_lumped) {
     this->allocNodalField(this->velocity, spatial_dimension, "velocity");
     this->allocNodalField(this->acceleration, spatial_dimension,
                           "acceleration");
 
     if (!dof_manager.hasDOFsDerivatives("displacement", 1)) {
       dof_manager.registerDOFsDerivative("displacement", 1, *this->velocity);
       dof_manager.registerDOFsDerivative("displacement", 2,
                                          *this->acceleration);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Initialize the model,basically it  pre-compute the shapes, shapes derivatives
  * and jacobian
  */
 void SolidMechanicsModel::initModel() {
   /// \todo add  the current position  as a parameter to  initShapeFunctions for
   /// large deformation
   getFEEngine().initShapeFunctions(_not_ghost);
   getFEEngine().initShapeFunctions(_ghost);
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleResidual() {
   AKANTU_DEBUG_IN();
 
   /* ------------------------------------------------------------------------ */
   // computes the internal forces
   this->assembleInternalForces();
 
   /* ------------------------------------------------------------------------ */
   this->getDOFManager().assembleToResidual("displacement",
                                            *this->external_force, 1);
   this->getDOFManager().assembleToResidual("displacement",
                                            *this->internal_force, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 MatrixType SolidMechanicsModel::getMatrixType(const ID & matrix_id) {
   // \TODO check the materials to know what is the correct answer
   if (matrix_id == "C")
     return _mt_not_defined;
 
   return _symmetric;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleMatrix(const ID & matrix_id) {
   if (matrix_id == "K") {
     this->assembleStiffnessMatrix();
   } else if (matrix_id == "M") {
     this->assembleMass();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleLumpedMatrix(const ID & matrix_id) {
   if (matrix_id == "M") {
     this->assembleMassLumped();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::beforeSolveStep() {
   for (auto & material : materials)
     material->beforeSolveStep();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::afterSolveStep() {
   for (auto & material : materials)
     material->afterSolveStep();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::predictor() { ++displacement_release; }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::corrector() { ++displacement_release; }
 
 /* -------------------------------------------------------------------------- */
 /**
  * This function computes the internal forces as F_{int} = \int_{\Omega} N
  * \sigma d\Omega@f$
  */
 void SolidMechanicsModel::assembleInternalForces() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Assemble the internal forces");
 
   this->internal_force->clear();
 
   // compute the stresses of local elements
   AKANTU_DEBUG_INFO("Compute local stresses");
   for (auto & material : materials) {
     material->computeAllStresses(_not_ghost);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Computation of the non local part */
   if (this->non_local_manager)
     this->non_local_manager->computeAllNonLocalStresses();
 
   // communicate the stresses
   AKANTU_DEBUG_INFO("Send data for residual assembly");
   this->asynchronousSynchronize(_gst_smm_stress);
 
   // assemble the forces due to local stresses
   AKANTU_DEBUG_INFO("Assemble residual for local elements");
   for (auto & material : materials) {
     material->assembleInternalForces(_not_ghost);
   }
 
   // finalize communications
   AKANTU_DEBUG_INFO("Wait distant stresses");
   this->waitEndSynchronize(_gst_smm_stress);
 
   // assemble the stresses due to ghost elements
   AKANTU_DEBUG_INFO("Assemble residual for ghost elements");
   for (auto & material : materials) {
     material->assembleInternalForces(_ghost);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleStiffnessMatrix() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Assemble the new stiffness matrix.");
 
   // Check if materials need to recompute the matrix
   bool need_to_reassemble = false;
 
   for (auto & material : materials) {
     need_to_reassemble |= material->hasStiffnessMatrixChanged();
   }
 
   if (need_to_reassemble) {
     this->getDOFManager().getMatrix("K").clear();
 
     // call compute stiffness matrix on each local elements
     for (auto & material : materials) {
       material->assembleStiffnessMatrix(_not_ghost);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::updateCurrentPosition() {
   if (this->current_position_release == this->displacement_release)
     return;
 
   this->current_position->copy(this->mesh.getNodes());
 
   auto cpos_it = this->current_position->begin(Model::spatial_dimension);
   auto cpos_end = this->current_position->end(Model::spatial_dimension);
   auto disp_it = this->displacement->begin(Model::spatial_dimension);
 
   for (; cpos_it != cpos_end; ++cpos_it, ++disp_it) {
     *cpos_it += *disp_it;
   }
 
   this->current_position_release = this->displacement_release;
 }
 
 /* -------------------------------------------------------------------------- */
 const Array<Real> & SolidMechanicsModel::getCurrentPosition() {
   this->updateCurrentPosition();
   return *this->current_position;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::updateDataForNonLocalCriterion(
     ElementTypeMapReal & criterion) {
   const ID field_name = criterion.getName();
   for (auto & material : materials) {
     if (!material->isInternal<Real>(field_name, _ek_regular))
       continue;
 
     for (auto ghost_type : ghost_types) {
       material->flattenInternal(field_name, criterion, ghost_type, _ek_regular);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 /* Information                                                                */
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getStableTimeStep() {
   AKANTU_DEBUG_IN();
 
   Real min_dt = getStableTimeStep(_not_ghost);
 
   /// reduction min over all processors
   mesh.getCommunicator().allReduce(min_dt, SynchronizerOperation::_min);
 
   AKANTU_DEBUG_OUT();
   return min_dt;
 }
 
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getStableTimeStep(const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   Real min_dt = std::numeric_limits<Real>::max();
 
   this->updateCurrentPosition();
 
   Element elem;
   elem.ghost_type = ghost_type;
 
   for (auto type :
        mesh.elementTypes(Model::spatial_dimension, ghost_type, _ek_regular)) {
     elem.type = type;
     UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
     UInt nb_element = mesh.getNbElement(type);
 
     auto mat_indexes = material_index(type, ghost_type).begin();
     auto mat_loc_num = material_local_numbering(type, ghost_type).begin();
 
     Array<Real> X(0, nb_nodes_per_element * Model::spatial_dimension);
     FEEngine::extractNodalToElementField(mesh, *current_position, X, type,
                                          _not_ghost);
 
     auto X_el = X.begin(Model::spatial_dimension, nb_nodes_per_element);
 
     for (UInt el = 0; el < nb_element;
          ++el, ++X_el, ++mat_indexes, ++mat_loc_num) {
       elem.element = *mat_loc_num;
       Real el_h = getFEEngine().getElementInradius(*X_el, type);
       Real el_c = this->materials[*mat_indexes]->getCelerity(elem);
       Real el_dt = el_h / el_c;
 
       min_dt = std::min(min_dt, el_dt);
     }
   }
 
   AKANTU_DEBUG_OUT();
   return min_dt;
 }
 
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getKineticEnergy() {
   AKANTU_DEBUG_IN();
 
   Real ekin = 0.;
   UInt nb_nodes = mesh.getNbNodes();
 
   if (this->getDOFManager().hasLumpedMatrix("M")) {
     auto m_it = this->mass->begin(Model::spatial_dimension);
     auto m_end = this->mass->end(Model::spatial_dimension);
     auto v_it = this->velocity->begin(Model::spatial_dimension);
 
     for (UInt n = 0; m_it != m_end; ++n, ++m_it, ++v_it) {
       const Vector<Real> & v = *v_it;
       const Vector<Real> & m = *m_it;
 
       Real mv2 = 0;
       bool is_local_node = mesh.isLocalOrMasterNode(n);
       // bool is_not_pbc_slave_node = !isPBCSlaveNode(n);
       bool count_node = is_local_node; // && is_not_pbc_slave_node;
       if (count_node) {
         for (UInt i = 0; i < Model::spatial_dimension; ++i) {
           if (m(i) > std::numeric_limits<Real>::epsilon())
             mv2 += v(i) * v(i) * m(i);
         }
       }
 
       ekin += mv2;
     }
   } else if (this->getDOFManager().hasMatrix("M")) {
     Array<Real> Mv(nb_nodes, Model::spatial_dimension);
     this->getDOFManager().getMatrix("M").matVecMul(*this->velocity, Mv);
 
     auto mv_it = Mv.begin(Model::spatial_dimension);
     auto mv_end = Mv.end(Model::spatial_dimension);
     auto v_it = this->velocity->begin(Model::spatial_dimension);
 
     for (; mv_it != mv_end; ++mv_it, ++v_it) {
       ekin += v_it->dot(*mv_it);
     }
   } else {
-    AKANTU_DEBUG_ERROR("No function called to assemble the mass matrix.");
+    AKANTU_ERROR("No function called to assemble the mass matrix.");
   }
 
   mesh.getCommunicator().allReduce(ekin, SynchronizerOperation::_sum);
 
   AKANTU_DEBUG_OUT();
   return ekin * .5;
 }
 
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getKineticEnergy(const ElementType & type,
                                            UInt index) {
   AKANTU_DEBUG_IN();
 
   UInt nb_quadrature_points = getFEEngine().getNbIntegrationPoints(type);
 
   Array<Real> vel_on_quad(nb_quadrature_points, Model::spatial_dimension);
   Array<UInt> filter_element(1, 1, index);
 
   getFEEngine().interpolateOnIntegrationPoints(*velocity, vel_on_quad,
                                                Model::spatial_dimension, type,
                                                _not_ghost, filter_element);
 
   Array<Real>::vector_iterator vit =
       vel_on_quad.begin(Model::spatial_dimension);
   Array<Real>::vector_iterator vend = vel_on_quad.end(Model::spatial_dimension);
 
   Vector<Real> rho_v2(nb_quadrature_points);
 
   Real rho = materials[material_index(type)(index)]->getRho();
 
   for (UInt q = 0; vit != vend; ++vit, ++q) {
     rho_v2(q) = rho * vit->dot(*vit);
   }
 
   AKANTU_DEBUG_OUT();
 
   return .5 * getFEEngine().integrate(rho_v2, type, index);
 }
 
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getExternalWork() {
   AKANTU_DEBUG_IN();
 
   auto ext_force_it = external_force->begin(Model::spatial_dimension);
   auto int_force_it = internal_force->begin(Model::spatial_dimension);
   auto boun_it = blocked_dofs->begin(Model::spatial_dimension);
 
   decltype(ext_force_it) incr_or_velo_it;
   if (this->method == _static) {
     incr_or_velo_it =
         this->displacement_increment->begin(Model::spatial_dimension);
   } else {
     incr_or_velo_it = this->velocity->begin(Model::spatial_dimension);
   }
 
   Real work = 0.;
 
   UInt nb_nodes = this->mesh.getNbNodes();
 
   for (UInt n = 0; n < nb_nodes;
        ++n, ++ext_force_it, ++int_force_it, ++boun_it, ++incr_or_velo_it) {
     const auto & int_force = *int_force_it;
     const auto & ext_force = *ext_force_it;
     const auto & boun = *boun_it;
     const auto & incr_or_velo = *incr_or_velo_it;
 
     bool is_local_node = this->mesh.isLocalOrMasterNode(n);
     // bool is_not_pbc_slave_node = !this->isPBCSlaveNode(n);
     bool count_node = is_local_node; // && is_not_pbc_slave_node;
 
     if (count_node) {
       for (UInt i = 0; i < Model::spatial_dimension; ++i) {
         if (boun(i))
           work -= int_force(i) * incr_or_velo(i);
         else
           work += ext_force(i) * incr_or_velo(i);
       }
     }
   }
 
   mesh.getCommunicator().allReduce(work, SynchronizerOperation::_sum);
 
   if (this->method != _static)
     work *= this->getTimeStep();
 
   AKANTU_DEBUG_OUT();
   return work;
 }
 
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getEnergy(const std::string & energy_id) {
   AKANTU_DEBUG_IN();
 
   if (energy_id == "kinetic") {
     return getKineticEnergy();
   } else if (energy_id == "external work") {
     return getExternalWork();
   }
 
   Real energy = 0.;
   for (auto & material : materials)
     energy += material->getEnergy(energy_id);
 
   /// reduction sum over all processors
   mesh.getCommunicator().allReduce(energy, SynchronizerOperation::_sum);
 
   AKANTU_DEBUG_OUT();
   return energy;
 }
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getEnergy(const std::string & energy_id,
                                     const ElementType & type, UInt index) {
   AKANTU_DEBUG_IN();
 
   if (energy_id == "kinetic") {
     return getKineticEnergy(type, index);
   }
 
   UInt mat_index = this->material_index(type, _not_ghost)(index);
   UInt mat_loc_num = this->material_local_numbering(type, _not_ghost)(index);
   Real energy =
       this->materials[mat_index]->getEnergy(energy_id, type, mat_loc_num);
 
   AKANTU_DEBUG_OUT();
   return energy;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::onElementsAdded(const Array<Element> & element_list,
                                           const NewElementsEvent & event) {
   AKANTU_DEBUG_IN();
 
   this->material_index.initialize(mesh, _element_kind = _ek_not_defined,
                                   _with_nb_element = true,
                                   _default_value = UInt(-1));
   this->material_local_numbering.initialize(
       mesh, _element_kind = _ek_not_defined, _with_nb_element = true,
       _default_value = UInt(-1));
 
   ElementTypeMapArray<UInt> filter("new_element_filter", this->getID(),
                                    this->getMemoryID());
 
   for (auto & elem : element_list) {
     if (!filter.exists(elem.type, elem.ghost_type))
       filter.alloc(0, 1, elem.type, elem.ghost_type);
     filter(elem.type, elem.ghost_type).push_back(elem.element);
   }
 
   this->assignMaterialToElements(&filter);
 
   for (auto & material : materials)
     material->onElementsAdded(element_list, event);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::onElementsRemoved(
     const Array<Element> & element_list,
     const ElementTypeMapArray<UInt> & new_numbering,
     const RemovedElementsEvent & event) {
   for (auto & material : materials) {
     material->onElementsRemoved(element_list, new_numbering, event);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::onNodesAdded(const Array<UInt> & nodes_list,
                                        const NewNodesEvent & event) {
   AKANTU_DEBUG_IN();
   UInt nb_nodes = mesh.getNbNodes();
 
   if (displacement) {
     displacement->resize(nb_nodes, 0.);
     ++displacement_release;
   }
   if (mass)
     mass->resize(nb_nodes, 0.);
   if (velocity)
     velocity->resize(nb_nodes, 0.);
   if (acceleration)
     acceleration->resize(nb_nodes, 0.);
   if (external_force)
     external_force->resize(nb_nodes, 0.);
   if (internal_force)
     internal_force->resize(nb_nodes, 0.);
   if (blocked_dofs)
     blocked_dofs->resize(nb_nodes, 0.);
   if (current_position)
     current_position->resize(nb_nodes, 0.);
 
   if (previous_displacement)
     previous_displacement->resize(nb_nodes, 0.);
   if (displacement_increment)
     displacement_increment->resize(nb_nodes, 0.);
 
   for (auto & material : materials) {
     material->onNodesAdded(nodes_list, event);
   }
 
   need_to_reassemble_lumped_mass = true;
   need_to_reassemble_mass = true;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::onNodesRemoved(const Array<UInt> & /*element_list*/,
                                          const Array<UInt> & new_numbering,
                                          const RemovedNodesEvent & /*event*/) {
   if (displacement) {
     mesh.removeNodesFromArray(*displacement, new_numbering);
     ++displacement_release;
   }
   if (mass)
     mesh.removeNodesFromArray(*mass, new_numbering);
   if (velocity)
     mesh.removeNodesFromArray(*velocity, new_numbering);
   if (acceleration)
     mesh.removeNodesFromArray(*acceleration, new_numbering);
   if (internal_force)
     mesh.removeNodesFromArray(*internal_force, new_numbering);
   if (external_force)
     mesh.removeNodesFromArray(*external_force, new_numbering);
   if (blocked_dofs)
     mesh.removeNodesFromArray(*blocked_dofs, new_numbering);
 
   // if (increment_acceleration)
   //   mesh.removeNodesFromArray(*increment_acceleration, new_numbering);
   if (displacement_increment)
     mesh.removeNodesFromArray(*displacement_increment, new_numbering);
 
   if (previous_displacement)
     mesh.removeNodesFromArray(*previous_displacement, new_numbering);
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "Solid 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 << " + nodals information [" << std::endl;
   displacement->printself(stream, indent + 2);
   if (velocity)
     velocity->printself(stream, indent + 2);
   if (acceleration)
     acceleration->printself(stream, indent + 2);
   if (mass)
     mass->printself(stream, indent + 2);
   external_force->printself(stream, indent + 2);
   internal_force->printself(stream, indent + 2);
   blocked_dofs->printself(stream, indent + 2);
   stream << space << AKANTU_INDENT << "]" << std::endl;
 
   stream << space << " + material information [" << std::endl;
   material_index.printself(stream, indent + 2);
   stream << space << AKANTU_INDENT << "]" << std::endl;
 
   stream << space << " + materials [" << std::endl;
   for (auto & material : materials) {
     material->printself(stream, indent + 1);
   }
   stream << space << AKANTU_INDENT << "]" << std::endl;
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::initializeNonLocal() {
   this->non_local_manager->synchronize(*this, _gst_material_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::insertIntegrationPointsInNeighborhoods(
     const GhostType & ghost_type) {
   for (auto & mat : materials) {
     MaterialNonLocalInterface * mat_non_local;
     if ((mat_non_local =
              dynamic_cast<MaterialNonLocalInterface *>(mat.get())) == nullptr)
       continue;
 
     ElementTypeMapArray<Real> quadrature_points_coordinates(
         "quadrature_points_coordinates_tmp_nl", this->id, this->memory_id);
     quadrature_points_coordinates.initialize(this->getFEEngine(),
                                              _nb_component = spatial_dimension,
                                              _ghost_type = ghost_type);
 
     for (auto & type : quadrature_points_coordinates.elementTypes(
              Model::spatial_dimension, ghost_type)) {
       this->getFEEngine().computeIntegrationPointsCoordinates(
           quadrature_points_coordinates(type, ghost_type), type, ghost_type);
     }
 
     mat_non_local->initMaterialNonLocal();
 
     mat_non_local->insertIntegrationPointsInNeighborhoods(
         ghost_type, quadrature_points_coordinates);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::computeNonLocalStresses(
     const GhostType & ghost_type) {
   for (auto & mat : materials) {
     if (dynamic_cast<MaterialNonLocalInterface *>(mat.get()) == nullptr)
       continue;
 
     auto & mat_non_local = dynamic_cast<MaterialNonLocalInterface &>(*mat);
     mat_non_local.computeNonLocalStresses(ghost_type);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::updateLocalInternal(
     ElementTypeMapReal & internal_flat, const GhostType & ghost_type,
     const ElementKind & kind) {
   const ID field_name = internal_flat.getName();
   for (auto & material : materials) {
     if (material->isInternal<Real>(field_name, kind))
       material->flattenInternal(field_name, internal_flat, ghost_type, kind);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::updateNonLocalInternal(
     ElementTypeMapReal & internal_flat, const GhostType & ghost_type,
     const ElementKind & kind) {
 
   const ID field_name = internal_flat.getName();
 
   for (auto & mat : materials) {
     if (dynamic_cast<MaterialNonLocalInterface *>(mat.get()) == nullptr)
       continue;
 
     auto & mat_non_local = dynamic_cast<MaterialNonLocalInterface &>(*mat);
     mat_non_local.updateNonLocalInternals(internal_flat, field_name, ghost_type,
                                           kind);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 FEEngine & SolidMechanicsModel::getFEEngineBoundary(const ID & name) {
   return dynamic_cast<FEEngine &>(
       getFEEngineClassBoundary<MyFEEngineType>(name));
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::splitElementByMaterial(
     const Array<Element> & elements,
     std::vector<Array<Element>> & elements_per_mat) const {
   ElementType current_element_type = _not_defined;
   GhostType current_ghost_type = _casper;
   const Array<UInt> * mat_indexes = nullptr;
   const Array<UInt> * mat_loc_num = nullptr;
 
   for (const auto & el : elements) {
     if (el.type != current_element_type ||
         el.ghost_type != current_ghost_type) {
       current_element_type = el.type;
       current_ghost_type = el.ghost_type;
       mat_indexes = &(this->material_index(el.type, el.ghost_type));
       mat_loc_num = &(this->material_local_numbering(el.type, el.ghost_type));
     }
 
     Element mat_el = el;
 
     mat_el.element = (*mat_loc_num)(el.element);
     elements_per_mat[(*mat_indexes)(el.element)].push_back(mat_el);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 UInt SolidMechanicsModel::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);
   }
 
   switch (tag) {
   case _gst_material_id: {
     size += elements.size() * sizeof(UInt);
     break;
   }
   case _gst_smm_mass: {
     size += nb_nodes_per_element * sizeof(Real) *
             Model::spatial_dimension; // mass vector
     break;
   }
   case _gst_smm_for_gradu: {
     size += nb_nodes_per_element * Model::spatial_dimension *
             sizeof(Real); // displacement
     break;
   }
   case _gst_smm_boundary: {
     // force, displacement, boundary
     size += nb_nodes_per_element * Model::spatial_dimension *
             (2 * sizeof(Real) + sizeof(bool));
     break;
   }
   case _gst_for_dump: {
     // displacement, velocity, acceleration, residual, force
     size += nb_nodes_per_element * Model::spatial_dimension * sizeof(Real) * 5;
     break;
   }
   default: {}
   }
 
   if (tag != _gst_material_id) {
     splitByMaterial(elements, [&](auto && mat, auto && elements) {
       size += mat.getNbData(elements, tag);
     });
   }
 
   AKANTU_DEBUG_OUT();
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::packData(CommunicationBuffer & buffer,
                                    const Array<Element> & elements,
                                    const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   switch (tag) {
   case _gst_material_id: {
     this->packElementalDataHelper(material_index, buffer, elements, false,
                                   getFEEngine());
     break;
   }
   case _gst_smm_mass: {
     packNodalDataHelper(*mass, buffer, elements, mesh);
     break;
   }
   case _gst_smm_for_gradu: {
     packNodalDataHelper(*displacement, buffer, elements, mesh);
     break;
   }
   case _gst_for_dump: {
     packNodalDataHelper(*displacement, buffer, elements, mesh);
     packNodalDataHelper(*velocity, buffer, elements, mesh);
     packNodalDataHelper(*acceleration, buffer, elements, mesh);
     packNodalDataHelper(*internal_force, buffer, elements, mesh);
     packNodalDataHelper(*external_force, buffer, elements, mesh);
     break;
   }
   case _gst_smm_boundary: {
     packNodalDataHelper(*external_force, buffer, elements, mesh);
     packNodalDataHelper(*velocity, buffer, elements, mesh);
     packNodalDataHelper(*blocked_dofs, buffer, elements, mesh);
     break;
   }
   default: {}
   }
 
   if (tag != _gst_material_id) {
     splitByMaterial(elements, [&](auto && mat, auto && elements) {
       mat.packData(buffer, elements, tag);
     });
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::unpackData(CommunicationBuffer & buffer,
                                      const Array<Element> & elements,
                                      const SynchronizationTag & tag) {
   AKANTU_DEBUG_IN();
 
   switch (tag) {
   case _gst_material_id: {
     for (auto && element : elements) {
       UInt recv_mat_index;
       buffer >> recv_mat_index;
       UInt & mat_index = material_index(element);
       if (mat_index != UInt(-1))
         continue;
 
       // add ghosts element to the correct material
       mat_index = recv_mat_index;
       UInt index = materials[mat_index]->addElement(element);
       material_local_numbering(element) = index;
     }
     break;
   }
   case _gst_smm_mass: {
     unpackNodalDataHelper(*mass, buffer, elements, mesh);
     break;
   }
   case _gst_smm_for_gradu: {
     unpackNodalDataHelper(*displacement, buffer, elements, mesh);
     break;
   }
   case _gst_for_dump: {
     unpackNodalDataHelper(*displacement, buffer, elements, mesh);
     unpackNodalDataHelper(*velocity, buffer, elements, mesh);
     unpackNodalDataHelper(*acceleration, buffer, elements, mesh);
     unpackNodalDataHelper(*internal_force, buffer, elements, mesh);
     unpackNodalDataHelper(*external_force, buffer, elements, mesh);
     break;
   }
   case _gst_smm_boundary: {
     unpackNodalDataHelper(*external_force, buffer, elements, mesh);
     unpackNodalDataHelper(*velocity, buffer, elements, mesh);
     unpackNodalDataHelper(*blocked_dofs, buffer, elements, mesh);
     break;
   }
   default: {}
   }
 
   if (tag != _gst_material_id) {
     splitByMaterial(elements, [&](auto && mat, auto && elements) {
       mat.unpackData(buffer, elements, tag);
     });
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 UInt SolidMechanicsModel::getNbData(const Array<UInt> & dofs,
                                     const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
   //  UInt nb_nodes = mesh.getNbNodes();
 
   switch (tag) {
   case _gst_smm_uv: {
     size += sizeof(Real) * Model::spatial_dimension * 2;
     break;
   }
   case _gst_smm_res: {
     size += sizeof(Real) * Model::spatial_dimension;
     break;
   }
   case _gst_smm_mass: {
     size += sizeof(Real) * Model::spatial_dimension;
     break;
   }
   case _gst_for_dump: {
     size += sizeof(Real) * Model::spatial_dimension * 5;
     break;
   }
   default: {
-    AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
+    AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   AKANTU_DEBUG_OUT();
   return size * dofs.size();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::packData(CommunicationBuffer & buffer,
                                    const Array<UInt> & dofs,
                                    const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   switch (tag) {
   case _gst_smm_uv: {
     packDOFDataHelper(*displacement, buffer, dofs);
     packDOFDataHelper(*velocity, buffer, dofs);
     break;
   }
   case _gst_smm_res: {
     packDOFDataHelper(*internal_force, buffer, dofs);
     break;
   }
   case _gst_smm_mass: {
     packDOFDataHelper(*mass, buffer, dofs);
     break;
   }
   case _gst_for_dump: {
     packDOFDataHelper(*displacement, buffer, dofs);
     packDOFDataHelper(*velocity, buffer, dofs);
     packDOFDataHelper(*acceleration, buffer, dofs);
     packDOFDataHelper(*internal_force, buffer, dofs);
     packDOFDataHelper(*external_force, buffer, dofs);
     break;
   }
   default: {
-    AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
+    AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::unpackData(CommunicationBuffer & buffer,
                                      const Array<UInt> & dofs,
                                      const SynchronizationTag & tag) {
   AKANTU_DEBUG_IN();
 
   switch (tag) {
   case _gst_smm_uv: {
     unpackDOFDataHelper(*displacement, buffer, dofs);
     unpackDOFDataHelper(*velocity, buffer, dofs);
     break;
   }
   case _gst_smm_res: {
     unpackDOFDataHelper(*internal_force, buffer, dofs);
     break;
   }
   case _gst_smm_mass: {
     unpackDOFDataHelper(*mass, buffer, dofs);
     break;
   }
   case _gst_for_dump: {
     unpackDOFDataHelper(*displacement, buffer, dofs);
     unpackDOFDataHelper(*velocity, buffer, dofs);
     unpackDOFDataHelper(*acceleration, buffer, dofs);
     unpackDOFDataHelper(*internal_force, buffer, dofs);
     unpackDOFDataHelper(*external_force, buffer, dofs);
     break;
   }
   default: {
-    AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
+    AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/solid_mechanics_model_cohesive/materials/constitutive_laws/material_cohesive_bilinear.cc b/src/model/solid_mechanics/solid_mechanics_model_cohesive/materials/constitutive_laws/material_cohesive_bilinear.cc
index ee385f8e6..5e3d137d6 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_cohesive/materials/constitutive_laws/material_cohesive_bilinear.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_cohesive/materials/constitutive_laws/material_cohesive_bilinear.cc
@@ -1,219 +1,219 @@
 /**
  * @file   material_cohesive_bilinear.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Feb 22 2012
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Bilinear cohesive constitutive law
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "material_cohesive_bilinear.hh"
 //#include "solid_mechanics_model_cohesive.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 MaterialCohesiveBilinear<spatial_dimension>::MaterialCohesiveBilinear(
     SolidMechanicsModel & model, const ID & id)
     : MaterialCohesiveLinear<spatial_dimension>(model, id) {
   AKANTU_DEBUG_IN();
 
   this->registerParam("delta_0", delta_0, Real(0.),
                       _pat_parsable | _pat_readable,
                       "Elastic limit displacement");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveBilinear<spatial_dimension>::initMaterial() {
   AKANTU_DEBUG_IN();
 
   this->sigma_c_eff.setRandomDistribution(this->sigma_c.getRandomParameter());
   MaterialCohesiveLinear<spatial_dimension>::initMaterial();
 
   this->delta_max.setDefaultValue(delta_0);
   this->insertion_stress.setDefaultValue(0);
 
   this->delta_max.reset();
   this->insertion_stress.reset();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveBilinear<spatial_dimension>::onElementsAdded(
     const Array<Element> & element_list, const NewElementsEvent & event) {
   AKANTU_DEBUG_IN();
 
   MaterialCohesiveLinear<spatial_dimension>::onElementsAdded(element_list,
                                                              event);
 
   bool scale_traction = false;
 
   // don't scale sigma_c if volume_s hasn't been specified by the user
   if (!Math::are_float_equal(this->volume_s, 0.))
     scale_traction = true;
 
   Array<Element>::const_scalar_iterator el_it = element_list.begin();
   Array<Element>::const_scalar_iterator el_end = element_list.end();
 
   for (; el_it != el_end; ++el_it) {
     // filter not ghost cohesive elements
     if (el_it->ghost_type != _not_ghost ||
         Mesh::getKind(el_it->type) != _ek_cohesive)
       continue;
 
     UInt index = el_it->element;
     ElementType type = el_it->type;
     UInt nb_element = this->model->getMesh().getNbElement(type);
     UInt nb_quad_per_element = this->fem_cohesive.getNbIntegrationPoints(type);
 
     Array<Real>::vector_iterator sigma_c_begin =
         this->sigma_c_eff(type).begin_reinterpret(nb_quad_per_element,
                                                   nb_element);
     Vector<Real> sigma_c_vec = sigma_c_begin[index];
 
     Array<Real>::vector_iterator delta_c_begin =
         this->delta_c_eff(type).begin_reinterpret(nb_quad_per_element,
                                                   nb_element);
     Vector<Real> delta_c_vec = delta_c_begin[index];
 
     if (scale_traction)
       scaleTraction(*el_it, sigma_c_vec);
 
     /**
      * Recompute sigma_c as
      * @f$ {\sigma_c}_\textup{new} =
      * \frac{{\sigma_c}_\textup{old} \delta_c} {\delta_c - \delta_0} @f$
      */
 
     for (UInt q = 0; q < nb_quad_per_element; ++q) {
       delta_c_vec(q) = 2 * this->G_c / sigma_c_vec(q);
 
       if (delta_c_vec(q) - delta_0 < Math::getTolerance())
-        AKANTU_DEBUG_ERROR("delta_0 = "
+        AKANTU_ERROR("delta_0 = "
                            << delta_0 << " must be lower than delta_c = "
                            << delta_c_vec(q) << ", modify your material file");
 
       sigma_c_vec(q) *= delta_c_vec(q) / (delta_c_vec(q) - delta_0);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveBilinear<spatial_dimension>::scaleTraction(
     const Element & el, Vector<Real> & sigma_c_vec) {
   AKANTU_DEBUG_IN();
 
   Real base_sigma_c = this->sigma_c_eff;
 
   const Mesh & mesh_facets = this->model->getMeshFacets();
   const FEEngine & fe_engine = this->model->getFEEngine();
 
   auto coh_element_to_facet_begin =
       mesh_facets.getSubelementToElement(el.type).begin(2);
   const Vector<Element> & coh_element_to_facet =
       coh_element_to_facet_begin[el.element];
 
   // compute bounding volume
   Real volume = 0;
 
   // loop over facets
   for (UInt f = 0; f < 2; ++f) {
     const Element & facet = coh_element_to_facet(f);
 
     const Array<std::vector<Element>> & facet_to_element =
         mesh_facets.getElementToSubelement(facet.type, facet.ghost_type);
 
     const std::vector<Element> & element_list = facet_to_element(facet.element);
 
     auto elem = element_list.begin();
     auto elem_end = element_list.end();
 
     // loop over elements connected to each facet
     for (; elem != elem_end; ++elem) {
       // skip cohesive elements and dummy elements
       if (*elem == ElementNull || Mesh::getKind(elem->type) == _ek_cohesive)
         continue;
 
       // unit vector for integration in order to obtain the volume
       UInt nb_quadrature_points = fe_engine.getNbIntegrationPoints(elem->type);
       Vector<Real> unit_vector(nb_quadrature_points, 1);
 
       volume += fe_engine.integrate(unit_vector, elem->type, elem->element,
                                     elem->ghost_type);
     }
   }
 
   // scale sigma_c
   sigma_c_vec -= base_sigma_c;
   sigma_c_vec *= std::pow(this->volume_s / volume, 1. / this->m_s);
   sigma_c_vec += base_sigma_c;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveBilinear<spatial_dimension>::computeTraction(
     const Array<Real> & normal, ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
   MaterialCohesiveLinear<spatial_dimension>::computeTraction(normal, el_type,
                                                              ghost_type);
 
   // adjust damage
   Array<Real>::scalar_iterator delta_c_it =
       this->delta_c_eff(el_type, ghost_type).begin();
 
   Array<Real>::scalar_iterator delta_max_it =
       this->delta_max(el_type, ghost_type).begin();
 
   Array<Real>::scalar_iterator damage_it =
       this->damage(el_type, ghost_type).begin();
 
   Array<Real>::scalar_iterator damage_end =
       this->damage(el_type, ghost_type).end();
 
   for (; damage_it != damage_end; ++damage_it, ++delta_max_it, ++delta_c_it) {
     *damage_it =
         std::max((*delta_max_it - delta_0) / (*delta_c_it - delta_0), Real(0.));
     *damage_it = std::min(*damage_it, Real(1.));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 INSTANTIATE_MATERIAL(cohesive_bilinear, MaterialCohesiveBilinear);
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/solid_mechanics_model_cohesive/materials/constitutive_laws/material_cohesive_linear_fatigue.cc b/src/model/solid_mechanics/solid_mechanics_model_cohesive/materials/constitutive_laws/material_cohesive_linear_fatigue.cc
index 2bdfb7b2f..aeffe864e 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_cohesive/materials/constitutive_laws/material_cohesive_linear_fatigue.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_cohesive/materials/constitutive_laws/material_cohesive_linear_fatigue.cc
@@ -1,296 +1,296 @@
 /**
  * @file   material_cohesive_linear_fatigue.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Feb 20 2015
  * @date last modification: Tue Jan 12 2016
  *
  * @brief  See material_cohesive_linear_fatigue.hh for information
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 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 "material_cohesive_linear_fatigue.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 MaterialCohesiveLinearFatigue<spatial_dimension>
 ::MaterialCohesiveLinearFatigue(SolidMechanicsModel & model,
 				const ID & id) :
   MaterialCohesiveLinear<spatial_dimension>(model, id),
   delta_prec("delta_prec", *this),
   K_plus("K_plus", *this),
   K_minus("K_minus", *this),
   T_1d("T_1d", *this),
   switches("switches", *this),
   delta_dot_prec("delta_dot_prec", *this),
   normal_regime("normal_regime", *this) {
 
   this->registerParam("delta_f", delta_f, Real(-1.) ,
 		      _pat_parsable | _pat_readable,
 		      "delta_f");
 
   this->registerParam("progressive_delta_f", progressive_delta_f, false,
 		      _pat_parsable | _pat_readable,
 		      "Whether or not delta_f is equal to delta_max");
 
   this->registerParam("count_switches", count_switches, false,
 		      _pat_parsable | _pat_readable,
 		      "Count the opening/closing switches per element");
 
   this->registerParam("fatigue_ratio", fatigue_ratio, Real(1.),
 		      _pat_parsable | _pat_readable,
 		      "What portion of the cohesive law is subjected to fatigue");
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveLinearFatigue<spatial_dimension>::initMaterial() {
   MaterialCohesiveLinear<spatial_dimension>::initMaterial();
 
   // check that delta_f has a proper value or assign a defaul value
   if (delta_f < 0) delta_f = this->delta_c_eff;
   else if (delta_f < this->delta_c_eff)
-    AKANTU_DEBUG_ERROR("Delta_f must be greater or equal to delta_c");
+    AKANTU_ERROR("Delta_f must be greater or equal to delta_c");
 
   delta_prec.initialize(1);
   K_plus.initialize(1);
   K_minus.initialize(1);
   T_1d.initialize(1);
   normal_regime.initialize(1);
 
   if (count_switches) {
     switches.initialize(1);
     delta_dot_prec.initialize(1);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template<UInt spatial_dimension>
 void MaterialCohesiveLinearFatigue<spatial_dimension>
 ::computeTraction(const Array<Real> & normal,
 		  ElementType el_type,
 		  GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   /// define iterators
   Array<Real>::vector_iterator traction_it =
     this->tractions(el_type, ghost_type).begin(spatial_dimension);
 
   Array<Real>::vector_iterator opening_it =
     this->opening(el_type, ghost_type).begin(spatial_dimension);
 
   Array<Real>::vector_iterator contact_traction_it =
     this->contact_tractions(el_type, ghost_type).begin(spatial_dimension);
 
   Array<Real>::vector_iterator contact_opening_it =
     this->contact_opening(el_type, ghost_type).begin(spatial_dimension);
 
   Array<Real>::const_vector_iterator normal_it = normal.begin(spatial_dimension);
 
   Array<Real>::vector_iterator traction_end =
     this->tractions(el_type, ghost_type).end(spatial_dimension);
 
   const Array<Real> & sigma_c_array = this->sigma_c_eff(el_type, ghost_type);
   Array<Real> & delta_max_array = this->delta_max(el_type, ghost_type);
   const Array<Real> & delta_c_array = this->delta_c_eff(el_type, ghost_type);
   Array<Real> & damage_array = this->damage(el_type, ghost_type);
 
   Array<Real>::vector_iterator insertion_stress_it =
     this->insertion_stress(el_type, ghost_type).begin(spatial_dimension);
 
   Array<Real> & delta_prec_array = delta_prec(el_type, ghost_type);
   Array<Real> & K_plus_array = K_plus(el_type, ghost_type);
   Array<Real> & K_minus_array = K_minus(el_type, ghost_type);
   Array<Real> & T_1d_array = T_1d(el_type, ghost_type);
   Array<bool> & normal_regime_array = normal_regime(el_type, ghost_type);
 
   Array<UInt> * switches_array = nullptr;
   Array<Real> * delta_dot_prec_array = nullptr;
 
   if (count_switches) {
     switches_array = &switches(el_type, ghost_type);
     delta_dot_prec_array = &delta_dot_prec(el_type, ghost_type);
   }
 
   auto * memory_space = new Real[2 * spatial_dimension];
   Vector<Real> normal_opening(memory_space, spatial_dimension);
   Vector<Real> tangential_opening(memory_space + spatial_dimension,
 				  spatial_dimension);
 
   Real tolerance = Math::getTolerance();
 
   /// loop on each quadrature point
   for (UInt q = 0; traction_it != traction_end;
        ++traction_it, ++opening_it, ++normal_it,
 	 ++contact_traction_it, ++insertion_stress_it, ++contact_opening_it, ++q) {
 
     /// compute normal and tangential opening vectors
     Real normal_opening_norm = opening_it->dot(*normal_it);
     normal_opening  = (*normal_it);
     normal_opening *= normal_opening_norm;
 
     tangential_opening  = *opening_it;
     tangential_opening -=  normal_opening;
 
     Real tangential_opening_norm = tangential_opening.norm();
 
     /**
      * compute effective opening displacement
      * @f$ \delta = \sqrt{
      * \frac{\beta^2}{\kappa^2} \Delta_t^2 + \Delta_n^2 } @f$
      */
     Real delta = tangential_opening_norm * tangential_opening_norm * this->beta2_kappa2;
 
     bool penetration = normal_opening_norm < -tolerance;
     if (this->contact_after_breaking == false && Math::are_float_equal(damage_array(q), 1.))
       penetration = false;
 
     if (penetration) {
       /// use penalty coefficient in case of penetration
       *contact_traction_it = normal_opening;
       *contact_traction_it *= this->penalty;
       *contact_opening_it = normal_opening;
       /// don't consider penetration contribution for delta
       *opening_it = tangential_opening;
       normal_opening.clear();
     }
     else {
       delta += normal_opening_norm * normal_opening_norm;
       contact_traction_it->clear();
       contact_opening_it->clear();
     }
 
     delta = std::sqrt(delta);
 
     /**
      * Compute traction @f$ \mathbf{T} = \left(
      * \frac{\beta^2}{\kappa} \Delta_t \mathbf{t} + \Delta_n
      * \mathbf{n} \right) \frac{\sigma_c}{\delta} \left( 1-
      * \frac{\delta}{\delta_c} \right)@f$
      */
 
 
     // update maximum displacement and damage
     delta_max_array(q) = std::max(delta, delta_max_array(q));
     damage_array(q) = std::min(delta_max_array(q) / delta_c_array(q), Real(1.));
 
     Real delta_dot = delta - delta_prec_array(q);
 
     // count switches if asked
     if (count_switches) {
       if ( (delta_dot > 0. && (*delta_dot_prec_array)(q) <= 0.) ||
 	   (delta_dot < 0. && (*delta_dot_prec_array)(q) >= 0.) )
 	++((*switches_array)(q));
 
       (*delta_dot_prec_array)(q) = delta_dot;
     }
 
     // set delta_f equal to delta_max if desired
     if (progressive_delta_f) delta_f = delta_max_array(q);
 
     // broken element case
     if (Math::are_float_equal(damage_array(q), 1.))
       traction_it->clear();
     // just inserted element case
     else if (Math::are_float_equal(damage_array(q), 0.)) {
       if (penetration)
 	traction_it->clear();
       else
 	*traction_it = *insertion_stress_it;
       // initialize the 1d traction to sigma_c
       T_1d_array(q) = sigma_c_array(q);
     }
     // normal case
     else {
       // if element is closed then there are zero tractions
       if (delta <= tolerance)
 	traction_it->clear();
       // otherwise compute new tractions if the new delta is different
       // than the previous one
       else if (std::abs(delta_dot) > tolerance) {
 	// loading case
 	if (delta_dot > 0.) {
 	  if (!normal_regime_array(q)) {
 	    // equation (4) of the article
 	    K_plus_array(q) *= 1. - delta_dot / delta_f;
 	    // equivalent to equation (2) of the article
 	    T_1d_array(q) += K_plus_array(q) * delta_dot;
 
 	    // in case of reloading, traction must not exceed that of the
 	    // envelop of the cohesive law
 	    Real max_traction = sigma_c_array(q) * (1 - delta / delta_c_array(q));
 	    bool max_traction_exceeded = T_1d_array(q) > max_traction;
 	    if (max_traction_exceeded) T_1d_array(q) = max_traction;
 
 	    // switch to standard linear cohesive law
 	    if (delta_max_array(q) > fatigue_ratio * delta_c_array(q)) {
 	      // reset delta_max to avoid big jumps in the traction
 	      delta_max_array(q) = sigma_c_array(q) / (T_1d_array(q) / delta + sigma_c_array(q) / delta_c_array(q));
 	      damage_array(q) = std::min(delta_max_array(q) / delta_c_array(q), Real(1.));
 	      K_minus_array(q) = sigma_c_array(q) / delta_max_array(q) * (1. - damage_array(q));
 	      normal_regime_array(q) = true;
 	    } else {
 	      // equation (3) of the article
 	      K_minus_array(q) = T_1d_array(q) / delta;
 
 	      // if the traction is following the cohesive envelop, then
 	      // K_plus has to be reset
 	      if (max_traction_exceeded) K_plus_array(q) = K_minus_array(q);
 	    }
 	  } else {
 	    // compute stiffness according to the standard law
 	    K_minus_array(q) = sigma_c_array(q) / delta_max_array(q) * (1. - damage_array(q));
 	  }
 	}
 	// unloading case
 	else if (!normal_regime_array(q)) {
 	  // equation (4) of the article
 	  K_plus_array(q) += (K_plus_array(q) - K_minus_array(q)) * delta_dot / delta_f;
 	  // equivalent to equation (2) of the article
 	  T_1d_array(q) = K_minus_array(q) * delta;
 	}
 
 	// applying the actual stiffness
 	*traction_it  = tangential_opening;
 	*traction_it *= this->beta2_kappa;
 	*traction_it += normal_opening;
 	*traction_it *= K_minus_array(q);
       }
     }
 
     // update precendent delta
     delta_prec_array(q) = delta;
   }
 
   delete [] memory_space;
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 INSTANTIATE_MATERIAL(cohesive_linear_fatigue, MaterialCohesiveLinearFatigue);
 
 
 } // akantu
diff --git a/src/model/solid_mechanics/solid_mechanics_model_cohesive/materials/material_cohesive.hh b/src/model/solid_mechanics/solid_mechanics_model_cohesive/materials/material_cohesive.hh
index 596297cc9..09079fc7a 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_cohesive/materials/material_cohesive.hh
+++ b/src/model/solid_mechanics/solid_mechanics_model_cohesive/materials/material_cohesive.hh
@@ -1,251 +1,251 @@
 /**
  * @file   material_cohesive.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Seyedeh Mohadeseh Taheri Mousavi <mohadeseh.taherimousavi@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Jan 12 2016
  *
  * @brief  Specialization of the material class for cohesive elements
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "material.hh"
 /* -------------------------------------------------------------------------- */
 #include "cohesive_internal_field.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_COHESIVE_HH__
 #define __AKANTU_MATERIAL_COHESIVE_HH__
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 class SolidMechanicsModelCohesive;
 }
 
 namespace akantu {
 
 class MaterialCohesive : public Material {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   using MyFEEngineCohesiveType =
       FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_cohesive>;
 
 public:
   MaterialCohesive(SolidMechanicsModel & model, const ID & id = "");
   ~MaterialCohesive() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// initialize the material computed parameter
   void initMaterial() override;
 
   /// compute tractions (including normals and openings)
   void computeTraction(GhostType ghost_type = _not_ghost);
 
   /// assemble residual
   void assembleInternalForces(GhostType ghost_type = _not_ghost) override;
 
     /// check stress for cohesive elements' insertion, by default it
   /// also updates the cohesive elements' data
   virtual void checkInsertion(bool /*check_only*/ = false) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// check delta_max for cohesive elements in case of no convergence
   /// in the solveStep (only for extrinsic-implicit)
   virtual void checkDeltaMax(GhostType /*ghost_type*/ = _not_ghost) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// reset variables when convergence is reached (only for
   /// extrinsic-implicit)
   virtual void resetVariables(GhostType /*ghost_type*/ = _not_ghost) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// interpolate   stress  on   given   positions  for   each  element   (empty
   /// implemantation to avoid the generic call to be done on cohesive elements)
   virtual void interpolateStress(const ElementType /*type*/,
 
                                  Array<Real> & /*result*/){};
 
   /// compute the stresses
   void computeAllStresses(GhostType /*ghost_type*/ = _not_ghost) override{};
 
   // add the facet to be handled by the material
   UInt addFacet(const Element & element);
 
 protected:
   virtual void computeTangentTraction(const ElementType & /*el_type*/,
                                       Array<Real> & /*tangent_matrix*/,
                                       const Array<Real> & /*normal*/,
                                       GhostType /*ghost_type*/ = _not_ghost) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// compute the normal
   void computeNormal(const Array<Real> & position, Array<Real> & normal,
                      ElementType type, GhostType ghost_type);
 
   /// compute the opening
   void computeOpening(const Array<Real> & displacement, Array<Real> & opening,
                       ElementType type, GhostType ghost_type);
 
   template <ElementType type>
   void computeNormal(const Array<Real> & position, Array<Real> & normal,
                      GhostType ghost_type);
 
   /// assemble stiffness
   void assembleStiffnessMatrix(GhostType ghost_type) override;
 
   /// constitutive law
   virtual void computeTraction(const Array<Real> & normal, ElementType el_type,
                                GhostType ghost_type = _not_ghost) = 0;
 
   /// parallelism functions
   inline UInt getNbDataForElements(const Array<Element> & elements,
                                    SynchronizationTag tag) const;
 
   inline void packElementData(CommunicationBuffer & buffer,
                               const Array<Element> & elements,
                               SynchronizationTag tag) const;
 
   inline void unpackElementData(CommunicationBuffer & buffer,
                                 const Array<Element> & elements,
                                 SynchronizationTag tag);
 
 protected:
   void updateEnergies(ElementType el_type, GhostType ghost_type) override;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the opening
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Opening, opening, Real);
 
   /// get the traction
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Traction, tractions, Real);
 
   /// get damage
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Damage, damage, Real);
 
   /// get facet filter
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(FacetFilter, facet_filter, UInt);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(FacetFilter, facet_filter, UInt);
   AKANTU_GET_MACRO(FacetFilter, facet_filter,
                    const ElementTypeMapArray<UInt> &);
   // AKANTU_GET_MACRO(ElementFilter, element_filter, const
   // ElementTypeMapArray<UInt> &);
 
   /// compute reversible energy
   Real getReversibleEnergy();
 
   /// compute dissipated energy
   Real getDissipatedEnergy();
 
   /// compute contact energy
   Real getContactEnergy();
 
   /// get energy
   Real getEnergy(const std::string & type) override;
 
   /// return the energy (identified by id) for the provided element
   Real getEnergy(const std::string & energy_id, ElementType type,
                  UInt index) override {
     return Material::getEnergy(energy_id, type, index);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// list of facets assigned to this material
   ElementTypeMapArray<UInt> facet_filter;
 
   /// Link to the cohesive fem object in the model
   FEEngine & fem_cohesive;
 
 private:
   /// reversible energy by quadrature point
   CohesiveInternalField<Real> reversible_energy;
 
   /// total energy by quadrature point
   CohesiveInternalField<Real> total_energy;
 
 protected:
   /// opening in all elements and quadrature points
   CohesiveInternalField<Real> opening;
 
   /// traction in all elements and quadrature points
   CohesiveInternalField<Real> tractions;
 
   /// traction due to contact
   CohesiveInternalField<Real> contact_tractions;
 
   /// normal openings for contact tractions
   CohesiveInternalField<Real> contact_opening;
 
   /// maximum displacement
   CohesiveInternalField<Real> delta_max;
 
   /// tell if the previous delta_max state is needed (in iterative schemes)
   bool use_previous_delta_max;
 
   /// tell if the previous opening state is needed (in iterative schemes)
   bool use_previous_opening;
 
   /// damage
   CohesiveInternalField<Real> damage;
 
   /// pointer to the solid mechanics model for cohesive elements
   SolidMechanicsModelCohesive * model;
 
   /// critical stress
   RandomInternalField<Real, FacetInternalField> sigma_c;
 
   /// critical displacement
   Real delta_c;
 
   /// array to temporarily store the normals
   Array<Real> normal;
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 #include "material_cohesive_inline_impl.cc"
 
 } // namespace akantu
 
 #include "cohesive_internal_field_tmpl.hh"
 
 #endif /* __AKANTU_MATERIAL_COHESIVE_HH__ */
diff --git a/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive_inline_impl.cc b/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive_inline_impl.cc
index 60f700548..922bb5ab6 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive_inline_impl.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive_inline_impl.cc
@@ -1,303 +1,303 @@
 /**
  * @file   solid_mechanics_model_cohesive_inline_impl.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Jan 18 2013
  * @date last modification: Thu Jan 14 2016
  *
  * @brief  Implementation of inline functions for the Cohesive element model
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 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 "material_cohesive.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SOLID_MECHANICS_MODEL_COHESIVE_INLINE_IMPL_CC__
 #define __AKANTU_SOLID_MECHANICS_MODEL_COHESIVE_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 // template <SolveConvergenceMethod cmethod, SolveConvergenceCriteria criteria>
 // bool SolidMechanicsModelCohesive::solveStepCohesive(
 //     Real tolerance, Real & error, UInt max_iteration, bool load_reduction,
 //     Real tol_increase_factor, bool do_not_factorize) {
 
   // // EventManager::sendEvent(
   // //     SolidMechanicsModelEvent::BeforeSolveStepEvent(method));
   // // this->implicitPred();
 
   // // bool insertion_new_element = true;
   // // bool converged = false;
   // // Array<Real> * displacement_tmp = NULL;
   // // Array<Real> * velocity_tmp = NULL;
   // // Array<Real> * acceleration_tmp = NULL;
   // // StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
   // // Int prank = comm.whoAmI();
 
   // // /// Loop for the insertion of new cohesive elements
   // // while (insertion_new_element) {
 
   // //   if (is_extrinsic) {
   // //     /**
   // //      * If in extrinsic the solution of the previous incremental step
   // //      * is saved in temporary arrays created for displacements,
   // //      * velocities and accelerations. Such arrays are used to find
   // //      * the solution with the Newton-Raphson scheme (this is done by
   // //      * pointing the pointer "displacement" to displacement_tmp). In
   // //      * this way, inside the array "displacement" is kept the
   // //      * solution of the previous incremental step, and in
   // //      * "displacement_tmp" is saved the current solution.
   // //      */
 
   // //     if (!displacement_tmp)
   // //       displacement_tmp = new Array<Real>(0, spatial_dimension);
 
   // //     displacement_tmp->copy(*(this->displacement));
 
   // //     if (!velocity_tmp)
   // //       velocity_tmp = new Array<Real>(0, spatial_dimension);
 
   // //     velocity_tmp->copy(*(this->velocity));
 
   // //     if (!acceleration_tmp) {
   // //       acceleration_tmp = new Array<Real>(0, spatial_dimension);
   // //     }
 
   // //     acceleration_tmp->copy(*(this->acceleration));
 
   // //     std::swap(displacement, displacement_tmp);
   // //     std::swap(velocity, velocity_tmp);
   // //     std::swap(acceleration, acceleration_tmp);
   // //   }
 
   // //   this->updateResidual();
 
   // //   AKANTU_DEBUG_ASSERT(stiffness_matrix != NULL,
   // //                       "You should first initialize the implicit solver and "
   // //                       "assemble the stiffness matrix");
 
   // //   bool need_factorize = !do_not_factorize;
 
   // //   if (method == _implicit_dynamic) {
   // //     AKANTU_DEBUG_ASSERT(mass_matrix != NULL, "You should first initialize "
   // //                                              "the implicit solver and "
   // //                                              "assemble the mass matrix");
   // //   }
 
   // //   switch (cmethod) {
   // //   case _scm_newton_raphson_tangent:
   // //   case _scm_newton_raphson_tangent_not_computed:
   // //     break;
   // //   case _scm_newton_raphson_tangent_modified:
   // //     this->assembleStiffnessMatrix();
   // //     break;
   // //   default:
-  // //     AKANTU_DEBUG_ERROR("The resolution method "
+  // //     AKANTU_ERROR("The resolution method "
   // //                        << cmethod << " has not been implemented!");
   // //   }
 
   // //   UInt iter = 0;
   // //   converged = false;
   // //   error = 0.;
   // //   if (criteria == _scc_residual) {
   // //     converged = this->testConvergence<criteria>(tolerance, error);
   // //     if (converged)
   // //       return converged;
   // //   }
 
   // //   /// Loop to solve the nonlinear system
   // //   do {
   // //     if (cmethod == _scm_newton_raphson_tangent)
   // //       this->assembleStiffnessMatrix();
 
   // //     solve<NewmarkBeta::_displacement_corrector>(*increment, 1.,
   // //                                                 need_factorize);
 
   // //     this->implicitCorr();
 
   // //     this->updateResidual();
 
   // //     converged = this->testConvergence<criteria>(tolerance, error);
 
   // //     iter++;
   // //     AKANTU_DEBUG_INFO("[" << criteria << "] Convergence iteration "
   // //                           << std::setw(std::log10(max_iteration)) << iter
   // //                           << ": error " << error
   // //                           << (converged ? " < " : " > ") << tolerance);
 
   // //     switch (cmethod) {
   // //     case _scm_newton_raphson_tangent:
   // //       need_factorize = true;
   // //       break;
   // //     case _scm_newton_raphson_tangent_not_computed:
   // //     case _scm_newton_raphson_tangent_modified:
   // //       need_factorize = false;
   // //       break;
   // //     default:
-  // //       AKANTU_DEBUG_ERROR("The resolution method "
+  // //       AKANTU_ERROR("The resolution method "
   // //                          << cmethod << " has not been implemented!");
   // //     }
 
   // //   } while (!converged && iter < max_iteration);
 
   // //   /**
   // //    * This is to save the obtained result and proceed with the
   // //    * simulation even if the error is higher than the pre-fixed
   // //    * tolerance. This is done only after loading reduction
   // //    * (load_reduction = true).
   // //    */
   // //   //    if (load_reduction && (error < tolerance * tol_increase_factor))
   // //   //    converged = true;
   // //   if ((error < tolerance * tol_increase_factor))
   // //     converged = true;
 
   // //   if (converged) {
 
   // //   } else if (iter == max_iteration) {
   // //     if (prank == 0) {
   // //       AKANTU_DEBUG_WARNING(
   // //           "[" << criteria << "] Convergence not reached after "
   // //               << std::setw(std::log10(max_iteration)) << iter << " iteration"
   // //               << (iter == 1 ? "" : "s") << "!" << std::endl);
   // //     }
   // //   }
 
   // //   if (is_extrinsic) {
   // //     /**
   // //      * If is extrinsic the pointer "displacement" is moved back to
   // //      * the array displacement. In this way, the array displacement is
   // //      * correctly resized during the checkCohesiveStress function (in
   // //      * case new cohesive elements are added). This is possible
   // //      * because the procedure called by checkCohesiveStress does not
   // //      * use the displacement field (the correct one is now stored in
   // //      * displacement_tmp), but directly the stress field that is
   // //      * already computed.
   // //      */
   // //     Array<Real> * tmp_swap;
 
   // //     tmp_swap = displacement_tmp;
   // //     displacement_tmp = this->displacement;
   // //     this->displacement = tmp_swap;
 
   // //     tmp_swap = velocity_tmp;
   // //     velocity_tmp = this->velocity;
   // //     this->velocity = tmp_swap;
 
   // //     tmp_swap = acceleration_tmp;
   // //     acceleration_tmp = this->acceleration;
   // //     this->acceleration = tmp_swap;
 
   // //     /// If convergence is reached, call checkCohesiveStress in order
   // //     /// to check if cohesive elements have to be introduced
   // //     if (converged) {
 
   // //       UInt new_cohesive_elements = checkCohesiveStress();
 
   // //       if (new_cohesive_elements == 0) {
   // //         insertion_new_element = false;
   // //       } else {
   // //         insertion_new_element = true;
   // //       }
   // //     }
   // //   }
 
   // //   if (!converged && load_reduction)
   // //     insertion_new_element = false;
 
   // //   /**
   // //    * If convergence is not reached, there is the possibility to
   // //    * return back to the main file and reduce the load. Before doing
   // //    * this, a pre-fixed value as to be defined for the parameter
   // //    * delta_max of the cohesive elements introduced in the current
   // //    * incremental step. This is done by calling the function
   // //    * checkDeltaMax.
   // //    */
   // //   if (!converged) {
   // //     insertion_new_element = false;
 
   // //     for (UInt m = 0; m < materials.size(); ++m) {
   // //       try {
   // //         MaterialCohesive & mat =
   // //             dynamic_cast<MaterialCohesive &>(*materials[m]);
   // //         mat.checkDeltaMax(_not_ghost);
   // //       } catch (std::bad_cast &) {
   // //       }
   // //     }
   // //   }
 
   // // } // end loop for the insertion of new cohesive elements
 
   // // /**
   // //  * When the solution to the current incremental step is computed (no
   // //  * more cohesive elements have to be introduced), call the function
   // //  * to compute the energies.
   // //  */
   // // if ((is_extrinsic && converged)) {
 
   // //   for (UInt m = 0; m < materials.size(); ++m) {
   // //     try {
   // //       MaterialCohesive & mat =
   // //           dynamic_cast<MaterialCohesive &>(*materials[m]);
   // //       mat.computeEnergies();
   // //     } catch (std::bad_cast & bce) {
   // //     }
   // //   }
 
   // //   EventManager::sendEvent(
   // //       SolidMechanicsModelEvent::AfterSolveStepEvent(method));
 
   // //   /**
   // //    * The function resetVariables is necessary to correctly set a
   // //    * variable that permit to decrease locally the penalty parameter
   // //    * for compression.
   // //    */
   // //   for (UInt m = 0; m < materials.size(); ++m) {
   // //     try {
   // //       MaterialCohesive & mat =
   // //           dynamic_cast<MaterialCohesive &>(*materials[m]);
   // //       mat.resetVariables(_not_ghost);
   // //     } catch (std::bad_cast &) {
   // //     }
   // //   }
 
   // //   /// The correct solution is saved
   // //   this->displacement->copy(*displacement_tmp);
   // //   this->velocity->copy(*velocity_tmp);
   // //   this->acceleration->copy(*acceleration_tmp);
   // // }
 
   // // delete displacement_tmp;
   // // delete velocity_tmp;
   // // delete acceleration_tmp;
 
   // // return insertion_new_element;
 //}
 
 } // akantu
 
 
 #endif /* __AKANTU_SOLID_MECHANICS_MODEL_COHESIVE_INLINE_IMPL_CC__ */
diff --git a/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive_parallel.cc b/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive_parallel.cc
index ba6037031..8cfc2745d 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive_parallel.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive_parallel.cc
@@ -1,484 +1,481 @@
 /**
  * @file   solid_mechanics_model_cohesive_parallel.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  *
  * @brief  Functions for parallel cohesive elements
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "communicator.hh"
 #include "element_synchronizer.hh"
 #include "material_cohesive.hh"
 #include "solid_mechanics_model_cohesive.hh"
 #include "solid_mechanics_model_tmpl.hh"
 /* -------------------------------------------------------------------------- */
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::synchronizeGhostFacetsConnectivity() {
   AKANTU_DEBUG_IN();
 
   const Communicator & comm = mesh.getCommunicator();
   Int psize = comm.getNbProc();
 
   if (psize > 1) {
     /// get global connectivity for not ghost facets
-    global_connectivity =
-        new ElementTypeMapArray<UInt>("global_connectivity", id);
+    ElementTypeMapArray<UInt> global_connectivity("global_connectivity", id);
 
     auto & mesh_facets = inserter->getMeshFacets();
 
-    global_connectivity->initialize(
+    global_connectivity.initialize(
         mesh_facets, _spatial_dimension = spatial_dimension - 1,
         _with_nb_element = true, _with_nb_nodes_per_element = true,
         _element_kind = _ek_regular);
 
-    mesh_facets.getGlobalConnectivity(*global_connectivity);
+    mesh_facets.getGlobalConnectivity(global_connectivity);
 
     /// communicate
     synchronize(_gst_smmc_facets_conn);
 
     /// flip facets
-    MeshUtils::flipFacets(mesh_facets, *global_connectivity, _ghost);
-
-    delete global_connectivity;
+    MeshUtils::flipFacets(mesh_facets, global_connectivity, _ghost);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::updateCohesiveSynchronizers() {
   /// update synchronizers if needed
 
   if (not mesh.isDistributed())
     return;
 
   auto & mesh_facets = inserter->getMeshFacets();
   auto & facet_synchronizer = mesh_facets.getElementSynchronizer();
   const auto & cfacet_synchronizer = facet_synchronizer;
 
   // update the cohesive element synchronizer
   cohesive_synchronizer->updateSchemes([&](auto && scheme, auto && proc,
                                            auto && direction) {
     auto & facet_scheme =
         cfacet_synchronizer.getCommunications().getScheme(proc, direction);
 
     for (auto && facet : facet_scheme) {
       const auto & connected_elements = mesh_facets.getElementToSubelement(
           facet.type,
           facet.ghost_type)(facet.element); // slow access here
       const auto & cohesive_element = connected_elements[1];
 
       auto && cohesive_type = FEEngine::getCohesiveElementType(facet.type);
       auto old_nb_cohesive_elements =
           mesh.getNbElement(cohesive_type, facet.ghost_type);
       old_nb_cohesive_elements -=
           mesh.getData<UInt>("facet_to_double", facet.type, facet.ghost_type)
               .size();
 
       if (cohesive_element.kind() == _ek_cohesive and
           cohesive_element.element >= old_nb_cohesive_elements) {
         scheme.push_back(cohesive_element);
       }
     }
   });
 
   const auto & comm = mesh.getCommunicator();
   auto && my_rank = comm.whoAmI();
 
   // update the facet stress synchronizer
   if (facet_stress_synchronizer)
     facet_stress_synchronizer->updateSchemes([&](auto && scheme, auto && proc,
                                                  auto && /*direction*/) {
       auto it_element = scheme.begin();
       for (auto && element : scheme) {
         auto && facet_check = inserter->getCheckFacets(
             element.type, element.ghost_type)(element.element); // slow access
                                                                 // here
 
         if (facet_check) {
           auto && connected_elements = mesh_facets.getElementToSubelement(
               element.type, element.ghost_type)(element.element); // slow access
                                                                   // here
           auto && rank_left = facet_synchronizer.getRank(connected_elements[0]);
           auto && rank_right =
               facet_synchronizer.getRank(connected_elements[1]);
 
           // keep element if the element is still a boundary element between two
           // processors
           if ((rank_left == Int(proc) and rank_right == my_rank) or
               (rank_left == my_rank and rank_right == Int(proc))) {
             *it_element = element;
             ++it_element;
           }
         }
       }
       scheme.resize(it_element - scheme.begin());
     });
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::updateFacetStressSynchronizer() {
   if (facet_stress_synchronizer != nullptr) {
     const auto & rank_to_element =
         mesh.getElementSynchronizer().getElementToRank();
     const auto & facet_checks = inserter->getCheckFacets();
     const auto & mesh_facets = inserter->getMeshFacets();
     const auto & element_to_facet = mesh_facets.getElementToSubelement();
     UInt rank = mesh.getCommunicator().whoAmI();
 
     facet_stress_synchronizer->updateSchemes(
         [&](auto & scheme, auto & proc, auto & /*direction*/) {
           UInt el = 0;
           for (auto && element : scheme) {
             if (not facet_checks(element))
               continue;
 
             const auto & next_el = element_to_facet(element);
             UInt rank_left = rank_to_element(next_el[0]);
             UInt rank_right = rank_to_element(next_el[1]);
 
             if ((rank_left == rank and rank_right == proc) or
                 (rank_left == proc and rank_right == rank)) {
               scheme[el] = element;
               ++el;
             }
           }
           scheme.resize(el);
         });
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void SolidMechanicsModelCohesive::packFacetStressDataHelper(
     const ElementTypeMapArray<T> & data_to_pack, CommunicationBuffer & buffer,
     const Array<Element> & elements) const {
   packUnpackFacetStressDataHelper<T, true>(
       const_cast<ElementTypeMapArray<T> &>(data_to_pack), buffer, elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void SolidMechanicsModelCohesive::unpackFacetStressDataHelper(
     ElementTypeMapArray<T> & data_to_unpack, CommunicationBuffer & buffer,
     const Array<Element> & elements) const {
   packUnpackFacetStressDataHelper<T, false>(data_to_unpack, buffer, elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, bool pack_helper>
 void SolidMechanicsModelCohesive::packUnpackFacetStressDataHelper(
     ElementTypeMapArray<T> & data_to_pack, CommunicationBuffer & buffer,
     const Array<Element> & elements) const {
   ElementType current_element_type = _not_defined;
   GhostType current_ghost_type = _casper;
   UInt nb_quad_per_elem = 0;
   UInt sp2 = spatial_dimension * spatial_dimension;
   UInt nb_component = sp2 * 2;
   bool element_rank = false;
   Mesh & mesh_facets = inserter->getMeshFacets();
 
   Array<T> * vect = nullptr;
   Array<std::vector<Element>> * element_to_facet = nullptr;
 
   auto & fe_engine = this->getFEEngine("FacetsFEEngine");
   for (auto && el : elements) {
     if (el.type == _not_defined)
       AKANTU_EXCEPTION(
           "packUnpackFacetStressDataHelper called with wrong inputs");
 
     if (el.type != current_element_type ||
         el.ghost_type != current_ghost_type) {
       current_element_type = el.type;
       current_ghost_type = el.ghost_type;
       vect = &data_to_pack(el.type, el.ghost_type);
 
       element_to_facet =
           &(mesh_facets.getElementToSubelement(el.type, el.ghost_type));
 
       nb_quad_per_elem =
           fe_engine.getNbIntegrationPoints(el.type, el.ghost_type);
     }
 
     if (pack_helper)
       element_rank =
           (*element_to_facet)(el.element)[0].ghost_type != _not_ghost;
     else
       element_rank =
           (*element_to_facet)(el.element)[0].ghost_type == _not_ghost;
 
     for (UInt q = 0; q < nb_quad_per_elem; ++q) {
       Vector<T> data(vect->storage() +
                          (el.element * nb_quad_per_elem + q) * nb_component +
                          element_rank * sp2,
                      sp2);
 
       if (pack_helper)
         buffer << data;
       else
         buffer >> data;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 UInt SolidMechanicsModelCohesive::getNbQuadsForFacetCheck(
     const Array<Element> & elements) const {
   UInt nb_quads = 0;
   UInt nb_quad_per_facet = 0;
 
   ElementType current_element_type = _not_defined;
   GhostType current_ghost_type = _casper;
   auto & fe_engine = this->getFEEngine("FacetsFEEngine");
   for (auto & el : elements) {
     if (el.type != current_element_type ||
         el.ghost_type != current_ghost_type) {
       current_element_type = el.type;
       current_ghost_type = el.ghost_type;
 
       nb_quad_per_facet =
           fe_engine.getNbIntegrationPoints(el.type, el.ghost_type);
     }
 
     nb_quads += nb_quad_per_facet;
   }
 
   return nb_quads;
 }
 
 /* -------------------------------------------------------------------------- */
 UInt SolidMechanicsModelCohesive::getNbData(
     const Array<Element> & elements, const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
   if (elements.size() == 0)
     return 0;
 
   /// regular element case
   if (elements(0).kind() == _ek_regular) {
 
     switch (tag) {
     case _gst_smmc_facets: {
       size += elements.size() * sizeof(bool);
       break;
     }
     case _gst_smmc_facets_conn: {
       UInt nb_nodes = Mesh::getNbNodesPerElementList(elements);
       size += nb_nodes * sizeof(UInt);
       break;
     }
     case _gst_smmc_facets_stress: {
       UInt nb_quads = getNbQuadsForFacetCheck(elements);
       size += nb_quads * spatial_dimension * spatial_dimension * sizeof(Real);
       break;
     }
     case _gst_material_id: {
       for (auto && element : elements) {
         if (Mesh::getSpatialDimension(element.type) == (spatial_dimension - 1))
           size += sizeof(UInt);
       }
 
       size += SolidMechanicsModel::getNbData(elements, tag);
       break;
     }
 
     default: { size += SolidMechanicsModel::getNbData(elements, tag); }
     }
   }
   /// cohesive element case
   else if (elements(0).kind() == _ek_cohesive) {
 
     switch (tag) {
     case _gst_material_id: {
       size += elements.size() * sizeof(UInt);
       break;
     }
     case _gst_smm_boundary: {
       UInt nb_nodes_per_element = 0;
 
       for (auto && el : elements) {
         nb_nodes_per_element += Mesh::getNbNodesPerElement(el.type);
       }
 
       // force, displacement, boundary
       size += nb_nodes_per_element * spatial_dimension *
               (2 * sizeof(Real) + sizeof(bool));
       break;
     }
     default:
       break;
     }
 
     if (tag != _gst_material_id && tag != _gst_smmc_facets) {
       splitByMaterial(elements, [&](auto && mat, auto && elements) {
         size += mat.getNbData(elements, tag);
       });
     }
   }
 
   AKANTU_DEBUG_OUT();
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::packData(
     CommunicationBuffer & buffer, const Array<Element> & elements,
     const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   if (elements.size() == 0)
     return;
 
   if (elements(0).kind() == _ek_regular) {
     switch (tag) {
     case _gst_smmc_facets: {
       packElementalDataHelper(inserter->getInsertionFacetsByElement(), buffer,
                               elements, false, getFEEngine());
       break;
     }
     case _gst_smmc_facets_conn: {
       packElementalDataHelper(*global_connectivity, buffer, elements, false,
                               getFEEngine());
       break;
     }
     case _gst_smmc_facets_stress: {
       packFacetStressDataHelper(facet_stress, buffer, elements);
       break;
     }
     case _gst_material_id: {
       for (auto && element : elements) {
         if (Mesh::getSpatialDimension(element.type) != (spatial_dimension - 1))
           continue;
         buffer << material_index(element);
       }
 
       SolidMechanicsModel::packData(buffer, elements, tag);
       break;
     }
     default: { SolidMechanicsModel::packData(buffer, elements, tag); }
     }
 
     AKANTU_DEBUG_OUT();
     return;
   }
 
   if (elements(0).kind() == _ek_cohesive) {
     switch (tag) {
     case _gst_material_id: {
       packElementalDataHelper(material_index, buffer, elements, false,
                               getFEEngine("CohesiveFEEngine"));
       break;
     }
     case _gst_smm_boundary: {
       packNodalDataHelper(*internal_force, buffer, elements, mesh);
       packNodalDataHelper(*velocity, buffer, elements, mesh);
       packNodalDataHelper(*blocked_dofs, buffer, elements, mesh);
       break;
     }
     default: {}
     }
 
     if (tag != _gst_material_id && tag != _gst_smmc_facets) {
       splitByMaterial(elements, [&](auto && mat, auto && elements) {
         mat.packData(buffer, elements, tag);
       });
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::unpackData(CommunicationBuffer & buffer,
                                              const Array<Element> & elements,
                                              const SynchronizationTag & tag) {
   AKANTU_DEBUG_IN();
 
   if (elements.size() == 0)
     return;
 
   if (elements(0).kind() == _ek_regular) {
     switch (tag) {
     case _gst_smmc_facets: {
       unpackElementalDataHelper(inserter->getInsertionFacetsByElement(), buffer,
                                 elements, false, getFEEngine());
       break;
     }
     case _gst_smmc_facets_conn: {
       unpackElementalDataHelper(*global_connectivity, buffer, elements, false,
                                 getFEEngine());
       break;
     }
     case _gst_smmc_facets_stress: {
       unpackFacetStressDataHelper(facet_stress, buffer, elements);
       break;
     }
     case _gst_material_id: {
       for (auto && element : elements) {
         if (Mesh::getSpatialDimension(element.type) != (spatial_dimension - 1))
           continue;
 
         UInt recv_mat_index;
         buffer >> recv_mat_index;
         UInt & mat_index = material_index(element);
         if (mat_index != UInt(-1))
           continue;
 
         // add ghosts element to the correct material
         mat_index = recv_mat_index;
         auto & mat = dynamic_cast<MaterialCohesive &>(*materials[mat_index]);
         mat.addFacet(element);
         facet_material(element) = recv_mat_index;
       }
       SolidMechanicsModel::unpackData(buffer, elements, tag);
       break;
     }
     default: { SolidMechanicsModel::unpackData(buffer, elements, tag); }
     }
 
     AKANTU_DEBUG_OUT();
     return;
   }
 
   if (elements(0).kind() == _ek_cohesive) {
     switch (tag) {
     case _gst_material_id: {
       unpackElementalDataHelper(material_index, buffer, elements, false,
                                 getFEEngine("CohesiveFEEngine"));
       break;
     }
     case _gst_smm_boundary: {
       unpackNodalDataHelper(*internal_force, buffer, elements, mesh);
       unpackNodalDataHelper(*velocity, buffer, elements, mesh);
       unpackNodalDataHelper(*blocked_dofs, buffer, elements, mesh);
       break;
     }
     default: {}
     }
 
     if (tag != _gst_material_id && tag != _gst_smmc_facets) {
       splitByMaterial(elements, [&](auto && mat, auto && elements) {
         mat.unpackData(buffer, elements, tag);
       });
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/solid_mechanics_model_embedded_interface/embedded_interface_intersector.cc b/src/model/solid_mechanics/solid_mechanics_model_embedded_interface/embedded_interface_intersector.cc
index 69e637b6d..e376a4ba7 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_embedded_interface/embedded_interface_intersector.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_embedded_interface/embedded_interface_intersector.cc
@@ -1,179 +1,179 @@
 /**
  * @file   embedded_interface_intersector.cc
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  *
  * @date creation: Fri May 01 2015
  * @date last modification: Mon Jan 04 2016
  *
  * @brief  Class that loads the interface from mesh and computes intersections
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 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 "embedded_interface_intersector.hh"
 #include "mesh_segment_intersector.hh"
 
 /// Helper macro for types in the mesh. Creates an intersector and computes
 /// intersection queries
 #define INTERFACE_INTERSECTOR_CASE(dim, type)                                  \
   do {                                                                         \
     MeshSegmentIntersector<dim, type> intersector(this->mesh, interface_mesh); \
     name_to_primitives_it = name_to_primitives_map.begin();                    \
     for (; name_to_primitives_it != name_to_primitives_end;                    \
          ++name_to_primitives_it) {                                            \
       intersector.setPhysicalName(name_to_primitives_it->first);               \
       intersector.buildResultFromQueryList(name_to_primitives_it->second);     \
     }                                                                          \
   } while (0)
 
 #define INTERFACE_INTERSECTOR_CASE_2D(type) INTERFACE_INTERSECTOR_CASE(2, type)
 #define INTERFACE_INTERSECTOR_CASE_3D(type) INTERFACE_INTERSECTOR_CASE(3, type)
 
 namespace akantu {
 
 EmbeddedInterfaceIntersector::EmbeddedInterfaceIntersector(
     Mesh & mesh, const Mesh & primitive_mesh)
     : MeshGeomAbstract(mesh),
       interface_mesh(mesh.getSpatialDimension(), "interface_mesh"),
       primitive_mesh(primitive_mesh) {
   // Initiating mesh connectivity and data
   interface_mesh.addConnectivityType(_segment_2, _not_ghost);
   interface_mesh.addConnectivityType(_segment_2, _ghost);
   interface_mesh.registerData<Element>("associated_element")
       .alloc(0, 1, _segment_2);
   interface_mesh.registerData<std::string>("physical_names")
       .alloc(0, 1, _segment_2);
 }
 
 EmbeddedInterfaceIntersector::~EmbeddedInterfaceIntersector() {}
 
 void EmbeddedInterfaceIntersector::constructData(GhostType /*ghost_type*/) {
   AKANTU_DEBUG_IN();
 
   const UInt dim = this->mesh.getSpatialDimension();
 
   if (dim == 1)
-    AKANTU_DEBUG_ERROR(
+    AKANTU_ERROR(
         "No embedded model in 1D. Deactivate intersection initialization");
 
   Array<std::string> * physical_names = NULL;
 
   try {
     physical_names = &const_cast<Array<std::string> &>(
         this->primitive_mesh.getData<std::string>("physical_names",
                                                   _segment_2));
   } catch (debug::Exception & e) {
-    AKANTU_DEBUG_ERROR("You must define physical names to reinforcements in "
+    AKANTU_ERROR("You must define physical names to reinforcements in "
                        "order to use the embedded model");
     throw e;
   }
 
   const UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(_segment_2);
   Array<UInt>::const_vector_iterator connectivity =
       primitive_mesh.getConnectivity(_segment_2).begin(nb_nodes_per_element);
 
   Array<std::string>::scalar_iterator names_it = physical_names->begin(),
                                       names_end = physical_names->end();
 
   std::map<std::string, std::list<K::Segment_3>> name_to_primitives_map;
 
   // Loop over the physical names and register segment lists in
   // name_to_primitives_map
   for (; names_it != names_end; ++names_it) {
     UInt element_id = names_it - physical_names->begin();
     const Vector<UInt> el_connectivity = connectivity[element_id];
 
     K::Segment_3 segment = this->createSegment(el_connectivity);
     name_to_primitives_map[*names_it].push_back(segment);
   }
 
   // Loop over the background types of the mesh
   Mesh::type_iterator type_it = this->mesh.firstType(dim, _not_ghost),
                       type_end = this->mesh.lastType(dim, _not_ghost);
 
   std::map<std::string, std::list<K::Segment_3>>::iterator
       name_to_primitives_it,
       name_to_primitives_end = name_to_primitives_map.end();
 
   for (; type_it != type_end; ++type_it) {
     // Used in AKANTU_BOOST_ELEMENT_SWITCH
     ElementType type = *type_it;
 
     AKANTU_DEBUG_INFO("Computing intersections with background element type "
                       << type);
 
     switch (dim) {
     case 1:
       break;
 
     case 2:
       // Compute intersections for supported 2D elements
       AKANTU_BOOST_ELEMENT_SWITCH(INTERFACE_INTERSECTOR_CASE_2D,
                                   (_triangle_3)(_triangle_6));
       break;
 
     case 3:
       // Compute intersections for supported 3D elements
       AKANTU_BOOST_ELEMENT_SWITCH(INTERFACE_INTERSECTOR_CASE_3D,
                                   (_tetrahedron_4));
       break;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 K::Segment_3
 EmbeddedInterfaceIntersector::createSegment(const Vector<UInt> & connectivity) {
   AKANTU_DEBUG_IN();
 
   K::Point_3 *source = NULL, *target = NULL;
   const Array<Real> & nodes = this->primitive_mesh.getNodes();
 
   if (this->mesh.getSpatialDimension() == 2) {
     source = new K::Point_3(nodes(connectivity(0), 0),
                             nodes(connectivity(0), 1), 0.);
     target = new K::Point_3(nodes(connectivity(1), 0),
                             nodes(connectivity(1), 1), 0.);
   } else if (this->mesh.getSpatialDimension() == 3) {
     source =
         new K::Point_3(nodes(connectivity(0), 0), nodes(connectivity(0), 1),
                        nodes(connectivity(0), 2));
     target =
         new K::Point_3(nodes(connectivity(1), 0), nodes(connectivity(1), 1),
                        nodes(connectivity(1), 2));
   }
 
   K::Segment_3 segment(*source, *target);
   delete source;
   delete target;
 
   AKANTU_DEBUG_OUT();
   return segment;
 }
 
 } // namespace akantu
 
 #undef INTERFACE_INTERSECTOR_CASE
 #undef INTERFACE_INTERSECTOR_CASE_2D
 #undef INTERFACE_INTERSECTOR_CASE_3D
diff --git a/src/model/solid_mechanics/solid_mechanics_model_material.cc b/src/model/solid_mechanics/solid_mechanics_model_material.cc
index 9125b1752..ece2d8d99 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_material.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_material.cc
@@ -1,256 +1,256 @@
 /**
  * @file   solid_mechanics_model_material.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Nov 26 2010
  * @date last modification: Mon Nov 16 2015
  *
  * @brief  instatiation of materials
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "aka_factory.hh"
 #include "aka_math.hh"
 #include "material_non_local.hh"
 #include "mesh_iterators.hh"
 #include "non_local_manager.hh"
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Material &
 SolidMechanicsModel::registerNewMaterial(const ParserSection & section) {
   std::string mat_name;
   std::string mat_type = section.getName();
   std::string opt_param = section.getOption();
 
   try {
     std::string tmp = section.getParameter("name");
     mat_name = tmp; /** this can seam weird, but there is an ambiguous operator
                      * overload that i couldn't solve. @todo remove the
                      * weirdness of this code
                      */
   } catch (debug::Exception &) {
-    AKANTU_DEBUG_ERROR(
+    AKANTU_ERROR(
         "A material of type \'"
         << mat_type << "\' in the input file has been defined without a name!");
   }
   Material & mat = this->registerNewMaterial(mat_name, mat_type, opt_param);
 
   mat.parseSection(section);
 
   return mat;
 }
 
 /* -------------------------------------------------------------------------- */
 Material & SolidMechanicsModel::registerNewMaterial(const ID & mat_name,
                                                     const ID & mat_type,
                                                     const ID & opt_param) {
   AKANTU_DEBUG_ASSERT(materials_names_to_id.find(mat_name) ==
                           materials_names_to_id.end(),
                       "A material with this name '"
                           << mat_name << "' has already been registered. "
                           << "Please use unique names for materials");
 
   UInt mat_count = materials.size();
   materials_names_to_id[mat_name] = mat_count;
 
   std::stringstream sstr_mat;
   sstr_mat << this->id << ":" << mat_count << ":" << mat_type;
   ID mat_id = sstr_mat.str();
 
   std::unique_ptr<Material> material = MaterialFactory::getInstance().allocate(
       mat_type, spatial_dimension, opt_param, *this, mat_id);
 
   materials.push_back(std::move(material));
 
   return *(materials.back());
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::instantiateMaterials() {
   ParserSection model_section;
   bool is_empty;
   std::tie(model_section, is_empty) = this->getParserSection();
 
   if(not is_empty) {
     auto model_materials = model_section.getSubSections(ParserType::_material);
     for (const auto & section : model_materials) {
       this->registerNewMaterial(section);
     }
   }
 
   auto sub_sections = this->parser.getSubSections(ParserType::_material);
   for (const auto & section : sub_sections) {
     this->registerNewMaterial(section);
   }
 
 
 
 #ifdef AKANTU_DAMAGE_NON_LOCAL
   for (auto & material : materials) {
     if (dynamic_cast<MaterialNonLocalInterface *>(material.get()) == nullptr)
       continue;
 
     this->non_local_manager = std::make_unique<NonLocalManager>(
         *this, *this, id + ":non_local_manager", memory_id);
     break;
   }
 #endif
 
   if(materials.empty())
     AKANTU_EXCEPTION("No materials where instantiated for the model" << getID());
   are_materials_instantiated = true;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assignMaterialToElements(
     const ElementTypeMapArray<UInt> * filter) {
 
   for_each_element(
       mesh,
       [&](auto && element) {
         UInt mat_index = (*material_selector)(element);
         AKANTU_DEBUG_ASSERT(
             mat_index < materials.size(),
             "The material selector returned an index that does not exists");
         material_index(element) = mat_index;
       },
       _element_filter = filter, _ghost_type = _not_ghost);
 
   if (non_local_manager)
     non_local_manager->synchronize(*this, _gst_material_id);
 
   for_each_element(
       mesh,
       [&](auto && element) {
         auto mat_index = material_index(element);
         auto index = materials[mat_index]->addElement(element);
         material_local_numbering(element) = index;
       },
       _element_filter = filter, _ghost_type = _not_ghost);
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::initMaterials() {
   AKANTU_DEBUG_ASSERT(materials.size() != 0, "No material to initialize !");
 
   if (!are_materials_instantiated)
     instantiateMaterials();
 
   this->assignMaterialToElements();
   // synchronize the element material arrays
   this->synchronize(_gst_material_id);
 
   for (auto & material : materials) {
     /// init internals properties
     material->initMaterial();
   }
 
   this->synchronize(_gst_smm_init_mat);
 
   if (this->non_local_manager) {
     this->non_local_manager->initialize();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 Int SolidMechanicsModel::getInternalIndexFromID(const ID & id) const {
   AKANTU_DEBUG_IN();
 
   auto it = materials.begin();
   auto end = materials.end();
 
   for (; it != end; ++it)
     if ((*it)->getID() == id) {
       AKANTU_DEBUG_OUT();
       return (it - materials.begin());
     }
 
   AKANTU_DEBUG_OUT();
   return -1;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::reassignMaterial() {
   AKANTU_DEBUG_IN();
 
   std::vector<Array<Element>> element_to_add(materials.size());
   std::vector<Array<Element>> element_to_remove(materials.size());
 
   Element element;
   for (auto ghost_type : ghost_types) {
     element.ghost_type = ghost_type;
 
     for (auto type :
          mesh.elementTypes(spatial_dimension, ghost_type, _ek_not_defined)) {
       element.type = type;
 
       UInt nb_element = mesh.getNbElement(type, ghost_type);
       Array<UInt> & mat_indexes = material_index(type, ghost_type);
 
       for (UInt el = 0; el < nb_element; ++el) {
         element.element = el;
 
         UInt old_material = mat_indexes(el);
         UInt new_material = (*material_selector)(element);
 
         if (old_material != new_material) {
           element_to_add[new_material].push_back(element);
           element_to_remove[old_material].push_back(element);
         }
       }
     }
   }
 
   UInt mat_index = 0;
   for (auto mat_it = materials.begin(); mat_it != materials.end();
        ++mat_it, ++mat_index) {
     (*mat_it)->removeElements(element_to_remove[mat_index]);
     (*mat_it)->addElements(element_to_add[mat_index]);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::applyEigenGradU(
     const Matrix<Real> & prescribed_eigen_grad_u, const ID & material_name,
     const GhostType ghost_type) {
 
   AKANTU_DEBUG_ASSERT(prescribed_eigen_grad_u.size() ==
                           spatial_dimension * spatial_dimension,
                       "The prescribed grad_u is not of the good size");
   for (auto & material : materials) {
     if (material->getName() == material_name)
       material->applyEigenGradU(prescribed_eigen_grad_u, ghost_type);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/model/structural_mechanics/structural_elements/structural_element_kirchhoff_shell.hh b/src/model/structural_mechanics/structural_elements/structural_element_kirchhoff_shell.hh
index 6e9806e72..e84fb3017 100644
--- a/src/model/structural_mechanics/structural_elements/structural_element_kirchhoff_shell.hh
+++ b/src/model/structural_mechanics/structural_elements/structural_element_kirchhoff_shell.hh
@@ -1,75 +1,75 @@
 /**
  * @file   structural_element_bernoulli_kirchhoff_shell.hh
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Sébastien Hartmann <sebastien.hartmann@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Damien Spielmann <damien.spielmann@epfl.ch>
  *
  * @date creation  Tue Sep 19 2017
  *
  * @brief Specific functions for bernoulli kirchhoff shell
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 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/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #ifndef __AKANTU_STRUCTURAL_ELEMENT_BERNOULLI_KIRCHHOFF_SHELL_HH__
 #define __AKANTU_STRUCTURAL_ELEMENT_BERNOULLI_KIRCHHOFF_SHELL_HH__
 
 #include "structural_mechanics_model.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 StructuralMechanicsModel::assembleMass<_discrete_kirchhoff_triangle_18>() {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void StructuralMechanicsModel::computeTangentModuli<
     _discrete_kirchhoff_triangle_18>(Array<Real> & tangent_moduli) {
 
   auto tangent_size =
     ElementClass<_discrete_kirchhoff_triangle_18>::getNbStressComponents();
   auto nb_quad =
       getFEEngine().getNbIntegrationPoints(_discrete_kirchhoff_triangle_18);
 
   auto H_it = tangent_moduli.begin(tangent_size, tangent_size);
 
   for (UInt mat :
        element_material(_discrete_kirchhoff_triangle_18, _not_ghost)) {
     auto & m = materials[mat];
 
     for (UInt q = 0; q < nb_quad; ++q, ++H_it) {
       auto & H = *H_it;
       Matrix<Real> D = {{1, m.nu, 0}, {m.nu, 1, 0}, {0, 0, (1 - m.nu) / 2}};
       D *= m.E / (1 - m.nu * m.nu);
       H.block(0, 0, 3, 3) = D; // in plane membrane behavior
       H.block(3, 3, 3, 3) = D * Math::pow<3>(m.t) / 12.; // bending behavior
     }
   }
 }
 
 }  // akantu
 
 #endif /* __AKANTU_STRUCTURAL_ELEMENT_BERNOULLI_DISCRETE_KIRCHHOFF_TRIANGLE_18_HH__ */
diff --git a/src/model/structural_mechanics/structural_mechanics_model.cc b/src/model/structural_mechanics/structural_mechanics_model.cc
index dc3e5e8d2..9a29752cb 100644
--- a/src/model/structural_mechanics/structural_mechanics_model.cc
+++ b/src/model/structural_mechanics/structural_mechanics_model.cc
@@ -1,442 +1,442 @@
 /**
  * @file   structural_mechanics_model.cc
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Sébastien Hartmann <sebastien.hartmann@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Damien Spielmann <damien.spielmann@epfl.ch>
  *
  * @date creation: Fri Jul 15 2011
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Model implementation for StucturalMechanics elements
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "structural_mechanics_model.hh"
 #include "dof_manager.hh"
 #include "integrator_gauss.hh"
 #include "mesh.hh"
 #include "shape_structural.hh"
 #include "sparse_matrix.hh"
 /* -------------------------------------------------------------------------- */
 #ifdef AKANTU_USE_IOHELPER
 #include "dumpable_inline_impl.hh"
 #include "dumper_elemental_field.hh"
 #include "dumper_iohelper_paraview.hh"
 #include "group_manager_inline_impl.cc"
 #endif
 /* -------------------------------------------------------------------------- */
 #include "structural_mechanics_model_inline_impl.cc"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 StructuralMechanicsModel::StructuralMechanicsModel(Mesh & mesh, UInt dim,
                                                    const ID & id,
                                                    const MemoryID & memory_id)
     : Model(mesh, ModelType::_structural_mechanics_model, dim, id, memory_id),
       time_step(NAN), f_m2a(1.0), stress("stress", id, memory_id),
       element_material("element_material", id, memory_id),
       set_ID("beam sets", id, memory_id),
       rotation_matrix("rotation_matices", id, memory_id) {
   AKANTU_DEBUG_IN();
 
   registerFEEngineObject<MyFEEngineType>("StructuralMechanicsFEEngine", mesh,
                                          spatial_dimension);
 
   if (spatial_dimension == 2)
     nb_degree_of_freedom = 3;
   else if (spatial_dimension == 3)
     nb_degree_of_freedom = 6;
   else {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
 #ifdef AKANTU_USE_IOHELPER
   this->mesh.registerDumper<DumperParaview>("paraview_all", id, true);
 #endif
   this->mesh.addDumpMesh(mesh, spatial_dimension, _not_ghost, _ek_structural);
 
   this->initDOFManager();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 StructuralMechanicsModel::~StructuralMechanicsModel() = default;
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::initFullImpl(const ModelOptions & options) {
   // <<<< This is the SolidMechanicsModel implementation for future ref >>>>
   // material_index.initialize(mesh, _element_kind = _ek_not_defined,
   //                           _default_value = UInt(-1), _with_nb_element =
   //                           true);
   // material_local_numbering.initialize(mesh, _element_kind = _ek_not_defined,
   //                                     _with_nb_element = true);
 
   // Model::initFullImpl(options);
 
   // // initialize pbc
   // if (this->pbc_pair.size() != 0)
   //   this->initPBC();
 
   // // initialize the materials
   // if (this->parser.getLastParsedFile() != "") {
   //   this->instantiateMaterials();
   // }
 
   // this->initMaterials();
   // this->initBC(*this, *displacement, *displacement_increment,
   // *external_force);
 
   // <<<< END >>>>
 
   Model::initFullImpl(options);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void StructuralMechanicsModel::initFEEngineBoundary() {
   /// TODO: this function should not be reimplemented
   /// we're just avoiding a call to Model::initFEEngineBoundary()
 }
 
 /* -------------------------------------------------------------------------- */
 // void StructuralMechanicsModel::setTimeStep(Real time_step) {
 //   this->time_step = time_step;
 
 // #if defined(AKANTU_USE_IOHELPER)
 //   this->mesh.getDumper().setTimeStep(time_step);
 // #endif
 // }
 
 /* -------------------------------------------------------------------------- */
 /* Initialisation                                                             */
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::initSolver(
     TimeStepSolverType time_step_solver_type, NonLinearSolverType) {
   AKANTU_DEBUG_IN();
 
   this->allocNodalField(displacement_rotation, nb_degree_of_freedom,
                         "displacement");
   this->allocNodalField(external_force_momentum, nb_degree_of_freedom,
                         "external_force");
   this->allocNodalField(internal_force_momentum, nb_degree_of_freedom,
                         "internal_force");
   this->allocNodalField(blocked_dofs, nb_degree_of_freedom, "blocked_dofs");
 
   auto & dof_manager = this->getDOFManager();
 
   if (!dof_manager.hasDOFs("displacement")) {
     dof_manager.registerDOFs("displacement", *displacement_rotation,
                              _dst_nodal);
     dof_manager.registerBlockedDOFs("displacement", *this->blocked_dofs);
   }
 
   if (time_step_solver_type == _tsst_dynamic ||
       time_step_solver_type == _tsst_dynamic_lumped) {
     this->allocNodalField(velocity, spatial_dimension, "velocity");
     this->allocNodalField(acceleration, spatial_dimension, "acceleration");
 
     if (!dof_manager.hasDOFsDerivatives("displacement", 1)) {
       dof_manager.registerDOFsDerivative("displacement", 1, *this->velocity);
       dof_manager.registerDOFsDerivative("displacement", 2,
                                          *this->acceleration);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::initModel() {
   for (auto && type : mesh.elementTypes(_element_kind = _ek_structural)) {
     // computeRotationMatrix(type);
     element_material.alloc(mesh.getNbElement(type), 1, type);
   }
 
   getFEEngine().initShapeFunctions(_not_ghost);
   getFEEngine().initShapeFunctions(_ghost);
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::assembleStiffnessMatrix() {
   AKANTU_DEBUG_IN();
 
   getDOFManager().getMatrix("K").clear();
 
   for (auto & type :
        mesh.elementTypes(spatial_dimension, _not_ghost, _ek_structural)) {
 #define ASSEMBLE_STIFFNESS_MATRIX(type) assembleStiffnessMatrix<type>();
 
     AKANTU_BOOST_STRUCTURAL_ELEMENT_SWITCH(ASSEMBLE_STIFFNESS_MATRIX);
 #undef ASSEMBLE_STIFFNESS_MATRIX
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::computeStresses() {
   AKANTU_DEBUG_IN();
 
   for (auto & type :
        mesh.elementTypes(spatial_dimension, _not_ghost, _ek_structural)) {
 #define COMPUTE_STRESS_ON_QUAD(type) computeStressOnQuad<type>();
 
     AKANTU_BOOST_STRUCTURAL_ELEMENT_SWITCH(COMPUTE_STRESS_ON_QUAD);
 #undef COMPUTE_STRESS_ON_QUAD
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::updateResidual() {
   AKANTU_DEBUG_IN();
 
   auto & K = getDOFManager().getMatrix("K");
 
   internal_force_momentum->clear();
   K.matVecMul(*displacement_rotation, *internal_force_momentum);
   *internal_force_momentum *= -1.;
 
   getDOFManager().assembleToResidual("displacement", *external_force_momentum,
                                      1.);
 
   getDOFManager().assembleToResidual("displacement", *internal_force_momentum,
                                      1.);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::computeRotationMatrix(const ElementType & type) {
   Mesh & mesh = getFEEngine().getMesh();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_element = mesh.getNbElement(type);
 
   if (!rotation_matrix.exists(type)) {
     rotation_matrix.alloc(nb_element,
                           nb_degree_of_freedom * nb_nodes_per_element *
                               nb_degree_of_freedom * nb_nodes_per_element,
                           type);
   } else {
     rotation_matrix(type).resize(nb_element);
   }
   rotation_matrix(type).clear();
 
   Array<Real> rotations(nb_element,
                         nb_degree_of_freedom * nb_degree_of_freedom);
   rotations.clear();
 
 #define COMPUTE_ROTATION_MATRIX(type) computeRotationMatrix<type>(rotations);
 
   AKANTU_BOOST_STRUCTURAL_ELEMENT_SWITCH(COMPUTE_ROTATION_MATRIX);
 #undef COMPUTE_ROTATION_MATRIX
 
   auto R_it = rotations.begin(nb_degree_of_freedom, nb_degree_of_freedom);
   auto T_it =
       rotation_matrix(type).begin(nb_degree_of_freedom * nb_nodes_per_element,
                                   nb_degree_of_freedom * nb_nodes_per_element);
 
   for (UInt el = 0; el < nb_element; ++el, ++R_it, ++T_it) {
     auto & T = *T_it;
     auto & R = *R_it;
     for (UInt k = 0; k < nb_nodes_per_element; ++k) {
       for (UInt i = 0; i < nb_degree_of_freedom; ++i)
         for (UInt j = 0; j < nb_degree_of_freedom; ++j)
           T(k * nb_degree_of_freedom + i, k * nb_degree_of_freedom + j) =
               R(i, j);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 dumper::Field * StructuralMechanicsModel::createNodalFieldBool(
     const std::string & field_name, const std::string & group_name,
     __attribute__((unused)) bool padding_flag) {
 
   std::map<std::string, Array<bool> *> uint_nodal_fields;
   uint_nodal_fields["blocked_dofs"] = blocked_dofs;
 
   dumper::Field * field = NULL;
   field = mesh.createNodalField(uint_nodal_fields[field_name], group_name);
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 dumper::Field *
 StructuralMechanicsModel::createNodalFieldReal(const std::string & field_name,
                                                const std::string & group_name,
                                                bool padding_flag) {
 
   UInt n;
   if (spatial_dimension == 2) {
     n = 2;
   } else {
     n = 3;
   }
 
   if (field_name == "displacement") {
     return mesh.createStridedNodalField(displacement_rotation, group_name, n, 0,
                                         padding_flag);
   }
 
   if (field_name == "rotation") {
     return mesh.createStridedNodalField(displacement_rotation, group_name,
                                         nb_degree_of_freedom - n, n,
                                         padding_flag);
   }
 
   if (field_name == "force") {
     return mesh.createStridedNodalField(external_force_momentum, group_name, n,
                                         0, padding_flag);
   }
 
   if (field_name == "momentum") {
     return mesh.createStridedNodalField(external_force_momentum, group_name,
                                         nb_degree_of_freedom - n, n,
                                         padding_flag);
   }
 
   if (field_name == "internal_force") {
     return mesh.createStridedNodalField(internal_force_momentum, group_name, n,
                                         0, padding_flag);
   }
 
   if (field_name == "internal_momentum") {
     return mesh.createStridedNodalField(internal_force_momentum, group_name,
                                         nb_degree_of_freedom - n, n,
                                         padding_flag);
   }
 
   return nullptr;
 }
 
 /* -------------------------------------------------------------------------- */
 dumper::Field * StructuralMechanicsModel::createElementalField(
     const std::string & field_name, const std::string & group_name, bool,
     const ElementKind & kind, const std::string &) {
 
   dumper::Field * field = NULL;
 
   if (field_name == "element_index_by_material")
     field = mesh.createElementalField<UInt, Vector, dumper::ElementalField>(
         field_name, group_name, this->spatial_dimension, kind);
 
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 /* Virtual methods from SolverCallback */
 /* -------------------------------------------------------------------------- */
 /// get the type of matrix needed
 MatrixType StructuralMechanicsModel::getMatrixType(const ID & /*id*/) {
   return _symmetric;
 }
 
 /// callback to assemble a Matrix
 void StructuralMechanicsModel::assembleMatrix(const ID & id) {
   if (id == "K")
     assembleStiffnessMatrix();
 }
 
 /// callback to assemble a lumped Matrix
 void StructuralMechanicsModel::assembleLumpedMatrix(const ID & /*id*/) {}
 
 /// callback to assemble the residual StructuralMechanicsModel::(rhs)
 void StructuralMechanicsModel::assembleResidual() {
   this->getDOFManager().assembleToResidual("displacement",
                                            *this->external_force_momentum, 1);
 }
 
 /* -------------------------------------------------------------------------- */
 /* Virtual methods from MeshEventHandler */
 /* -------------------------------------------------------------------------- */
 
 /// function to implement to react on  akantu::NewNodesEvent
 void StructuralMechanicsModel::onNodesAdded(const Array<UInt> & /*nodes_list*/,
                                             const NewNodesEvent & /*event*/) {}
 /// function to implement to react on  akantu::RemovedNodesEvent
 void StructuralMechanicsModel::onNodesRemoved(
     const Array<UInt> & /*nodes_list*/, const Array<UInt> & /*new_numbering*/,
     const RemovedNodesEvent & /*event*/) {}
 /// function to implement to react on  akantu::NewElementsEvent
 void StructuralMechanicsModel::onElementsAdded(
     const Array<Element> & /*elements_list*/,
     const NewElementsEvent & /*event*/) {}
 /// function to implement to react on  akantu::RemovedElementsEvent
 void StructuralMechanicsModel::onElementsRemoved(
     const Array<Element> & /*elements_list*/,
     const ElementTypeMapArray<UInt> & /*new_numbering*/,
     const RemovedElementsEvent & /*event*/) {}
 /// function to implement to react on  akantu::ChangedElementsEvent
 void StructuralMechanicsModel::onElementsChanged(
     const Array<Element> & /*old_elements_list*/,
     const Array<Element> & /*new_elements_list*/,
     const ElementTypeMapArray<UInt> & /*new_numbering*/,
     const ChangedElementsEvent & /*event*/) {}
 
 /* -------------------------------------------------------------------------- */
 /* Virtual methods from Model */
 /* -------------------------------------------------------------------------- */
 /// get some default values for derived classes
 std::tuple<ID, TimeStepSolverType>
 StructuralMechanicsModel::getDefaultSolverID(const AnalysisMethod & method) {
   switch (method) {
   case _static: {
     return std::make_tuple("static", _tsst_static);
   }
   case _implicit_dynamic: {
     return std::make_tuple("implicit", _tsst_dynamic);
   }
   default:
     return std::make_tuple("unknown", _tsst_not_defined);
   }
 }
 
 /* ------------------------------------------------------------------------ */
 ModelSolverOptions StructuralMechanicsModel::getDefaultSolverOptions(
     const TimeStepSolverType & type) const {
   ModelSolverOptions options;
 
   switch (type) {
   case _tsst_static: {
     options.non_linear_solver_type = _nls_linear;
     options.integration_scheme_type["displacement"] = _ist_pseudo_time;
     options.solution_type["displacement"] = IntegrationScheme::_not_defined;
     break;
   }
   default:
     AKANTU_EXCEPTION(type << " is not a valid time step solver type");
   }
 
   return options;
 }
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/model/structural_mechanics/structural_mechanics_model_inline_impl.cc b/src/model/structural_mechanics/structural_mechanics_model_inline_impl.cc
index ec27c7ede..0e33ccd73 100644
--- a/src/model/structural_mechanics/structural_mechanics_model_inline_impl.cc
+++ b/src/model/structural_mechanics/structural_mechanics_model_inline_impl.cc
@@ -1,361 +1,361 @@
 /**
  * @file   structural_mechanics_model_inline_impl.cc
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Sébastien Hartmann <sebastien.hartmann@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Damien Spielmann <damien.spielmann@epfl.ch>
  *
  * @date creation: Fri Jul 15 2011
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Implementation of inline functions of StructuralMechanicsModel
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "structural_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_STRUCTURAL_MECHANICS_MODEL_INLINE_IMPL_CC__
 #define __AKANTU_STRUCTURAL_MECHANICS_MODEL_INLINE_IMPL_CC__
 
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void StructuralMechanicsModel::computeTangentModuli(
     Array<Real> & /*tangent_moduli*/) {
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
 }
 } // namespace akantu
 
 #include "structural_element_bernoulli_beam_2.hh"
 #include "structural_element_bernoulli_beam_3.hh"
 #include "structural_element_kirchhoff_shell.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void StructuralMechanicsModel::assembleStiffnessMatrix() {
   AKANTU_DEBUG_IN();
 
   auto nb_element = getFEEngine().getMesh().getNbElement(type);
   auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   auto nb_quadrature_points = getFEEngine().getNbIntegrationPoints(type);
   auto tangent_size = ElementClass<type>::getNbStressComponents();
 
   auto tangent_moduli = std::make_unique<Array<Real>>(
       nb_element * nb_quadrature_points, tangent_size * tangent_size,
       "tangent_stiffness_matrix");
   computeTangentModuli<type>(*tangent_moduli);
 
   /// compute @f$\mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   UInt bt_d_b_size = nb_degree_of_freedom * nb_nodes_per_element;
 
   auto bt_d_b = std::make_unique<Array<Real>>(
       nb_element * nb_quadrature_points, bt_d_b_size * bt_d_b_size, "B^t*D*B");
 
   const auto & b = getFEEngine().getShapesDerivatives(type);
 
   Matrix<Real> BtD(bt_d_b_size, tangent_size);
 
   for (auto && tuple :
        zip(make_view(b, tangent_size, bt_d_b_size),
            make_view(*tangent_moduli, tangent_size, tangent_size),
            make_view(*bt_d_b, bt_d_b_size, bt_d_b_size))) {
     auto & B = std::get<0>(tuple);
     auto & D = std::get<1>(tuple);
     auto & BtDB = std::get<2>(tuple);
     BtD.mul<true, false>(B, D);
     BtDB.template mul<false, false>(BtD, B);
   }
 
   /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   auto int_bt_d_b = std::make_unique<Array<Real>>(
       nb_element, bt_d_b_size * bt_d_b_size, "int_B^t*D*B");
 
   getFEEngine().integrate(*bt_d_b, *int_bt_d_b, bt_d_b_size * bt_d_b_size,
                           type);
 
   getDOFManager().assembleElementalMatricesToMatrix(
       "K", "displacement", *int_bt_d_b, type, _not_ghost, _symmetric);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void StructuralMechanicsModel::computeStressOnQuad() {
   AKANTU_DEBUG_IN();
 
   Array<Real> & sigma = stress(type, _not_ghost);
 
   auto nb_element = mesh.getNbElement(type);
   auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   auto nb_quadrature_points = getFEEngine().getNbIntegrationPoints(type);
   auto tangent_size = ElementClass<type>::getNbStressComponents();
 
   auto tangent_moduli = std::make_unique<Array<Real>>(
       nb_element * nb_quadrature_points, tangent_size * tangent_size,
       "tangent_stiffness_matrix");
 
   computeTangentModuli<type>(*tangent_moduli);
 
   /// compute DB
   auto d_b_size = nb_degree_of_freedom * nb_nodes_per_element;
 
   auto d_b = std::make_unique<Array<Real>>(nb_element * nb_quadrature_points,
                                            d_b_size * tangent_size, "D*B");
 
   const auto & b = getFEEngine().getShapesDerivatives(type);
 
   auto B = b.begin(tangent_size, d_b_size);
   auto D = tangent_moduli->begin(tangent_size, tangent_size);
   auto D_B = d_b->begin(tangent_size, d_b_size);
 
   for (UInt e = 0; e < nb_element; ++e) {
     for (UInt q = 0; q < nb_quadrature_points; ++q, ++B, ++D, ++D_B) {
       D_B->template mul<false, false>(*D, *B);
     }
   }
 
   /// compute DBu
   D_B = d_b->begin(tangent_size, d_b_size);
   auto DBu = sigma.begin(tangent_size);
   Vector<Real> ul(d_b_size);
 
   Array<Real> u_el(0, d_b_size);
   FEEngine::extractNodalToElementField(mesh, *displacement_rotation, u_el,
                                        type);
 
   auto ug = u_el.begin(d_b_size);
   auto T = rotation_matrix(type).begin(d_b_size, d_b_size);
 
   for (UInt e = 0; e < nb_element; ++e, ++T, ++ug) {
     ul.mul<false>(*T, *ug);
     for (UInt q = 0; q < nb_quadrature_points; ++q, ++D_B, ++DBu) {
       DBu->template mul<false>(*D_B, ul);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void StructuralMechanicsModel::computeForcesByLocalTractionArray(
     const Array<Real> & tractions) {
   AKANTU_DEBUG_IN();
 
 #if 0
   UInt nb_element = getFEEngine().getMesh().getNbElement(type);
   UInt nb_nodes_per_element =
       getFEEngine().getMesh().getNbNodesPerElement(type);
   UInt nb_quad = getFEEngine().getNbIntegrationPoints(type);
 
   // check dimension match
   AKANTU_DEBUG_ASSERT(
       Mesh::getSpatialDimension(type) == getFEEngine().getElementDimension(),
       "element type dimension does not match the dimension of boundaries : "
           << getFEEngine().getElementDimension()
           << " != " << Mesh::getSpatialDimension(type));
 
   // check size of the vector
   AKANTU_DEBUG_ASSERT(
       tractions.size() == nb_quad * nb_element,
       "the size of the vector should be the total number of quadrature points");
 
   // check number of components
   AKANTU_DEBUG_ASSERT(tractions.getNbComponent() == nb_degree_of_freedom,
                       "the number of components should be the spatial "
                       "dimension of the problem");
 
   Array<Real> Nvoigt(nb_element * nb_quad, nb_degree_of_freedom *
                                                nb_degree_of_freedom *
                                                nb_nodes_per_element);
   transferNMatrixToSymVoigtNMatrix<type>(Nvoigt);
 
   Array<Real>::const_matrix_iterator N_it = Nvoigt.begin(
       nb_degree_of_freedom, nb_degree_of_freedom * nb_nodes_per_element);
   Array<Real>::const_matrix_iterator T_it =
       rotation_matrix(type).begin(nb_degree_of_freedom * nb_nodes_per_element,
                                   nb_degree_of_freedom * nb_nodes_per_element);
   Array<Real>::const_vector_iterator te_it =
       tractions.begin(nb_degree_of_freedom);
 
   Array<Real> funct(nb_element * nb_quad,
                     nb_degree_of_freedom * nb_nodes_per_element, 0.);
   Array<Real>::iterator<Vector<Real>> Fe_it =
       funct.begin(nb_degree_of_freedom * nb_nodes_per_element);
 
   Vector<Real> fe(nb_degree_of_freedom * nb_nodes_per_element);
   for (UInt e = 0; e < nb_element; ++e, ++T_it) {
     const Matrix<Real> & T = *T_it;
     for (UInt q = 0; q < nb_quad; ++q, ++N_it, ++te_it, ++Fe_it) {
       const Matrix<Real> & N = *N_it;
       const Vector<Real> & te = *te_it;
       Vector<Real> & Fe = *Fe_it;
 
       // compute N^t tl
       fe.mul<true>(N, te);
       // turn N^t tl back in the global referential
       Fe.mul<true>(T, fe);
     }
   }
 
   // allocate the vector that will contain the integrated values
   std::stringstream name;
   name << id << type << ":integral_boundary";
   Array<Real> int_funct(nb_element, nb_degree_of_freedom * nb_nodes_per_element,
                         name.str());
 
   // do the integration
   getFEEngine().integrate(funct, int_funct,
                           nb_degree_of_freedom * nb_nodes_per_element, type);
 
   // assemble the result into force vector
   getFEEngine().assembleArray(int_funct, *force_momentum,
                               dof_synchronizer->getLocalDOFEquationNumbers(),
                               nb_degree_of_freedom, type);
 #endif
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void StructuralMechanicsModel::computeForcesByGlobalTractionArray(
     const Array<Real> & traction_global) {
   AKANTU_DEBUG_IN();
 #if 0
   UInt nb_element = mesh.getNbElement(type);
   UInt nb_quad = getFEEngine().getNbIntegrationPoints(type);
   UInt nb_nodes_per_element =
       getFEEngine().getMesh().getNbNodesPerElement(type);
 
   std::stringstream name;
   name << id << ":structuralmechanics:imposed_linear_load";
   Array<Real> traction_local(nb_element * nb_quad, nb_degree_of_freedom,
                              name.str());
 
   Array<Real>::const_matrix_iterator T_it =
       rotation_matrix(type).begin(nb_degree_of_freedom * nb_nodes_per_element,
                                   nb_degree_of_freedom * nb_nodes_per_element);
 
   Array<Real>::const_iterator<Vector<Real>> Te_it =
       traction_global.begin(nb_degree_of_freedom);
   Array<Real>::iterator<Vector<Real>> te_it =
       traction_local.begin(nb_degree_of_freedom);
 
   Matrix<Real> R(nb_degree_of_freedom, nb_degree_of_freedom);
   for (UInt e = 0; e < nb_element; ++e, ++T_it) {
     const Matrix<Real> & T = *T_it;
     for (UInt i = 0; i < nb_degree_of_freedom; ++i)
       for (UInt j = 0; j < nb_degree_of_freedom; ++j)
         R(i, j) = T(i, j);
 
     for (UInt q = 0; q < nb_quad; ++q, ++Te_it, ++te_it) {
       const Vector<Real> & Te = *Te_it;
       Vector<Real> & te = *te_it;
       // turn the traction in the local referential
       te.mul<false>(R, Te);
     }
   }
 
   computeForcesByLocalTractionArray<type>(traction_local);
 #endif
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * @param myf pointer  to a function that fills a  vector/tensor with respect to
  * passed coordinates
  */
 #if 0
 template <ElementType type>
 inline void StructuralMechanicsModel::computeForcesFromFunction(
     BoundaryFunction myf, BoundaryFunctionType function_type) {
   /** function type is
    ** _bft_forces : linear load is given
    ** _bft_stress : stress function is given -> Not already done for this kind
    *of model
    */
 
   std::stringstream name;
   name << id << ":structuralmechanics:imposed_linear_load";
   Array<Real> lin_load(0, nb_degree_of_freedom, name.str());
   name.clear();
 
   UInt offset = nb_degree_of_freedom;
 
   // prepare the loop over element types
   UInt nb_quad = getFEEngine().getNbIntegrationPoints(type);
   UInt nb_element = getFEEngine().getMesh().getNbElement(type);
 
   name.clear();
   name << id << ":structuralmechanics:quad_coords";
   Array<Real> quad_coords(nb_element * nb_quad, spatial_dimension,
                           "quad_coords");
 
   getFEEngineClass<MyFEEngineType>()
       .getShapeFunctions()
       .interpolateOnIntegrationPoints<type>(getFEEngine().getMesh().getNodes(),
                                             quad_coords, spatial_dimension);
   getFEEngineClass<MyFEEngineType>()
       .getShapeFunctions()
       .interpolateOnIntegrationPoints<type>(
           getFEEngine().getMesh().getNodes(), quad_coords, spatial_dimension,
           _not_ghost, empty_filter, true, 0, 1, 1);
   if (spatial_dimension == 3)
     getFEEngineClass<MyFEEngineType>()
         .getShapeFunctions()
         .interpolateOnIntegrationPoints<type>(
             getFEEngine().getMesh().getNodes(), quad_coords, spatial_dimension,
             _not_ghost, empty_filter, true, 0, 2, 2);
   lin_load.resize(nb_element * nb_quad);
   Real * imposed_val = lin_load.storage();
 
   /// sigma/load on each quadrature points
   Real * qcoord = quad_coords.storage();
   for (UInt el = 0; el < nb_element; ++el) {
     for (UInt q = 0; q < nb_quad; ++q) {
       myf(qcoord, imposed_val, NULL, 0);
       imposed_val += offset;
       qcoord += spatial_dimension;
     }
   }
 
   switch (function_type) {
   case _bft_traction_local:
     computeForcesByLocalTractionArray<type>(lin_load);
     break;
   case _bft_traction:
     computeForcesByGlobalTractionArray<type>(lin_load);
     break;
   default:
     break;
   }
 }
 #endif
 } // namespace akantu
 
 #endif /* __AKANTU_STRUCTURAL_MECHANICS_MODEL_INLINE_IMPL_CC__ */
diff --git a/src/model/time_step_solvers/time_step_solver_default.cc b/src/model/time_step_solvers/time_step_solver_default.cc
index 747378f1d..95e038d65 100644
--- a/src/model/time_step_solvers/time_step_solver_default.cc
+++ b/src/model/time_step_solvers/time_step_solver_default.cc
@@ -1,282 +1,282 @@
 /**
  * @file   time_step_solver_default.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Sep 16 10:20:55 2015
  *
  * @brief  Default implementation of the time step solver
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 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 "time_step_solver_default.hh"
 #include "dof_manager_default.hh"
 #include "integration_scheme_1st_order.hh"
 #include "integration_scheme_2nd_order.hh"
 #include "mesh.hh"
 #include "non_linear_solver.hh"
 #include "pseudo_time.hh"
 #include "sparse_matrix_aij.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolverDefault::TimeStepSolverDefault(
     DOFManagerDefault & dof_manager, const TimeStepSolverType & type,
     NonLinearSolver & non_linear_solver, const ID & id, UInt memory_id)
     : TimeStepSolver(dof_manager, type, non_linear_solver, id, memory_id),
       dof_manager(dof_manager), is_mass_lumped(false) {
   switch (type) {
   case _tsst_dynamic:
     break;
   case _tsst_dynamic_lumped:
     this->is_mass_lumped = true;
     break;
   case _tsst_static:
     /// initialize a static time solver for callback dofs
     break;
   default:
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void TimeStepSolverDefault::setIntegrationScheme(
     const ID & dof_id, const IntegrationSchemeType & type,
     IntegrationScheme::SolutionType solution_type) {
   if (this->integration_schemes.find(dof_id) !=
       this->integration_schemes.end()) {
     AKANTU_EXCEPTION("Their DOFs "
                      << dof_id
                      << "  have already an integration scheme associated");
   }
 
   std::unique_ptr<IntegrationScheme> integration_scheme;
   if (this->is_mass_lumped) {
     switch (type) {
     case _ist_forward_euler: {
       integration_scheme = std::make_unique<ForwardEuler>(dof_manager, dof_id);
       break;
     }
     case _ist_central_difference: {
       integration_scheme =
           std::make_unique<CentralDifference>(dof_manager, dof_id);
       break;
     }
     default:
       AKANTU_EXCEPTION(
           "This integration scheme cannot be used in lumped dynamic");
     }
   } else {
     switch (type) {
     case _ist_pseudo_time: {
       integration_scheme = std::make_unique<PseudoTime>(dof_manager, dof_id);
       break;
     }
     case _ist_forward_euler: {
       integration_scheme = std::make_unique<ForwardEuler>(dof_manager, dof_id);
       break;
     }
     case _ist_trapezoidal_rule_1: {
       integration_scheme =
           std::make_unique<TrapezoidalRule1>(dof_manager, dof_id);
       break;
     }
     case _ist_backward_euler: {
       integration_scheme = std::make_unique<BackwardEuler>(dof_manager, dof_id);
       break;
     }
     case _ist_central_difference: {
       integration_scheme =
           std::make_unique<CentralDifference>(dof_manager, dof_id);
       break;
     }
     case _ist_fox_goodwin: {
       integration_scheme = std::make_unique<FoxGoodwin>(dof_manager, dof_id);
       break;
     }
     case _ist_trapezoidal_rule_2: {
       integration_scheme =
           std::make_unique<TrapezoidalRule2>(dof_manager, dof_id);
       break;
     }
     case _ist_linear_acceleration: {
       integration_scheme =
           std::make_unique<LinearAceleration>(dof_manager, dof_id);
       break;
     }
     case _ist_generalized_trapezoidal: {
       integration_scheme =
           std::make_unique<GeneralizedTrapezoidal>(dof_manager, dof_id);
       break;
     }
     case _ist_newmark_beta:
       integration_scheme = std::make_unique<NewmarkBeta>(dof_manager, dof_id);
       break;
     }
   }
 
   AKANTU_DEBUG_ASSERT(integration_scheme,
                       "No integration scheme was found for the provided types");
 
   auto && matrices_names = integration_scheme->getNeededMatrixList();
   for (auto && name : matrices_names) {
     needed_matrices.insert({name, _mt_not_defined});
   }
 
   this->integration_schemes[dof_id] = std::move(integration_scheme);
   this->solution_types[dof_id] = solution_type;
 
   this->integration_schemes_owner.insert(dof_id);
 }
 
 /* -------------------------------------------------------------------------- */
 bool TimeStepSolverDefault::hasIntegrationScheme(const ID & dof_id) const {
   return this->integration_schemes.find(dof_id) !=
          this->integration_schemes.end();
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolverDefault::~TimeStepSolverDefault() = default;
 
 /* -------------------------------------------------------------------------- */
 void TimeStepSolverDefault::solveStep(SolverCallback & solver_callback) {
   this->solver_callback = &solver_callback;
 
   this->solver_callback->beforeSolveStep();
   this->non_linear_solver.solve(*this);
   this->solver_callback->afterSolveStep();
 
   this->solver_callback = nullptr;
 }
 
 /* -------------------------------------------------------------------------- */
 void TimeStepSolverDefault::predictor() {
   AKANTU_DEBUG_IN();
 
   TimeStepSolver::predictor();
 
   for (auto & pair : this->integration_schemes) {
     auto & dof_id = pair.first;
     auto & integration_scheme = pair.second;
 
     if (this->dof_manager.hasPreviousDOFs(dof_id)) {
       this->dof_manager.savePreviousDOFs(dof_id);
     }
 
     /// integrator predictor
     integration_scheme->predictor(this->time_step);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void TimeStepSolverDefault::corrector() {
   AKANTU_DEBUG_IN();
 
   TimeStepSolver::corrector();
 
   for (auto & pair : this->integration_schemes) {
     auto & dof_id = pair.first;
     auto & integration_scheme = pair.second;
 
     const auto & solution_type = this->solution_types[dof_id];
     integration_scheme->corrector(solution_type, this->time_step);
 
     /// computing the increment of dof if needed
     if (this->dof_manager.hasDOFsIncrement(dof_id)) {
       if (!this->dof_manager.hasPreviousDOFs(dof_id)) {
         AKANTU_DEBUG_WARNING("In order to compute the increment of "
                              << dof_id << " a 'previous' has to be registered");
         continue;
       }
 
       Array<Real> & increment = this->dof_manager.getDOFsIncrement(dof_id);
       Array<Real> & previous = this->dof_manager.getPreviousDOFs(dof_id);
 
       UInt dof_array_comp = this->dof_manager.getDOFs(dof_id).getNbComponent();
 
       auto prev_dof_it = previous.begin(dof_array_comp);
       auto incr_it = increment.begin(dof_array_comp);
       auto incr_end = increment.end(dof_array_comp);
 
       increment.copy(this->dof_manager.getDOFs(dof_id));
       for (; incr_it != incr_end; ++incr_it, ++prev_dof_it) {
         *incr_it -= *prev_dof_it;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void TimeStepSolverDefault::assembleMatrix(const ID & matrix_id) {
   AKANTU_DEBUG_IN();
 
   TimeStepSolver::assembleMatrix(matrix_id);
 
   if (matrix_id != "J")
     return;
 
   for (auto & pair : this->integration_schemes) {
     auto & dof_id = pair.first;
     auto & integration_scheme = pair.second;
 
     const auto & solution_type = this->solution_types[dof_id];
 
     integration_scheme->assembleJacobian(solution_type, this->time_step);
   }
 
   this->dof_manager.applyBoundary("J");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void TimeStepSolverDefault::assembleResidual() {
   AKANTU_DEBUG_IN();
 
   if (this->needed_matrices.find("M") != needed_matrices.end()) {
     if (this->is_mass_lumped) {
       this->assembleLumpedMatrix("M");
     } else {
       this->assembleMatrix("M");
     }
   }
 
   TimeStepSolver::assembleResidual();
 
   for (auto & pair : this->integration_schemes) {
     auto & integration_scheme = pair.second;
 
     integration_scheme->assembleResidual(this->is_mass_lumped);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/python/python_functor_inline_impl.cc b/src/python/python_functor_inline_impl.cc
index 38ceb9b6c..27ea3b174 100644
--- a/src/python/python_functor_inline_impl.cc
+++ b/src/python/python_functor_inline_impl.cc
@@ -1,463 +1,463 @@
 /**
  * @file   python_functor_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *
  * @date creation: Fri Nov 13 2015
  * @date last modification: Wed Nov 18 2015
  *
  * @brief  Python functor interface
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 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 "integration_point.hh"
 #include "internal_field.hh"
 /* -------------------------------------------------------------------------- */
 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
 #include <Python.h>
 #include <numpy/arrayobject.h>
 #include <typeinfo>
 #if PY_MAJOR_VERSION >= 3
 #include <codecvt>
 #endif
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_PYTHON_FUNCTOR_INLINE_IMPL_CC__
 #define __AKANTU_PYTHON_FUNCTOR_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename T> inline int PythonFunctor::getPythonDataTypeCode() {
   AKANTU_EXCEPTION("undefined type: " << debug::demangle(typeid(T).name()));
 }
 
 /* -------------------------------------------------------------------------- */
 template <> inline int PythonFunctor::getPythonDataTypeCode<bool>() {
   int data_typecode = NPY_NOTYPE;
   size_t s = sizeof(bool);
   switch (s) {
   case 1:
     data_typecode = NPY_BOOL;
     break;
   case 2:
     data_typecode = NPY_UINT16;
     break;
   case 4:
     data_typecode = NPY_UINT32;
     break;
   case 8:
     data_typecode = NPY_UINT64;
     break;
   }
   return data_typecode;
 }
 
 /* -------------------------------------------------------------------------- */
 template <> inline int PythonFunctor::getPythonDataTypeCode<double>() {
   return NPY_DOUBLE;
 }
 
 /* -------------------------------------------------------------------------- */
 template <> inline int PythonFunctor::getPythonDataTypeCode<UInt>() {
   return NPY_UINT;
 }
 
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<double>(const double & akantu_object) {
   return PyFloat_FromDouble(akantu_object);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<UInt>(const UInt & akantu_object) {
 #if PY_MAJOR_VERSION >= 3
   return PyLong_FromLong(akantu_object);
 #else
   return PyInt_FromLong(akantu_object);
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<int>(const int & akantu_object) {
 #if PY_MAJOR_VERSION >= 3
   return PyLong_FromLong(akantu_object);
 #else
   return PyInt_FromLong(akantu_object);
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<bool>(const bool & akantu_object) {
   return PyBool_FromLong(long(akantu_object));
 }
 /* -------------------------------------------------------------------------- */
 
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<std::string>(const std::string & str) {
 #if PY_MAJOR_VERSION >= 3
   return PyUnicode_FromString(str.c_str());
 #else
   return PyString_FromString(str.c_str());
 #endif
 }
 
 /* --------------------------------------------------------------------------
  */
 
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<NodeGroup>(const NodeGroup & group) {
   return PythonFunctor::convertToPython(group.getNodes());
 }
 
 /* --------------------------------------------------------------------------
  */
 
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<ElementGroup>(const ElementGroup & group) {
 
   PyObject * res = PyDict_New();
 
   PyDict_SetItem(res,
                  PythonFunctor::convertToPython(std::string("element_group")),
                  PythonFunctor::convertToPython(group.getElements()));
 
   PyDict_SetItem(res, PythonFunctor::convertToPython(std::string("node_group")),
                  PythonFunctor::convertToPython(group.getNodeGroup()));
 
   return res;
 }
 
 /* --------------------------------------------------------------------------
  */
 
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<ElementGroup *>(ElementGroup * const & group) {
   return PythonFunctor::convertToPython(*group);
 }
 
 /* --------------------------------------------------------------------------
  */
 
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<ElementType>(const ElementType & type) {
   // std::stringstream sstr;
   // sstr << type;
   // return PythonFunctor::convertToPython(sstr.str());
   return PythonFunctor::convertToPython(int(type));
 }
 
 /* --------------------------------------------------------------------------
  */
 
 template <typename T>
 inline PyObject *
 PythonFunctor::convertToPython(const ElementTypeMapArray<T> & map) {
 
   std::map<std::string, Array<T> *> res;
   for (const auto & type : map.elementTypes()) {
     std::stringstream sstr;
     sstr << type;
     res[sstr.str()] = const_cast<Array<T> *>(&map(type));
   }
   return PythonFunctor::convertToPython(res);
 }
 
 /* --------------------------------------------------------------------------
  */
 
 template <typename T> PyObject * PythonFunctor::convertToPython(const T &) {
   AKANTU_EXCEPTION(__PRETTY_FUNCTION__ << " : not implemented yet !"
                                        << std::endl
                                        << debug::demangle(typeid(T).name()));
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline PyObject * PythonFunctor::convertToPython(const std::vector<T> & array) {
   int data_typecode = getPythonDataTypeCode<T>();
   npy_intp dims[1] = {int(array.size())};
   PyObject * obj = PyArray_SimpleNewFromData(1, dims, data_typecode,
                                              const_cast<T *>(&array[0]));
   auto * res = (PyArrayObject *)obj;
   return (PyObject *)res;
 }
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline PyObject *
 PythonFunctor::convertToPython(const std::vector<Array<T> *> & array) {
 
   PyObject * res = PyDict_New();
 
   for (auto a : array) {
     PyObject * obj = PythonFunctor::convertToPython(*a);
     PyObject * name = PythonFunctor::convertToPython(a->getID());
     PyDict_SetItem(res, name, obj);
   }
   return (PyObject *)res;
 }
 /* -------------------------------------------------------------------------- */
 
 template <typename T1, typename T2>
 inline PyObject * PythonFunctor::convertToPython(const std::map<T1, T2> & map) {
 
   PyObject * res = PyDict_New();
 
   for (auto && a : map) {
     PyObject * key = PythonFunctor::convertToPython(a.first);
     PyObject * value = PythonFunctor::convertToPython(a.second);
     PyDict_SetItem(res, key, value);
   }
   return (PyObject *)res;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 PyObject * PythonFunctor::convertToPython(const Vector<T> & array) {
   int data_typecode = getPythonDataTypeCode<T>();
   npy_intp dims[1] = {array.size()};
   PyObject * obj =
       PyArray_SimpleNewFromData(1, dims, data_typecode, array.storage());
   auto * res = (PyArrayObject *)obj;
   return (PyObject *)res;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline PyObject *
 PythonFunctor::convertToPython(const InternalField<T> & internals) {
   return convertToPython(
       static_cast<const ElementTypeMapArray<T> &>(internals));
 }
 
 /* --------------------------------------------------------------------- */
 
 template <typename T>
 inline PyObject * PythonFunctor::convertToPython(const std::unique_ptr<T> & u) {
   return convertToPython(*u);
 }
 
 /* --------------------------------------------------------------------- */
 
 template <typename T>
 PyObject * PythonFunctor::convertToPython(const Array<T> & array) {
   int data_typecode = getPythonDataTypeCode<T>();
   npy_intp dims[2] = {array.size(), array.getNbComponent()};
   PyObject * obj =
       PyArray_SimpleNewFromData(2, dims, data_typecode, array.storage());
   auto * res = (PyArrayObject *)obj;
   return (PyObject *)res;
 }
 /* ---------------------------------------------------------------------- */
 template <typename T>
 PyObject * PythonFunctor::convertToPython(Array<T> * array) {
   return PythonFunctor::convertToPython(*array);
 }
 
 /* ---------------------------------------------------------------------- */
 template <typename T>
 PyObject * PythonFunctor::convertToPython(const Matrix<T> & mat) {
   int data_typecode = getPythonDataTypeCode<T>();
   npy_intp dims[2] = {mat.size(0), mat.size(1)};
   PyObject * obj =
       PyArray_SimpleNewFromData(2, dims, data_typecode, mat.storage());
   auto * res = (PyArrayObject *)obj;
   return (PyObject *)res;
 }
 
 /* ---------------------------------------------------------------------- */
 
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<IntegrationPoint>(const IntegrationPoint & qp) {
 
   PyObject * input = PyDict_New();
   PyObject * num_point = PythonFunctor::convertToPython(qp.num_point);
   PyObject * global_num = PythonFunctor::convertToPython(qp.global_num);
   PyObject * material_id = PythonFunctor::convertToPython(qp.material_id);
   PyObject * position = PythonFunctor::convertToPython(qp.getPosition());
   PyDict_SetItemString(input, "num_point", num_point);
   PyDict_SetItemString(input, "global_num", global_num);
   PyDict_SetItemString(input, "material_id", material_id);
   PyDict_SetItemString(input, "position", position);
   return input;
 }
 
 /* --------------------------------------------------------------------------
  */
 inline PyObject *
 PythonFunctor::getPythonFunction(const std::string & functor_name) const {
 #if PY_MAJOR_VERSION < 3
   if (!PyInstance_Check(this->python_obj))
     AKANTU_EXCEPTION("Python object is not an instance");
 #else
 // does not make sense to check everything is an instance of object in python 3
 #endif
 
   if (not PyObject_HasAttrString(this->python_obj, functor_name.c_str()))
     AKANTU_EXCEPTION("Python dictionary has no " << functor_name << " entry");
 
   PyObject * pFunctor =
       PyObject_GetAttrString(this->python_obj, functor_name.c_str());
 
   return pFunctor;
 }
 
 /* --------------------------------------------------------------------------
  */
 inline void PythonFunctor::packArguments(__attribute__((unused))
                                          std::vector<PyObject *> & p_args) {}
 
 /* --------------------------------------------------------------------------
  */
 template <typename T, typename... Args>
 inline void PythonFunctor::packArguments(std::vector<PyObject *> & p_args,
                                          T & p, Args &... params) {
   p_args.push_back(PythonFunctor::convertToPython(p));
   if (sizeof...(params) != 0)
     PythonFunctor::packArguments(p_args, params...);
 }
 
 /* --------------------------------------------------------------------------
  */
 template <typename return_type, typename... Params>
 return_type PythonFunctor::callFunctor(const std::string & functor_name,
                                        Params &... parameters) const {
   _import_array();
 
   std::vector<PyObject *> arg_vector;
   this->packArguments(arg_vector, parameters...);
 
   PyObject * pArgs = PyTuple_New(arg_vector.size());
   for (UInt i = 0; i < arg_vector.size(); ++i) {
     PyTuple_SetItem(pArgs, i, arg_vector[i]);
   }
 
   PyObject * kwargs = PyDict_New();
 
   PyObject * pFunctor = this->getPythonFunction(functor_name);
   PyObject * res = this->callFunctor(pFunctor, pArgs, kwargs);
 
   Py_XDECREF(pArgs);
   Py_XDECREF(kwargs);
 
   return this->convertToAkantu<return_type>(res);
 }
 
 /* --------------------------------------------------------------------------
  */
 template <typename return_type>
 inline return_type PythonFunctor::convertToAkantu(PyObject * python_obj) {
 
   if (PyList_Check(python_obj)) {
     return PythonFunctor::convertListToAkantu<typename return_type::value_type>(
         python_obj);
   }
-  AKANTU_DEBUG_TO_IMPLEMENT();
+  AKANTU_TO_IMPLEMENT();
 }
 
 /* --------------------------------------------------------------------------
  */
 template <>
 inline void PythonFunctor::convertToAkantu<void>(PyObject * python_obj) {
   if (python_obj != Py_None)
     AKANTU_DEBUG_WARNING(
         "functor return a value while none was expected: ignored");
 }
 
 /* --------------------------------------------------------------------------
  */
 template <>
 inline std::string
 PythonFunctor::convertToAkantu<std::string>(PyObject * python_obj) {
 #if PY_MAJOR_VERSION >= 3
   if (!PyUnicode_Check(python_obj))
     AKANTU_EXCEPTION("cannot convert object to string");
 
   std::wstring unicode_str(PyUnicode_AsWideCharString(python_obj, NULL));
   std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> converter;
   return converter.to_bytes(unicode_str);
 #else
   if (!PyString_Check(python_obj))
     AKANTU_EXCEPTION("cannot convert object to string");
 
   return PyString_AsString(python_obj);
 #endif
 }
 
 /* --------------------------------------------------------------------------
  */
 template <>
 inline Real PythonFunctor::convertToAkantu<Real>(PyObject * python_obj) {
   if (!PyFloat_Check(python_obj))
     AKANTU_EXCEPTION("cannot convert object to float");
   return PyFloat_AsDouble(python_obj);
 }
 /* --------------------------------------------------------------------------
  */
 template <>
 inline UInt PythonFunctor::convertToAkantu<UInt>(PyObject * python_obj) {
 #if PY_MAJOR_VERSION >= 3
   if (!PyLong_Check(python_obj))
     AKANTU_EXCEPTION("cannot convert object to integer");
   return PyLong_AsLong(python_obj);
 #else
   if (!PyInt_Check(python_obj))
     AKANTU_EXCEPTION("cannot convert object to integer");
   return PyInt_AsLong(python_obj);
 #endif
 }
 
 /* --------------------------------------------------------------------------
  */
 template <typename T>
 inline std::vector<T>
 PythonFunctor::convertListToAkantu(PyObject * python_obj) {
   std::vector<T> res;
   UInt size = PyList_Size(python_obj);
   for (UInt i = 0; i < size; ++i) {
     PyObject * item = PyList_GET_ITEM(python_obj, i);
     res.push_back(PythonFunctor::convertToAkantu<T>(item));
   }
   return res;
 }
 
 /* --------------------------------------------------------------------------
  */
 
 } // akantu
 
 #endif /* __AKANTU_PYTHON_FUNCTOR_INLINE_IMPL_CC__ */
diff --git a/src/solver/sparse_matrix.hh b/src/solver/sparse_matrix.hh
index cc11e119e..db9709e96 100644
--- a/src/solver/sparse_matrix.hh
+++ b/src/solver/sparse_matrix.hh
@@ -1,159 +1,159 @@
 
 /**
  * @file   sparse_matrix.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Dec 13 2010
  * @date last modification: Fri Oct 16 2015
  *
  * @brief  sparse matrix storage class (distributed assembled matrix)
  * This is a COO format (Coordinate List)
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "aka_common.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SPARSE_MATRIX_HH__
 #define __AKANTU_SPARSE_MATRIX_HH__
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 class DOFManager;
 class TermsToAssemble;
 }
 
 namespace akantu {
 
 class SparseMatrix {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   SparseMatrix(DOFManager & dof_manager, const MatrixType & matrix_type,
                const ID & id = "sparse_matrix");
 
   SparseMatrix(const SparseMatrix & matrix, const ID & id = "sparse_matrix");
 
   virtual ~SparseMatrix();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// remove the existing profile
   virtual void clearProfile();
 
   /// set the matrix to 0
   virtual void clear() = 0;
 
   /// add a non-zero element to the profile
   virtual UInt add(UInt i, UInt j) = 0;
 
   /// assemble a local matrix in the sparse one
   virtual void add(UInt i, UInt j, Real value) = 0;
 
   /// save the profil in a file using the MatrixMarket file format
   virtual void saveProfile(__attribute__((unused)) const std::string &) const {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   /// save the matrix in a file using the MatrixMarket file format
   virtual void saveMatrix(__attribute__((unused)) const std::string &) const {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   };
 
   /// multiply the matrix by a coefficient
   virtual void mul(Real alpha) = 0;
 
   /// add matrices
   virtual void add(const SparseMatrix & matrix, Real alpha = 1.);
 
   /// Equivalent of *gemv in blas
   virtual void matVecMul(const Array<Real> & x, Array<Real> & y,
                          Real alpha = 1., Real beta = 0.) const = 0;
 
   /// modify the matrix to "remove" the blocked dof
   virtual void applyBoundary(Real block_val = 1.) = 0;
 
   /// operator *=
   SparseMatrix & operator*=(Real alpha) { this->mul(alpha); return *this; }
 
 protected:
   /// This is the revert of add B += \alpha * *this;
   virtual void addMeTo(SparseMatrix & B, Real alpha) const = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// return the values at potition i, j
   virtual inline Real operator()(__attribute__((unused)) UInt i,
                                  __attribute__((unused)) UInt j) const {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
   /// return the values at potition i, j
   virtual inline Real & operator()(__attribute__((unused)) UInt i,
                                    __attribute__((unused)) UInt j) {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
   AKANTU_GET_MACRO(NbNonZero, nb_non_zero, UInt);
   UInt size() const { return size_;}
   AKANTU_GET_MACRO(MatrixType, matrix_type, const MatrixType &);
 
   virtual UInt getRelease() const = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   ID id;
 
   /// Underlying dof manager
   DOFManager & _dof_manager;
 
   /// sparce matrix type
   MatrixType matrix_type;
 
   /// Size of the matrix
   UInt size_;
 
   /// number of processors
   UInt nb_proc;
 
   /// number of non zero element
   UInt nb_non_zero;
 };
 
 Array<Real> & operator*=(Array<Real> & vect, const SparseMatrix & mat);
 
 } // akantu
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 #include "sparse_matrix_inline_impl.cc"
 
 #endif /* __AKANTU_SPARSE_MATRIX_HH__ */
diff --git a/src/solver/sparse_solver_mumps.cc b/src/solver/sparse_solver_mumps.cc
index 2342a4162..de1b3e032 100644
--- a/src/solver/sparse_solver_mumps.cc
+++ b/src/solver/sparse_solver_mumps.cc
@@ -1,448 +1,448 @@
 /**
  * @file   sparse_solver_mumps.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Dec 13 2010
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  implem of SparseSolverMumps class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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/>.
  *
  * @section DESCRIPTION
  *
  * @subsection Ctrl_param Control parameters
  *
  * ICNTL(1),
  * ICNTL(2),
  * ICNTL(3) : output streams for error, diagnostics, and global messages
  *
  * ICNTL(4) : verbose level : 0 no message - 4 all messages
  *
  * ICNTL(5) : type of matrix, 0 assembled, 1 elementary
  *
  * ICNTL(6) : control  the permutation and scaling(default 7)  see mumps doc for
  * more information
  *
  * ICNTL(7) : determine  the pivot  order (default  7) see  mumps doc  for more
  * information
  *
  * ICNTL(8) : describe the scaling method used
  *
  * ICNTL(9) : 1 solve A x = b, 0 solve At x = b
  *
  * ICNTL(10) : number of iterative refinement when NRHS = 1
  *
  * ICNTL(11) : > 0 return statistics
  *
  * ICNTL(12) : only used for SYM = 2, ordering strategy
  *
  * ICNTL(13) :
  *
  * ICNTL(14) : percentage of increase of the estimated working space
  *
  * ICNTL(15-17) : not used
  *
  * ICNTL(18) : only  used if ICNTL(5) = 0, 0 matrix  centralized, 1 structure on
  * host and mumps  give the mapping, 2 structure on  host and distributed matrix
  * for facto, 3 distributed matrix
  *
  * ICNTL(19) : > 0, Shur complement returned
  *
  * ICNTL(20) : 0 rhs dense, 1 rhs sparse
  *
  * ICNTL(21) : 0 solution in rhs, 1 solution distributed in ISOL_loc and SOL_loc
  * allocated by user
  *
  * ICNTL(22) : 0 in-core, 1 out-of-core
  *
  * ICNTL(23) : maximum memory allocatable by mumps pre proc
  *
  * ICNTL(24) : controls the detection of "null pivot rows"
  *
  * ICNTL(25) :
  *
  * ICNTL(26) :
  *
  * ICNTL(27) :
  *
  * ICNTL(28) : 0 automatic choice, 1 sequential analysis, 2 parallel analysis
  *
  * ICNTL(29) : 0 automatic choice, 1 PT-Scotch, 2 ParMetis
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "dof_manager_default.hh"
 #include "dof_synchronizer.hh"
 #include "sparse_matrix_aij.hh"
 
 #if defined(AKANTU_USE_MPI)
 #include "mpi_communicator_data.hh"
 #endif
 
 #include "sparse_solver_mumps.hh"
 
 /* -------------------------------------------------------------------------- */
 // static std::ostream & operator <<(std::ostream & stream, const DMUMPS_STRUC_C
 // & _this) {
 //   stream << "DMUMPS Data [" << std::endl;
 //   stream << " + job          : " << _this.job          << std::endl;
 //   stream << " + par          : " << _this.par          << std::endl;
 //   stream << " + sym          : " << _this.sym          << std::endl;
 //   stream << " + comm_fortran : " << _this.comm_fortran << std::endl;
 //   stream << " + nz           : " << _this.nz           << std::endl;
 //   stream << " + irn          : " << _this.irn          << std::endl;
 //   stream << " + jcn          : " << _this.jcn          << std::endl;
 //   stream << " + nz_loc       : " << _this.nz_loc       << std::endl;
 //   stream << " + irn_loc      : " << _this.irn_loc      << std::endl;
 //   stream << " + jcn_loc      : " << _this.jcn_loc      << std::endl;
 //   stream << "]";
 //   return stream;
 // }
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 SparseSolverMumps::SparseSolverMumps(DOFManagerDefault & dof_manager,
                                      const ID & matrix_id, const ID & id,
                                      const MemoryID & memory_id)
     : SparseSolver(dof_manager, matrix_id, id, memory_id),
       dof_manager(dof_manager),
       master_rhs_solution(0, 1) {
   AKANTU_DEBUG_IN();
 
   this->prank = communicator.whoAmI();
 
 #ifdef AKANTU_USE_MPI
   this->parallel_method = _fully_distributed;
 #else  // AKANTU_USE_MPI
   this->parallel_method = _not_parallel;
 #endif // AKANTU_USE_MPI
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 SparseSolverMumps::~SparseSolverMumps() {
   AKANTU_DEBUG_IN();
 
   mumpsDataDestroy();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::mumpsDataDestroy() {
   if (this->is_initialized) {
     this->mumps_data.job = _smj_destroy; // destroy
     dmumps_c(&this->mumps_data);
     this->is_initialized = false;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::destroyInternalData() {
   mumpsDataDestroy();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::checkInitialized() {
   if (this->is_initialized) return;
 
   this->initialize();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::setOutputLevel() {
   // Output setup
   icntl(1) = 0; // error output
   icntl(2) = 0; // diagnostics output
   icntl(3) = 0; // information
   icntl(4) = 0;
 
 #if !defined(AKANTU_NDEBUG)
   DebugLevel dbg_lvl = debug::debugger.getDebugLevel();
 
   if (AKANTU_DEBUG_TEST(dblDump)) {
     strcpy(this->mumps_data.write_problem, "mumps_matrix.mtx");
   }
 
   // clang-format off
   icntl(1) = (dbg_lvl >= dblWarning) ? 6 : 0;
   icntl(3) = (dbg_lvl >= dblInfo)    ? 6 : 0;
   icntl(2) = (dbg_lvl >= dblTrace)   ? 6 : 0;
 
   icntl(4) =
     dbg_lvl >= dblDump    ? 4 :
     dbg_lvl >= dblTrace   ? 3 :
     dbg_lvl >= dblInfo    ? 2 :
     dbg_lvl >= dblWarning ? 1 :
                             0;
 
   // clang-format on
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::initMumpsData() {
   auto & A = dof_manager.getMatrix(matrix_id);
 
   // Default Scaling
   icntl(8) = 77;
 
   // Assembled matrix
   icntl(5) = 0;
 
   /// Default centralized dense second member
   icntl(20) = 0;
   icntl(21) = 0;
 
   // automatic choice for analysis
   icntl(28) = 0;
 
   UInt size = A.size();
 
   if (prank == 0) {
     this->master_rhs_solution.resize(size);
   }
 
   this->mumps_data.nz_alloc = 0;
   this->mumps_data.n = size;
 
   switch (this->parallel_method) {
   case _fully_distributed:
     icntl(18) = 3; // fully distributed
 
     this->mumps_data.nz_loc = A.getNbNonZero();
     this->mumps_data.irn_loc = A.getIRN().storage();
     this->mumps_data.jcn_loc = A.getJCN().storage();
 
     break;
   case _not_parallel:
   case _master_slave_distributed:
     icntl(18) = 0; // centralized
 
     if (prank == 0) {
       this->mumps_data.nz = A.getNbNonZero();
       this->mumps_data.irn = A.getIRN().storage();
       this->mumps_data.jcn = A.getJCN().storage();
     } else {
       this->mumps_data.nz = 0;
       this->mumps_data.irn = nullptr;
       this->mumps_data.jcn = nullptr;
     }
     break;
   default:
-    AKANTU_DEBUG_ERROR("This case should not happen!!");
+    AKANTU_ERROR("This case should not happen!!");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::initialize() {
   AKANTU_DEBUG_IN();
 
   this->mumps_data.par = 1; // The host is part of computations
 
   switch (this->parallel_method) {
   case _not_parallel:
     break;
   case _master_slave_distributed:
     this->mumps_data.par = 0; // The host is not part of the computations
     /* FALLTHRU */
     /* [[fallthrough]]; un-comment when compiler will get it */
   case _fully_distributed:
 #ifdef AKANTU_USE_MPI
     const auto & mpi_data = dynamic_cast<const MPICommunicatorData &>(
         communicator.getCommunicatorData());
     MPI_Comm mpi_comm = mpi_data.getMPICommunicator();
     this->mumps_data.comm_fortran = MPI_Comm_c2f(mpi_comm);
 #else
-    AKANTU_DEBUG_ERROR(
+    AKANTU_ERROR(
         "You cannot use parallel method to solve without activating MPI");
 #endif
     break;
   }
 
   const auto & A = dof_manager.getMatrix(matrix_id);
 
   this->mumps_data.sym = 2 * (A.getMatrixType() == _symmetric);
   this->prank = communicator.whoAmI();
 
   this->setOutputLevel();
 
   this->mumps_data.job = _smj_initialize; // initialize
   dmumps_c(&this->mumps_data);
 
   this->setOutputLevel();
 
   this->is_initialized = true;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::analysis() {
   AKANTU_DEBUG_IN();
 
   initMumpsData();
 
   this->mumps_data.job = _smj_analyze; // analyze
   dmumps_c(&this->mumps_data);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::factorize() {
   AKANTU_DEBUG_IN();
 
   auto & A = dof_manager.getMatrix(matrix_id);
 
   if (parallel_method == _fully_distributed)
     this->mumps_data.a_loc = A.getA().storage();
   else {
     if (prank == 0)
       this->mumps_data.a = A.getA().storage();
   }
 
   this->mumps_data.job = _smj_factorize; // factorize
   dmumps_c(&this->mumps_data);
 
   this->printError();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::solve(Array<Real> & x, const Array<Real> & b) {
   auto & synch = this->dof_manager.getSynchronizer();
 
   if (this->prank == 0) {
     this->master_rhs_solution.resize(this->dof_manager.getSystemSize());
     synch.gather(b, this->master_rhs_solution);
   } else {
     synch.gather(b);
   }
 
   this->solveInternal();
 
   if (this->prank == 0) {
     synch.scatter(x, this->master_rhs_solution);
   } else {
     synch.scatter(x);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::solve() {
   this->master_rhs_solution.copy(this->dof_manager.getGlobalResidual());
 
   this->solveInternal();
 
   this->dof_manager.setGlobalSolution(this->master_rhs_solution);
 
   this->dof_manager.splitSolutionPerDOFs();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::solveInternal() {
   AKANTU_DEBUG_IN();
 
   this->checkInitialized();
 
   const auto & A = dof_manager.getMatrix(matrix_id);
 
   this->setOutputLevel();
 
   if (this->last_profile_release != A.getProfileRelease()) {
     this->analysis();
     this->last_profile_release = A.getProfileRelease();
   }
 
   if (AKANTU_DEBUG_TEST(dblDump)) {
     std::stringstream sstr;
     sstr << prank << ".mtx";
     A.saveMatrix("solver_mumps" + sstr.str());
   }
 
   if (this->last_value_release != A.getValueRelease()) {
     this->factorize();
     this->last_value_release = A.getValueRelease();
   }
 
   if (prank == 0) {
     this->mumps_data.rhs = this->master_rhs_solution.storage();
   }
 
   this->mumps_data.job = _smj_solve; // solve
   dmumps_c(&this->mumps_data);
 
   this->printError();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::printError() {
   Vector<Int> _info_v(2);
   _info_v[0] = info(1);  // to get errors
   _info_v[1] = -info(1); // to get warnings
   dof_manager.getCommunicator().allReduce(_info_v, SynchronizerOperation::_min);
   _info_v[1] = -_info_v[1];
 
   if (_info_v[0] < 0) { // < 0 is an error
     switch (_info_v[0]) {
     case -10:
       AKANTU_CUSTOM_EXCEPTION(
           debug::SingularMatrixException(dof_manager.getMatrix(matrix_id)));
       break;
     case -9: {
       icntl(14) += 10;
       if (icntl(14) != 90) {
         // std::cout << "Dynamic memory increase of 10%" << std::endl;
         AKANTU_DEBUG_WARNING("MUMPS dynamic memory is insufficient it will be "
                              "increased allowed to use 10% more");
 
         // change releases to force a recompute
         this->last_value_release--;
         this->last_profile_release--;
 
         this->solve();
       } else {
-        AKANTU_DEBUG_ERROR("The MUMPS workarray is too small INFO(2)="
+        AKANTU_ERROR("The MUMPS workarray is too small INFO(2)="
                            << info(2) << "No further increase possible");
       }
       break;
     }
     default:
-      AKANTU_DEBUG_ERROR("Error in mumps during solve process, check mumps "
+      AKANTU_ERROR("Error in mumps during solve process, check mumps "
                          "user guide INFO(1) = "
                          << _info_v[1]);
     }
   } else if (_info_v[1] > 0) {
     AKANTU_DEBUG_WARNING("Warning in mumps during solve process, check mumps "
                          "user guide INFO(1) = "
                          << _info_v[1]);
   }
 }
 
 } // akantu
diff --git a/src/synchronizer/dof_synchronizer.hh b/src/synchronizer/dof_synchronizer.hh
index e5f61649b..386d2cb7f 100644
--- a/src/synchronizer/dof_synchronizer.hh
+++ b/src/synchronizer/dof_synchronizer.hh
@@ -1,115 +1,115 @@
 /**
  * @file   dof_synchronizer.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 17 2011
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Synchronize Array of DOFs
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "aka_array.hh"
 #include "aka_common.hh"
 #include "synchronizer_impl.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 class Mesh;
 class DOFManagerDefault;
 }
 
 #ifndef __AKANTU_DOF_SYNCHRONIZER_HH__
 #define __AKANTU_DOF_SYNCHRONIZER_HH__
 
 namespace akantu {
 
 class DOFSynchronizer : public SynchronizerImpl<UInt> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   DOFSynchronizer(
       DOFManagerDefault & dof_manager, const ID & id = "dof_synchronizer",
       MemoryID memory_id = 0);
   ~DOFSynchronizer() override;
 
   virtual void registerDOFs(const ID & dof_id);
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   template <typename T>
   /// Gather the DOF value on the root proccessor
   void gather(const Array<T> & to_gather, Array<T> & gathered);
 
   /// Gather the DOF value on the root proccessor
   template <typename T> void gather(const Array<T> & to_gather);
 
   /// Scatter a DOF Array form root to all processors
   template <typename T>
   void scatter(Array<T> & scattered, const Array<T> & to_scatter);
 
   /// Scatter a DOF Array form root to all processors
   template <typename T> void scatter(Array<T> & scattered);
 
   template <typename T> void synchronize(Array<T> & vector) const;
 
   template <template <class> class Op, typename T>
   void reduceSynchronize(Array<T> & vector) const;
 
   void onNodesAdded(const Array<UInt> & nodes);
 
 protected:
   /// check if dof changed set on at least one processor
   bool hasChanged();
 
   /// init the scheme for scatter and gather operation, need extra memory
   void initScatterGatherCommunicationScheme();
 
   Int getRank(const UInt & /*node*/) const final {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
 private:
   /// Root processor for scatter/gather operations
   Int root;
 
   /// information on the dofs
   DOFManagerDefault & dof_manager;
 
   /// dofs from root
   Array<UInt> root_dofs;
 
   /// Dofs received from slaves proc (only on master)
   std::map<UInt, Array<UInt>> master_receive_dofs;
 
   bool dof_changed;
 };
 } // akantu
 
 #include "dof_synchronizer_inline_impl.cc"
 
 #endif /* __AKANTU_DOF_SYNCHRONIZER_HH__ */
diff --git a/src/synchronizer/element_info_per_processor_tmpl.hh b/src/synchronizer/element_info_per_processor_tmpl.hh
index d7ba740e0..0ad6bf8f1 100644
--- a/src/synchronizer/element_info_per_processor_tmpl.hh
+++ b/src/synchronizer/element_info_per_processor_tmpl.hh
@@ -1,146 +1,146 @@
 /**
  * @file   element_info_per_processor_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Fri Mar 11 15:03:12 2016
  *
  * @brief
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 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_group.hh"
 #include "element_info_per_processor.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_ELEMENT_INFO_PER_PROCESSOR_TMPL_HH__
 #define __AKANTU_ELEMENT_INFO_PER_PROCESSOR_TMPL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename BufferType>
 void ElementInfoPerProc::fillMeshDataTemplated(BufferType & buffer,
                                                const std::string & tag_name,
                                                UInt nb_component) {
 
   AKANTU_DEBUG_ASSERT(this->mesh.getNbElement(this->type) == nb_local_element,
                       "Did not got enought informations for the tag "
                           << tag_name << " and the element type " << this->type
                           << ":"
                           << "_not_ghost."
                           << " Got " << nb_local_element << " values, expected "
                           << mesh.getNbElement(this->type));
   MeshData & mesh_data = this->getMeshData();
   mesh_data.registerElementalData<T>(tag_name);
   Array<T> & data = mesh_data.getElementalDataArrayAlloc<T>(
       tag_name, this->type, _not_ghost, nb_component);
 
   data.resize(nb_local_element);
   /// unpacking the data, element by element
   for (UInt i(0); i < nb_local_element; ++i) {
     for (UInt j(0); j < nb_component; ++j) {
       buffer >> data(i, j);
     }
   }
 
   AKANTU_DEBUG_ASSERT(mesh.getNbElement(this->type, _ghost) == nb_ghost_element,
                       "Did not got enought informations for the tag "
                           << tag_name << " and the element type " << this->type
                           << ":"
                           << "_ghost."
                           << " Got " << nb_ghost_element << " values, expected "
                           << mesh.getNbElement(this->type, _ghost));
 
   Array<T> & data_ghost = mesh_data.getElementalDataArrayAlloc<T>(
       tag_name, this->type, _ghost, nb_component);
   data_ghost.resize(nb_ghost_element);
 
   /// unpacking the ghost data, element by element
   for (UInt j(0); j < nb_ghost_element; ++j) {
     for (UInt k(0); k < nb_component; ++k) {
       buffer >> data_ghost(j, k);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename BufferType>
 void ElementInfoPerProc::fillMeshData(BufferType & buffer,
                                       const std::string & tag_name,
                                       const MeshDataTypeCode & type_code,
                                       UInt nb_component) {
 #define AKANTU_DISTRIBUTED_SYNHRONIZER_TAG_DATA(r, extra_param, elem)          \
   case BOOST_PP_TUPLE_ELEM(2, 0, elem): {                                      \
     fillMeshDataTemplated<BOOST_PP_TUPLE_ELEM(2, 1, elem)>(buffer, tag_name,   \
                                                            nb_component);      \
     break;                                                                     \
   }
 
   switch (type_code) {
     BOOST_PP_SEQ_FOR_EACH(AKANTU_DISTRIBUTED_SYNHRONIZER_TAG_DATA, ,
                           AKANTU_MESH_DATA_TYPES)
   default:
-    AKANTU_DEBUG_ERROR("Could not determine the type of tag" << tag_name
+    AKANTU_ERROR("Could not determine the type of tag" << tag_name
                                                              << "!");
     break;
   }
 #undef AKANTU_DISTRIBUTED_SYNHRONIZER_TAG_DATA
 }
 
 /* -------------------------------------------------------------------------- */
 template <class CommunicationBuffer>
 void ElementInfoPerProc::fillElementGroupsFromBuffer(
     CommunicationBuffer & buffer) {
   AKANTU_DEBUG_IN();
 
   Element el;
   el.type = type;
 
   for(auto ghost_type : ghost_types) {
     UInt nb_element = mesh.getNbElement(type, ghost_type);
     el.ghost_type = ghost_type;
 
     for (UInt e = 0; e < nb_element; ++e) {
       el.element = e;
 
       std::vector<std::string> element_to_group;
       buffer >> element_to_group;
 
       AKANTU_DEBUG_ASSERT(e < mesh.getNbElement(type, ghost_type),
                           "The mesh does not have the element " << e);
 
       for (auto && element : element_to_group) {
         mesh.getElementGroup(element).add(el, false, false);
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
 
 #endif /* __AKANTU_ELEMENT_INFO_PER_PROCESSOR_TMPL_HH__ */
diff --git a/src/synchronizer/master_element_info_per_processor.cc b/src/synchronizer/master_element_info_per_processor.cc
index 8a4759d6d..f27f9ee51 100644
--- a/src/synchronizer/master_element_info_per_processor.cc
+++ b/src/synchronizer/master_element_info_per_processor.cc
@@ -1,461 +1,461 @@
 /**
  * @file   master_element_info_per_processor.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Fri Mar 11 14:57:13 2016
  *
  * @brief
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 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 "aka_iterators.hh"
 #include "communicator.hh"
 #include "element_group.hh"
 #include "element_info_per_processor.hh"
 #include "element_synchronizer.hh"
 #include "mesh_iterators.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <iostream>
 #include <map>
 #include <tuple>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 MasterElementInfoPerProc::MasterElementInfoPerProc(
     ElementSynchronizer & synchronizer, UInt message_cnt, UInt root,
     ElementType type, const MeshPartition & partition)
     : ElementInfoPerProc(synchronizer, message_cnt, root, type),
       partition(partition), all_nb_local_element(nb_proc, 0),
       all_nb_ghost_element(nb_proc, 0), all_nb_element_to_send(nb_proc, 0) {
   Vector<UInt> size(5);
   size(0) = (UInt)type;
 
   if (type != _not_defined) {
     nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
     nb_element = mesh.getNbElement(type);
     const auto & partition_num =
         this->partition.getPartition(this->type, _not_ghost);
     const auto & ghost_partition =
         this->partition.getGhostPartitionCSR()(this->type, _not_ghost);
 
     for (UInt el = 0; el < nb_element; ++el) {
       this->all_nb_local_element[partition_num(el)]++;
       for (auto part = ghost_partition.begin(el);
            part != ghost_partition.end(el); ++part) {
         this->all_nb_ghost_element[*part]++;
       }
       this->all_nb_element_to_send[partition_num(el)] +=
           ghost_partition.getNbCols(el) + 1;
     }
 
     /// tag info
     std::vector<std::string> tag_names;
     this->getMeshData().getTagNames(tag_names, type);
     this->nb_tags = tag_names.size();
 
     size(4) = nb_tags;
 
     for (UInt p = 0; p < nb_proc; ++p) {
       if (p != root) {
         size(1) = this->all_nb_local_element[p];
         size(2) = this->all_nb_ghost_element[p];
         size(3) = this->all_nb_element_to_send[p];
         AKANTU_DEBUG_INFO(
             "Sending connectivities informations to proc "
             << p << " TAG("
             << Tag::genTag(this->rank, this->message_count, Tag::_SIZES)
             << ")");
         comm.send(size, p,
                   Tag::genTag(this->rank, this->message_count, Tag::_SIZES));
       } else {
         this->nb_local_element = this->all_nb_local_element[p];
         this->nb_ghost_element = this->all_nb_ghost_element[p];
       }
     }
   } else {
     for (UInt p = 0; p < this->nb_proc; ++p) {
       if (p != this->root) {
         AKANTU_DEBUG_INFO(
             "Sending empty connectivities informations to proc "
             << p << " TAG("
             << Tag::genTag(this->rank, this->message_count, Tag::_SIZES)
             << ")");
         comm.send(size, p,
                   Tag::genTag(this->rank, this->message_count, Tag::_SIZES));
       }
     }
   }
 }
 
 /* ------------------------------------------------------------------------ */
 void MasterElementInfoPerProc::synchronizeConnectivities() {
   const auto & partition_num =
       this->partition.getPartition(this->type, _not_ghost);
   const auto & ghost_partition =
       this->partition.getGhostPartitionCSR()(this->type, _not_ghost);
 
   std::vector<Array<UInt>> buffers(this->nb_proc);
 
   const auto & connectivities =
       this->mesh.getConnectivity(this->type, _not_ghost);
 
   /// copying the local connectivity
   for (auto && part_conn :
        zip(partition_num,
            make_view(connectivities, this->nb_nodes_per_element))) {
     auto && part = std::get<0>(part_conn);
     auto && conn = std::get<1>(part_conn);
     for (UInt i = 0; i < conn.size(); ++i) {
       buffers[part].push_back(conn[i]);
     }
   }
 
   /// copying the connectivity of ghost element
   for (auto && tuple :
            enumerate(make_view(connectivities, this->nb_nodes_per_element))) {
     auto && el = std::get<0>(tuple);
     auto && conn = std::get<1>(tuple);
     for (auto part = ghost_partition.begin(el); part != ghost_partition.end(el);
          ++part) {
       UInt proc = *part;
       for (UInt i = 0; i < conn.size(); ++i) {
         buffers[proc].push_back(conn[i]);
       }
     }
   }
 
 #ifndef AKANTU_NDEBUG
   for (auto p : arange(this->nb_proc)) {
     UInt size = this->nb_nodes_per_element *
                 (this->all_nb_local_element[p] + this->all_nb_ghost_element[p]);
     AKANTU_DEBUG_ASSERT(
         buffers[p].size() == size,
         "The connectivity data packed in the buffer are not correct");
   }
 #endif
 
   /// send all connectivity and ghost information to all processors
   std::vector<CommunicationRequest> requests;
   for (auto p : arange(this->nb_proc)) {
     if (p == this->root)
       continue;
     auto && tag =
         Tag::genTag(this->rank, this->message_count, Tag::_CONNECTIVITY);
     AKANTU_DEBUG_INFO("Sending connectivities to proc " << p << " TAG(" << tag
                                                         << ")");
     requests.push_back(comm.asyncSend(buffers[p], p, tag));
   }
 
   Array<UInt> & old_nodes = this->getNodesGlobalIds();
 
   /// create the renumbered connectivity
   AKANTU_DEBUG_INFO("Renumbering local connectivities");
   MeshUtils::renumberMeshNodes(mesh, buffers[root], all_nb_local_element[root],
                                all_nb_ghost_element[root], type, old_nodes);
 
   comm.waitAll(requests);
   comm.freeCommunicationRequest(requests);
 }
 
 /* ------------------------------------------------------------------------ */
 void MasterElementInfoPerProc::synchronizePartitions() {
   const auto & partition_num =
       this->partition.getPartition(this->type, _not_ghost);
   const auto & ghost_partition =
       this->partition.getGhostPartitionCSR()(this->type, _not_ghost);
 
   std::vector<Array<UInt>> buffers(this->partition.getNbPartition());
 
   /// splitting the partition information to send them to processors
   Vector<UInt> count_by_proc(nb_proc, 0);
   for (UInt el = 0; el < nb_element; ++el) {
     UInt proc = partition_num(el);
     buffers[proc].push_back(ghost_partition.getNbCols(el));
 
     UInt i(0);
     for (auto part = ghost_partition.begin(el); part != ghost_partition.end(el);
          ++part, ++i) {
       buffers[proc].push_back(*part);
     }
   }
 
   for (UInt el = 0; el < nb_element; ++el) {
     UInt i(0);
     for (auto part = ghost_partition.begin(el); part != ghost_partition.end(el);
          ++part, ++i) {
       buffers[*part].push_back(partition_num(el));
     }
   }
 
 #ifndef AKANTU_NDEBUG
   for (UInt p = 0; p < this->nb_proc; ++p) {
     AKANTU_DEBUG_ASSERT(buffers[p].size() == (this->all_nb_ghost_element[p] +
                                               this->all_nb_element_to_send[p]),
                         "Data stored in the buffer are most probably wrong");
   }
 #endif
 
   std::vector<CommunicationRequest> requests;
   /// last data to compute the communication scheme
   for (UInt p = 0; p < this->nb_proc; ++p) {
     if (p == this->root)
       continue;
 
     auto && tag =
         Tag::genTag(this->rank, this->message_count, Tag::_PARTITIONS);
     AKANTU_DEBUG_INFO("Sending partition informations to proc " << p << " TAG("
                                                                 << tag << ")");
     requests.push_back(comm.asyncSend(buffers[p], p, tag));
   }
 
   if (Mesh::getSpatialDimension(this->type) ==
       this->mesh.getSpatialDimension()) {
     AKANTU_DEBUG_INFO("Creating communications scheme");
     this->fillCommunicationScheme(buffers[this->rank]);
   }
 
   comm.waitAll(requests);
   comm.freeCommunicationRequest(requests);
 }
 
 /* -------------------------------------------------------------------------- */
 void MasterElementInfoPerProc::synchronizeTags() {
   AKANTU_DEBUG_IN();
 
   if (this->nb_tags == 0) {
     AKANTU_DEBUG_OUT();
     return;
   }
 
   UInt mesh_data_sizes_buffer_length;
   auto & mesh_data = this->getMeshData();
 
   /// tag info
   std::vector<std::string> tag_names;
   mesh_data.getTagNames(tag_names, type);
   // Make sure the tags are sorted (or at least not in random order),
   // because they come from a map !!
   std::sort(tag_names.begin(), tag_names.end());
 
   // Sending information about the tags in mesh_data: name, data type and
   // number of components of the underlying array associated to the current
   // type
   DynamicCommunicationBuffer mesh_data_sizes_buffer;
   for (auto && tag_name : tag_names) {
     mesh_data_sizes_buffer << tag_name;
     mesh_data_sizes_buffer << mesh_data.getTypeCode(tag_name);
     mesh_data_sizes_buffer << mesh_data.getNbComponent(tag_name, type);
   }
 
   mesh_data_sizes_buffer_length = mesh_data_sizes_buffer.size();
   AKANTU_DEBUG_INFO(
       "Broadcasting the size of the information about the mesh data tags: ("
       << mesh_data_sizes_buffer_length << ").");
   comm.broadcast(mesh_data_sizes_buffer_length, root);
   AKANTU_DEBUG_INFO(
       "Broadcasting the information about the mesh data tags, addr "
       << (void *)mesh_data_sizes_buffer.storage());
 
   if (mesh_data_sizes_buffer_length != 0)
     comm.broadcast(mesh_data_sizes_buffer, root);
 
   if (mesh_data_sizes_buffer_length != 0) {
     // Sending the actual data to each processor
     std::vector<DynamicCommunicationBuffer> buffers(nb_proc);
     // Loop over each tag for the current type
     for (auto && tag_name : tag_names) {
       // Type code of the current tag (i.e. the tag named *names_it)
       this->fillTagBuffer(buffers, tag_name);
     }
 
     std::vector<CommunicationRequest> requests;
     for (UInt p = 0; p < nb_proc; ++p) {
       if (p == root)
         continue;
 
       auto && tag =
           Tag::genTag(this->rank, this->message_count, Tag::_MESH_DATA);
       AKANTU_DEBUG_INFO("Sending " << buffers[p].size()
                                    << " bytes of mesh data to proc " << p
                                    << " TAG(" << tag << ")");
 
       requests.push_back(comm.asyncSend(buffers[p], p, tag));
     }
 
     // Loop over each tag for the current type
     for (auto && tag_name : tag_names) {
       // Reinitializing the mesh data on the master
       this->fillMeshData(buffers[root], tag_name,
                          mesh_data.getTypeCode(tag_name),
                          mesh_data.getNbComponent(tag_name, type));
     }
 
     comm.waitAll(requests);
     comm.freeCommunicationRequest(requests);
     requests.clear();
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void MasterElementInfoPerProc::fillTagBufferTemplated(
     std::vector<DynamicCommunicationBuffer> & buffers,
     const std::string & tag_name) {
   MeshData & mesh_data = this->getMeshData();
 
   const auto & data = mesh_data.getElementalDataArray<T>(tag_name, type);
   const auto & partition_num =
       this->partition.getPartition(this->type, _not_ghost);
   const auto & ghost_partition =
       this->partition.getGhostPartitionCSR()(this->type, _not_ghost);
 
   // Not possible to use the iterator because it potentially triggers the
   // creation of complex
   // type templates (such as akantu::Vector< std::vector<Element> > which don't
   // implement the right interface
   // (e.g. operator<< in that case).
   // typename Array<T>::template const_iterator< Vector<T> > data_it  =
   // data.begin(data.getNbComponent());
   // typename Array<T>::template const_iterator< Vector<T> > data_end =
   // data.end(data.getNbComponent());
 
   const T * data_it = data.storage();
   const T * data_end = data.storage() + data.size() * data.getNbComponent();
   const UInt * part = partition_num.storage();
 
   /// copying the data, element by element
   for (; data_it != data_end; ++part) {
     for (UInt j(0); j < data.getNbComponent(); ++j, ++data_it) {
       buffers[*part] << *data_it;
     }
   }
 
   data_it = data.storage();
   /// copying the data for the ghost element
   for (UInt el(0); data_it != data_end;
        data_it += data.getNbComponent(), ++el) {
     auto it = ghost_partition.begin(el);
     auto end = ghost_partition.end(el);
     for (; it != end; ++it) {
       UInt proc = *it;
       for (UInt j(0); j < data.getNbComponent(); ++j) {
         buffers[proc] << data_it[j];
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void MasterElementInfoPerProc::fillTagBuffer(
     std::vector<DynamicCommunicationBuffer> & buffers,
     const std::string & tag_name) {
   MeshData & mesh_data = this->getMeshData();
 
 #define AKANTU_DISTRIBUTED_SYNHRONIZER_TAG_DATA(r, extra_param, elem)          \
   case BOOST_PP_TUPLE_ELEM(2, 0, elem): {                                      \
     this->fillTagBufferTemplated<BOOST_PP_TUPLE_ELEM(2, 1, elem)>(buffers,     \
                                                                   tag_name);   \
     break;                                                                     \
   }
 
   MeshDataTypeCode data_type_code = mesh_data.getTypeCode(tag_name);
   switch (data_type_code) {
     BOOST_PP_SEQ_FOR_EACH(AKANTU_DISTRIBUTED_SYNHRONIZER_TAG_DATA, ,
                           AKANTU_MESH_DATA_TYPES)
   default:
-    AKANTU_DEBUG_ERROR("Could not obtain the type of tag" << tag_name << "!");
+    AKANTU_ERROR("Could not obtain the type of tag" << tag_name << "!");
     break;
   }
 #undef AKANTU_DISTRIBUTED_SYNHRONIZER_TAG_DATA
 }
 
 /* -------------------------------------------------------------------------- */
 void MasterElementInfoPerProc::synchronizeGroups() {
   AKANTU_DEBUG_IN();
 
   std::vector<DynamicCommunicationBuffer> buffers(nb_proc);
 
   using ElementToGroup = std::vector<std::vector<std::string>>;
   ElementToGroup element_to_group(nb_element);
 
   for (auto & eg : ElementGroupsIterable(mesh)) {
     const auto & name = eg.getName();
 
     for (const auto & element : eg.getElements(type, _not_ghost)) {
       element_to_group[element].push_back(name);
     }
 
     auto eit = eg.begin(type, _not_ghost);
     if (eit != eg.end(type, _not_ghost))
       const_cast<Array<UInt> &>(eg.getElements(type)).empty();
   }
 
   const auto & partition_num =
       this->partition.getPartition(this->type, _not_ghost);
   const auto & ghost_partition =
       this->partition.getGhostPartitionCSR()(this->type, _not_ghost);
 
   /// copying the data, element by element
   for (auto && pair : zip(partition_num, element_to_group)) {
     buffers[std::get<0>(pair)] << std::get<1>(pair);
   }
 
   /// copying the data for the ghost element
   for (auto && pair : enumerate(element_to_group)) {
     auto && el = std::get<0>(pair);
     auto it = ghost_partition.begin(el);
     auto end = ghost_partition.end(el);
     for (; it != end; ++it) {
       UInt proc = *it;
       buffers[proc] << std::get<1>(pair);
     }
   }
 
   std::vector<CommunicationRequest> requests;
   for (UInt p = 0; p < this->nb_proc; ++p) {
     if (p == this->rank)
       continue;
 
     auto && tag = Tag::genTag(this->rank, p, Tag::_ELEMENT_GROUP);
     AKANTU_DEBUG_INFO("Sending element groups to proc " << p << " TAG(" << tag
                                                         << ")");
     requests.push_back(comm.asyncSend(buffers[p], p, tag));
   }
 
   this->fillElementGroupsFromBuffer(buffers[this->rank]);
 
   comm.waitAll(requests);
   comm.freeCommunicationRequest(requests);
   requests.clear();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/synchronizer/node_synchronizer.hh b/src/synchronizer/node_synchronizer.hh
index 8bfd76044..08b8b48d0 100644
--- a/src/synchronizer/node_synchronizer.hh
+++ b/src/synchronizer/node_synchronizer.hh
@@ -1,88 +1,88 @@
 /**
  * @file   node_synchronizer.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Fri Sep 23 11:45:24 2016
  *
  * @brief  Synchronizer for nodal information
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 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 "mesh_events.hh"
 #include "synchronizer_impl.hh"
 /* -------------------------------------------------------------------------- */
 #include <unordered_map>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_NODE_SYNCHRONIZER_HH__
 #define __AKANTU_NODE_SYNCHRONIZER_HH__
 
 namespace akantu {
 
 class NodeSynchronizer : public MeshEventHandler,
                          public SynchronizerImpl<UInt> {
 public:
   NodeSynchronizer(Mesh & mesh, const ID & id = "element_synchronizer",
                    MemoryID memory_id = 0,
                    const bool register_to_event_manager = true,
                    EventHandlerPriority event_priority = _ehp_synchronizer);
 
   ~NodeSynchronizer() override;
 
   friend class NodeInfoPerProc;
 
   /// function to implement to react on  akantu::NewNodesEvent
   void onNodesAdded(const Array<UInt> &, const NewNodesEvent &) override;
 
   /// function to implement to react on  akantu::RemovedNodesEvent
   void onNodesRemoved(const Array<UInt> &, const Array<UInt> &,
                       const RemovedNodesEvent &) override {}
   /// function to implement to react on  akantu::NewElementsEvent
   void onElementsAdded(const Array<Element> &,
                        const NewElementsEvent &) override {}
   /// function to implement to react on  akantu::RemovedElementsEvent
   void onElementsRemoved(const Array<Element> &,
                          const ElementTypeMapArray<UInt> &,
                          const RemovedElementsEvent &) override {}
   /// function to implement to react on  akantu::ChangedElementsEvent
   void onElementsChanged(const Array<Element> &, const Array<Element> &,
                          const ElementTypeMapArray<UInt> &,
                          const ChangedElementsEvent &) override {}
 
 public:
   AKANTU_GET_MACRO(Mesh, mesh, Mesh &);
 
 protected:
   Int getRank(const UInt & /*node*/) const final {
-    AKANTU_DEBUG_TO_IMPLEMENT();
+    AKANTU_TO_IMPLEMENT();
   }
 
 protected:
   Mesh & mesh;
 
   //std::unordered_map<UInt, Int> node_to_prank;
 };
 
 } // namespace akantu
 
 #endif /* __AKANTU_NODE_SYNCHRONIZER_HH__ */
diff --git a/test/test_mesh_utils/test_purify_mesh.cc b/test/test_mesh_utils/test_purify_mesh.cc
index a9c19be5a..cbd019919 100644
--- a/test/test_mesh_utils/test_purify_mesh.cc
+++ b/test/test_mesh_utils/test_purify_mesh.cc
@@ -1,62 +1,62 @@
 /**
  * @file   test_purify_mesh.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Jul 15 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Test the purifyMesh function from MeshUtils
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "mesh.hh"
 #include "mesh_utils.hh"
 #include "mesh_io.hh"
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   akantu::initialize(argc, argv);
   
   Mesh mesh(2);
 
   mesh.read("purify_mesh.msh");
   
   MeshUtils::purifyMesh(mesh);
 
   mesh.write("purify_mesh_after.msh");
 
   if(mesh.getNbNodes() != 21)
-    AKANTU_DEBUG_ERROR("The purified mesh does not contain the good number of nodes.");
+    AKANTU_ERROR("The purified mesh does not contain the good number of nodes.");
 
   if(mesh.getNbElement(_quadrangle_8) != 4)
-    AKANTU_DEBUG_ERROR("The purified mesh does not contain the good number of element.");
+    AKANTU_ERROR("The purified mesh does not contain the good number of element.");
 
   
   akantu::finalize();
   
   return EXIT_SUCCESS;
 }
 
diff --git a/test/test_mesh_utils/test_segment_nodetype/test_segment_nodetype.cc b/test/test_mesh_utils/test_segment_nodetype/test_segment_nodetype.cc
index 8c696153e..b9f1dea71 100644
--- a/test/test_mesh_utils/test_segment_nodetype/test_segment_nodetype.cc
+++ b/test/test_mesh_utils/test_segment_nodetype/test_segment_nodetype.cc
@@ -1,97 +1,97 @@
 /**
  * @file   test_segment_nodetype.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Sep 18 2015
  *
  * @brief  Test to verify that the node type is correctly associated to
  * the segments in parallel
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 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_synchronizer.hh"
 #include "mesh_utils.hh"
 
 /* -------------------------------------------------------------------------- */
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
   initialize(argc, argv);
 
   UInt spatial_dimension = 3;
   Mesh mesh(spatial_dimension);
 
   const auto & comm = Communicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   // partition the mesh
   if (prank == 0) {
     mesh.read("mesh.msh");
   }
 
   mesh.distribute();
 
   // compute the node types for each segment
   Mesh & mesh_facets = mesh.initMeshFacets();
   MeshUtils::buildSegmentToNodeType(mesh, mesh_facets);
 
   // verify that the number of segments per node type makes sense
   std::map<Int, UInt> nb_facets_per_nodetype;
   UInt nb_segments = 0;
 
   for (auto ghost_type : ghost_types) {
     const Array<Int> & segment_to_nodetype =
         mesh_facets.getData<Int>("segment_to_nodetype", _segment_2, ghost_type);
 
     // count the number of segments per node type
     for (auto & stn : segment_to_nodetype) {
       if (nb_facets_per_nodetype.find(stn) == nb_facets_per_nodetype.end())
         nb_facets_per_nodetype[stn] = 1;
       else
         ++nb_facets_per_nodetype[stn];
     }
     nb_segments += segment_to_nodetype.size();
   }
 
   // checking the solution
   if (nb_segments != 24)
-    AKANTU_DEBUG_ERROR("The number of segments is wrong");
+    AKANTU_ERROR("The number of segments is wrong");
 
   if (prank == 0) {
     if (nb_facets_per_nodetype[-1] != 3 || nb_facets_per_nodetype[-2] != 9 ||
         nb_facets_per_nodetype[-3] != 12)
-      AKANTU_DEBUG_ERROR(
+      AKANTU_ERROR(
           "The segments of processor 0 have the wrong node type");
 
     if (nb_facets_per_nodetype.size() > 3)
-      AKANTU_DEBUG_ERROR("Processor 0 cannot have any slave segment");
+      AKANTU_ERROR("Processor 0 cannot have any slave segment");
   }
 
   if (prank == psize - 1 &&
       nb_facets_per_nodetype.find(-2) != nb_facets_per_nodetype.end())
-    AKANTU_DEBUG_ERROR("The last processor must not have any master facets");
+    AKANTU_ERROR("The last processor must not have any master facets");
 
   finalize();
   return 0;
 }
diff --git a/test/test_model/test_model_solver/test_model_solver_dynamic.cc b/test/test_model/test_model_solver/test_model_solver_dynamic.cc
index 7956e1e98..fea1fc63a 100644
--- a/test/test_model/test_model_solver/test_model_solver_dynamic.cc
+++ b/test/test_model/test_model_solver/test_model_solver_dynamic.cc
@@ -1,171 +1,171 @@
 /**
  * @file   test_dof_manager_default.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Feb 24 12:28:44 2016
  *
  * @brief  Test default dof manager
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 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 "data_accessor.hh"
 #include "dof_manager.hh"
 #include "dof_manager_default.hh"
 #include "element_synchronizer.hh"
 #include "mesh.hh"
 #include "mesh_accessor.hh"
 #include "model_solver.hh"
 #include "non_linear_solver.hh"
 #include "sparse_matrix.hh"
 #include "communicator.hh"
 #include "synchronizer_registry.hh"
 /* -------------------------------------------------------------------------- */
 #include "test_model_solver_my_model.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 #ifndef EXPLICIT
 #define EXPLICIT true
 #endif
 
 using namespace akantu;
 
 static void genMesh(Mesh & mesh, UInt nb_nodes);
 
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   initialize(argc, argv);
 
   UInt prank = Communicator::getStaticCommunicator().whoAmI();
   UInt global_nb_nodes = 201;
   UInt max_steps = 200;
   Real time_step = 0.001;
   Mesh mesh(1);
   Real F = -9.81;
   bool _explicit = EXPLICIT;
 
   if (prank == 0)
     genMesh(mesh, global_nb_nodes);
 
   mesh.distribute();
 
   MyModel model(F, mesh, _explicit);
 
   if (!_explicit) {
     model.getNewSolver("dynamic", _tsst_dynamic, _nls_newton_raphson);
     model.setIntegrationScheme("dynamic", "disp", _ist_trapezoidal_rule_2,
                                IntegrationScheme::_displacement);
   } else {
     model.getNewSolver("dynamic", _tsst_dynamic_lumped, _nls_lumped);
     model.setIntegrationScheme("dynamic", "disp", _ist_central_difference,
                                IntegrationScheme::_acceleration);
   }
 
   model.setTimeStep(time_step);
 
   // #if EXPLICIT == true
   //   std::ofstream output("output_dynamic_explicit.csv");
   // #else
   //   std::ofstream output("output_dynamic_implicit.csv");
   // #endif
 
   if (prank == 0) {
     std::cout << std::scientific;
     std::cout << std::setw(14) << "time"
               << "," << std::setw(14) << "wext"
               << "," << std::setw(14) << "epot"
               << "," << std::setw(14) << "ekin"
               << "," << std::setw(14) << "total" << std::endl;
   }
   Real wext = 0.;
 
   model.getDOFManager().clearResidual();
   model.assembleResidual();
 
   Real epot = 0;//model.getPotentialEnergy();
   Real ekin = 0;//model.getKineticEnergy();
   Real einit = ekin + epot;
   Real etot = ekin + epot - wext - einit;
   if (prank == 0) {
     std::cout << std::setw(14) << 0. << "," << std::setw(14) << wext << ","
               << std::setw(14) << epot << "," << std::setw(14) << ekin << ","
               << std::setw(14) << etot << std::endl;
   }
 
 #if EXPLICIT == false
   NonLinearSolver & solver =
       model.getDOFManager().getNonLinearSolver("dynamic");
 
   solver.set("max_iterations", 20);
 #endif
 
   for (UInt i = 1; i < max_steps + 1; ++i) {
     model.solveStep("dynamic");
 
 #if EXPLICIT == false
     //int nb_iter = solver.get("nb_iterations");
     //Real error = solver.get("error");
     //bool converged = solver.get("converged");
     //if (prank == 0)
     // std::cerr << error << " " << nb_iter << " -> " << converged << std::endl;
 #endif
 
     epot = model.getPotentialEnergy();
     ekin = model.getKineticEnergy();
     wext += model.getExternalWorkIncrement();
     etot = ekin + epot - wext - einit;
     if (prank == 0) {
       std::cout << std::setw(14) << time_step * i << "," << std::setw(14)
                 << wext << "," << std::setw(14) << epot << "," << std::setw(14)
                 << ekin << "," << std::setw(14) << etot << std::endl;
     }
 
     if (std::abs(etot) > 1e-1) {
-      AKANTU_DEBUG_ERROR("The total energy of the system is not conserved!");
+      AKANTU_ERROR("The total energy of the system is not conserved!");
     }
   }
 
   // output.close();
   finalize();
   return EXIT_SUCCESS;
 }
 
 /* -------------------------------------------------------------------------- */
 void genMesh(Mesh & mesh, UInt nb_nodes) {
   MeshAccessor mesh_accessor(mesh);
   Array<Real> & nodes = mesh_accessor.getNodes();
   Array<UInt> & conn = mesh_accessor.getConnectivity(_segment_2);
 
   nodes.resize(nb_nodes);
 
   for (UInt n = 0; n < nb_nodes; ++n) {
     nodes(n, _x) = n * (1. / (nb_nodes - 1));
   }
 
   conn.resize(nb_nodes - 1);
   for (UInt n = 0; n < nb_nodes - 1; ++n) {
     conn(n, 0) = n;
     conn(n, 1) = n + 1;
   }
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_extrinsic/test_cohesive_extrinsic_fatigue.cc b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_extrinsic/test_cohesive_extrinsic_fatigue.cc
index 5c10862bc..f486f398c 100644
--- a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_extrinsic/test_cohesive_extrinsic_fatigue.cc
+++ b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_extrinsic/test_cohesive_extrinsic_fatigue.cc
@@ -1,243 +1,243 @@
 /**
  * @file   test_cohesive_extrinsic_fatigue.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Feb 20 2015
  * @date last modification: Thu Jun 25 2015
  *
  * @brief  Test for the linear fatigue cohesive law
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 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 "material_cohesive_linear_fatigue.hh"
 #include "solid_mechanics_model_cohesive.hh"
 #include <limits>
 
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 // the following class contains an implementation of the 1D linear
 // fatigue cohesive law
 class MaterialFatigue {
 public:
   MaterialFatigue(Real delta_f, Real sigma_c, Real delta_c)
       : delta_f(delta_f), sigma_c(sigma_c), delta_c(delta_c), delta_prec(0),
         traction(sigma_c), delta_max(0),
         stiff_plus(std::numeric_limits<Real>::max()),
         tolerance(Math::getTolerance()){};
 
   Real computeTraction(Real delta) {
     if (delta - delta_c > -tolerance)
       traction = 0;
     else if (delta_max < tolerance && delta < tolerance)
       traction = sigma_c;
     else {
       Real delta_dot = delta - delta_prec;
 
       if (delta_dot > -tolerance) {
         stiff_plus *= 1 - delta_dot / delta_f;
         traction += stiff_plus * delta_dot;
         Real max_traction = sigma_c * (1 - delta / delta_c);
 
         if (traction - max_traction > -tolerance || delta_max < tolerance) {
           traction = max_traction;
           stiff_plus = traction / delta;
         }
       } else {
         Real stiff_minus = traction / delta_prec;
         stiff_plus += (stiff_plus - stiff_minus) * delta_dot / delta_f;
         traction += stiff_minus * delta_dot;
       }
     }
 
     delta_prec = delta;
     delta_max = std::max(delta, delta_max);
     return traction;
   }
 
 private:
   const Real delta_f;
   const Real sigma_c;
   const Real delta_c;
   Real delta_prec;
   Real traction;
   Real delta_max;
   Real stiff_plus;
   const Real tolerance;
 };
 
 void imposeOpening(SolidMechanicsModelCohesive &, Real);
 void arange(Array<Real> &, Real, Real, Real);
 
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   initialize("material_fatigue.dat", argc, argv);
 
   Math::setTolerance(1e-13);
 
   const UInt spatial_dimension = 2;
   const ElementType type = _quadrangle_4;
 
   Mesh mesh(spatial_dimension);
   mesh.read("fatigue.msh");
 
   // init stuff
   const ElementType type_facet = Mesh::getFacetType(type);
   const ElementType type_cohesive =
       FEEngine::getCohesiveElementType(type_facet);
 
   SolidMechanicsModelCohesive model(mesh);
   model.initFull(
       SolidMechanicsModelCohesiveOptions(_explicit_lumped_mass, true));
 
   MaterialCohesiveLinearFatigue<2> & numerical_material =
       dynamic_cast<MaterialCohesiveLinearFatigue<2> &>(
           model.getMaterial("cohesive"));
 
   Real delta_f = numerical_material.getParam("delta_f");
   Real delta_c = numerical_material.getParam("delta_c");
   Real sigma_c = 1;
 
   const Array<Real> & traction_array =
       numerical_material.getTraction(type_cohesive);
 
   MaterialFatigue theoretical_material(delta_f, sigma_c, delta_c);
 
   // model.setBaseName("fatigue");
   // model.addDumpFieldVector("displacement");
   // model.addDumpField("stress");
   // model.dump();
 
   // stretch material
   Real strain = 1;
   Array<Real> & displacement = model.getDisplacement();
   const Array<Real> & position = mesh.getNodes();
 
   for (UInt n = 0; n < mesh.getNbNodes(); ++n)
     displacement(n, 0) = position(n, 0) * strain;
 
   model.assembleInternalForces();
   // model.dump();
 
   // insert cohesive elements
   model.checkCohesiveStress();
 
   // create the displacement sequence
   Real increment = 0.01;
 
   Array<Real> openings;
 
   arange(openings, 0, 0.5, increment);
   arange(openings, 0.5, 0.1, increment);
   arange(openings, 0.1, 0.7, increment);
   arange(openings, 0.7, 0.3, increment);
   arange(openings, 0.3, 0.6, increment);
   arange(openings, 0.6, 0.3, increment);
   arange(openings, 0.3, 0.7, increment);
   arange(openings, 0.7, 1.3, increment);
 
   const Array<UInt> & switches = numerical_material.getSwitches(type_cohesive);
 
   // std::ofstream edis("fatigue_edis.txt");
 
   // impose openings
   for (UInt i = 0; i < openings.size(); ++i) {
 
     // compute numerical traction
     imposeOpening(model, openings(i));
     model.assembleInternalForces();
     // model.dump();
     Real numerical_traction = traction_array(0, 0);
 
     // compute theoretical traction
     Real theoretical_traction =
         theoretical_material.computeTraction(openings(i));
 
     // test traction
     if (std::abs(numerical_traction - theoretical_traction) > 1e-13)
-      AKANTU_DEBUG_ERROR("The numerical traction "
+      AKANTU_ERROR("The numerical traction "
                          << numerical_traction << " and theoretical traction "
                          << theoretical_traction << " are not coincident");
 
     // edis << model.getEnergy("dissipated") << std::endl;
   }
 
   if (switches(0) != 7)
-    AKANTU_DEBUG_ERROR("The number of switches is wrong");
+    AKANTU_ERROR("The number of switches is wrong");
 
   std::cout << "OK: the test_cohesive_extrinsic_fatigue passed." << std::endl;
   return 0;
 }
 
 /* -------------------------------------------------------------------------- */
 
 void imposeOpening(SolidMechanicsModelCohesive & model, Real opening) {
 
   UInt spatial_dimension = model.getSpatialDimension();
   Mesh & mesh = model.getFEEngine().getMesh();
   Array<Real> & position = mesh.getNodes();
   Array<Real> & displacement = model.getDisplacement();
   UInt nb_nodes = mesh.getNbNodes();
 
   Array<bool> update(nb_nodes);
   update.clear();
 
   Mesh::type_iterator it = mesh.firstType(spatial_dimension);
   Mesh::type_iterator end = mesh.lastType(spatial_dimension);
 
   for (; it != end; ++it) {
     ElementType type = *it;
     UInt nb_element = mesh.getNbElement(type);
     UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
 
     const Array<UInt> & connectivity = mesh.getConnectivity(type);
     Vector<Real> barycenter(spatial_dimension);
 
     for (UInt el = 0; el < nb_element; ++el) {
       mesh.getBarycenter({type, el, _not_ghost}, barycenter);
       if (barycenter(0) > 1) {
         for (UInt n = 0; n < nb_nodes_per_element; ++n) {
           UInt node = connectivity(el, n);
           if (!update(node)) {
             displacement(node, 0) = opening + position(node, 0);
             update(node) = true;
           }
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void arange(Array<Real> & openings, Real begin, Real end, Real increment) {
   if (begin < end) {
     for (Real opening = begin; opening < end - increment / 2.;
          opening += increment)
       openings.push_back(opening);
   } else {
     for (Real opening = begin; opening > end + increment / 2.;
          opening -= increment)
       openings.push_back(opening);
   }
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_extrinsic_implicit/test_assembling_K_cohe_elements.cc b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_extrinsic_implicit/test_assembling_K_cohe_elements.cc
index fa8a9a62c..56cb5a423 100644
--- a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_extrinsic_implicit/test_assembling_K_cohe_elements.cc
+++ b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_extrinsic_implicit/test_assembling_K_cohe_elements.cc
@@ -1,171 +1,171 @@
 /**
  * @file   test_assembling_K_cohe_elements.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  *
  * @date creation: Fri May 15 2015
  * @date last modification: Thu Aug 20 2015
  *
  * @brief  Test to check the correct matrix assembling for cohesive elements
  * with degenerated nodes
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 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 "dof_manager.hh"
 #include "non_linear_solver.hh"
 #include "solid_mechanics_model_cohesive.hh"
 #include "sparse_matrix.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 #include <iostream>
 #include <limits>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
   initialize("material.dat", argc, argv);
 
   debug::setDebugLevel(dblWarning);
 
   const UInt spatial_dimension = 2;
   Real increment = 0.004;
   bool passed = true;
   Real tol = 1.0e-13;
 
   Mesh mesh(spatial_dimension);
   mesh.read("quadrangle.msh");
 
   SolidMechanicsModelCohesive model(mesh);
 
   /// model initialization
   model.initFull(SolidMechanicsModelCohesiveOptions(_static, true));
 
   ///  CohesiveElementInserter
   model.getElementInserter().setLimit(_y, -0.001, 0.001);
   model.updateAutomaticInsertion();
 
   Array<bool> & boundary = model.getBlockedDOFs();
   Array<Real> & position = mesh.getNodes();
   Array<Real> & displacement = model.getDisplacement();
   // SparseMatrix & K_test = model.getStiffnessMatrix();
   Array<Real> K_verified(0, 3, "K_matrix_verified");
   Array<Real> K_test(0, 3, "K_matrix_test");
 
   /// load the verified stiffness matrix
   Vector<Real> tmp(3);
   UInt nb_lines;
 
   std::ifstream infile("K_matrix_verified.dat");
   std::string line;
   if (!infile.good())
-    AKANTU_DEBUG_ERROR("Cannot open file K_matrix_verified.dat");
+    AKANTU_ERROR("Cannot open file K_matrix_verified.dat");
   else {
     for (UInt i = 0; i < 2; ++i) {
       getline(infile, line);
       std::stringstream sstr_data(line);
       if (i == 1) {
         sstr_data >> tmp(0) >> tmp(1) >> tmp(2);
         nb_lines = tmp(2);
       }
     }
 
     for (UInt i = 0; i < nb_lines; ++i) {
       getline(infile, line);
       std::stringstream sstr_data(line);
       sstr_data >> tmp(0) >> tmp(1) >> tmp(2);
       K_verified.push_back(tmp);
     }
   }
   infile.close();
 
   /// impose boundary conditions
   for (UInt n = 0; n < mesh.getNbNodes(); ++n) {
     if (position(n, 1) < -0.99) {
       boundary(n, 1) = true;
       boundary(n, 0) = true;
     }
     if (position(n, 1) > 0.99 && position(n, 0) < -0.99)
       boundary(n, 1) = true;
   }
 
   /// solve step
   for (UInt n = 0; n < mesh.getNbNodes(); ++n) {
     if (position(n, 1) > 0.99 && position(n, 0) < -0.99)
       displacement(n, 1) += increment;
   }
 
   auto & solver = model.getNonLinearSolver();
   solver.set("max_iterations", 10);
   solver.set("threshold", 1e-13);
 
   model.solveStep();
 
   model.getDOFManager().getMatrix("K").saveMatrix("K_matrix_test.dat");
 
   /// load the stiffness matrix to be tested
   std::ifstream infile2("K_matrix_test.dat");
   if (!infile2.good())
-    AKANTU_DEBUG_ERROR("Cannot open file K_matrix_test.dat");
+    AKANTU_ERROR("Cannot open file K_matrix_test.dat");
   else {
     for (UInt i = 0; i < 2; ++i) {
       getline(infile2, line);
       std::stringstream sstr_data(line);
       if (i == 1) {
         sstr_data >> tmp(0) >> tmp(1) >> tmp(2);
         nb_lines = tmp(2);
       }
     }
 
     for (UInt i = 0; i < nb_lines; ++i) {
       getline(infile2, line);
       std::stringstream sstr_data(line);
       sstr_data >> tmp(0) >> tmp(1) >> tmp(2);
       K_test.push_back(tmp);
     }
   }
   infile2.close();
 
   for (UInt i = 0; i < K_verified.size(); ++i) {
     for (UInt j = 0; j < K_test.size(); ++j) {
       if ((K_test(j, 0) == K_verified(i, 0)) &&
           (K_test(j, 1) == K_verified(i, 1))) {
         if (std::abs(K_verified(i, 2)) < tol) {
           if (std::abs(K_test(j, 2)) > tol)
             passed = false;
         } else {
           Real ratio = (std::abs(K_test(j, 2) - K_verified(i, 2))) /
                        (std::abs(K_verified(i, 2)));
           if (ratio > tol)
             passed = false;
         }
       }
     }
   }
 
   finalize();
 
   if (passed)
     return EXIT_SUCCESS;
   else
     return EXIT_FAILURE;
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_linear_friction/test_cohesive_friction.cc b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_linear_friction/test_cohesive_friction.cc
index 62265f600..2888a6511 100644
--- a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_linear_friction/test_cohesive_friction.cc
+++ b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_linear_friction/test_cohesive_friction.cc
@@ -1,237 +1,237 @@
 /**
  * @file   test_cohesive_friction.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  *
  * @date   Wed Jan 13 11:56:18 2016
  *
  * @brief testing the correct behavior of the friction law included in
  * the cohesive linear law, in implicit
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 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 "solid_mechanics_model_cohesive.hh"
 /* -------------------------------------------------------------------------- */
 #include <cmath>
 #include <iostream>
 #include <fstream>
 #include <time.h>
 #include <string>
 #include <iomanip>
 
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
 
   initialize("material.dat", argc, argv);
 
   Math::setTolerance(1.e-15);
   UInt spatial_dimension = 2;
   const ElementType type = _cohesive_2d_4;
 
   Mesh mesh(spatial_dimension);
 
   mesh.read("mesh_cohesive_friction.msh");
   
   // Create the model
   SolidMechanicsModelCohesive model(mesh);
 
   // Model initialization
   model.initFull(SolidMechanicsModelCohesiveOptions(_static, true));
 
   //  CohesiveElementInserter inserter(mesh);
   model.limitInsertion(_y, -0.001, 0.001);
   model.updateAutomaticInsertion();
 
   Real eps = 1e-10;
   Array<Real> & pos = mesh.getNodes();
   Array<Real> & disp = model.getDisplacement();
   Array<bool> & boun = model.getBlockedDOFs();
   const Array<Real> & residual = model.getInternalForce();
   Array<Real> & cohe_opening = const_cast<Array<Real> &>(model.getMaterial("interface").getInternal<Real>("opening")(type));
   Array<Real> & friction_force = const_cast<Array<Real> &>(model.getMaterial("interface").getInternal<Real>("friction_force")(type));
 
   // Boundary conditions
   for (UInt i = 0; i < mesh.getNbNodes(); ++i) {
     if(pos(i,1) < -0.49 || pos(i,1) > 0.49){
       boun(i,0) = true;
       boun(i,1) = true;
     }
   }
 
   bool passed = true;
   Real tolerance = 1e-13;
   Real error;
   bool load_reduction = false;
   Real tol_increase_factor = 1e5;
   Real increment = 1.0e-4;
 
   model.synchronizeBoundaries();
   model.updateResidual();
 
   /* -------------------------------------------- */
   /* LOADING PHASE to introduce cohesive elements */
   /* -------------------------------------------- */
 
   for (UInt nstep = 0; nstep < 100; ++nstep){
 
     for (UInt n = 0; n < mesh.getNbNodes(); ++n) {
       if (pos(n,1) > 0.49)
 	disp(n,1) += increment;
     }
 
     model.solveStepCohesive<_scm_newton_raphson_tangent, _scc_increment>(tolerance, error, 25, load_reduction, tol_increase_factor);
 
     if (error > tolerance){
-      AKANTU_DEBUG_ERROR("Convergence not reached in the mode I loading phase");
+      AKANTU_ERROR("Convergence not reached in the mode I loading phase");
       passed = false;
     }
 
   }
 
   /* --------------------------------------------------------- */
   /* UNLOADING PHASE to bring cohesive elements in compression */
   /* --------------------------------------------------------- */
 
   for (UInt nstep = 0; nstep < 110; ++nstep){
 
     for (UInt n = 0; n < mesh.getNbNodes(); ++n) {
       if (pos(n,1) > 0.49)
 	disp(n,1) -= increment;
     }
 
     model.solveStepCohesive<_scm_newton_raphson_tangent, _scc_increment>(tolerance, error, 25, load_reduction, tol_increase_factor);
 
     if (error > tolerance){
-      AKANTU_DEBUG_ERROR("Convergence not reached in the mode I unloading phase");
+      AKANTU_ERROR("Convergence not reached in the mode I unloading phase");
       passed = false;
     }
 
   }
 
 
   /* -------------------------------------------------- */
   /* SHEAR PHASE - displacement towards right           */
   /* -------------------------------------------------- */
 
   increment *= 2;
 
   for (UInt nstep = 0; nstep < 30; ++nstep){
 
     for (UInt n = 0; n < mesh.getNbNodes(); ++n) {
       if (pos(n,1) > 0.49)
 	disp(n,0) += increment;
     }
 
     model.solveStepCohesive<_scm_newton_raphson_tangent, _scc_increment>(tolerance, error, 25, load_reduction, tol_increase_factor);
 
     if (error > tolerance){
-      AKANTU_DEBUG_ERROR("Convergence not reached in the shear loading phase");
+      AKANTU_ERROR("Convergence not reached in the shear loading phase");
       passed = false;
     }
 
   }
 
   /* ---------------------------------------------------*/
   /* Check the horizontal component of the reaction     */
   /* ---------------------------------------------------*/
 
   // Friction + mode II cohesive behavior
   Real reac_X = 0.;
 
   for (UInt i = 0; i < mesh.getNbNodes(); ++i) {
     if (pos(i,1) > 0.49)
       reac_X += residual(i,0);
   }
   if (std::abs(reac_X - (-13.987451183762181)) > eps)
     passed = false;
 
   // Only friction
   Real friction = friction_force(0,0) + friction_force(1,0);
 
   if (std::abs(friction - (-12.517967866999832)) > eps)
     passed = false;
 
 
   /* -------------------------------------------------- */
   /* SHEAR PHASE - displacement back to zero            */
   /* -------------------------------------------------- */
 
   for (UInt nstep = 0; nstep < 30; ++nstep){
 
     for (UInt n = 0; n < mesh.getNbNodes(); ++n) {
       if (pos(n,1) > 0.49)
 	disp(n,0) -= increment;
     }
 
     model.solveStepCohesive<_scm_newton_raphson_tangent, _scc_increment>(tolerance, error, 25, load_reduction, tol_increase_factor);
 
     if (error > tolerance){
-      AKANTU_DEBUG_ERROR("Convergence not reached in the shear unloading phase");
+      AKANTU_ERROR("Convergence not reached in the shear unloading phase");
       passed = false;
     }
 
   }
 
 
   /* ------------------------------------------------------- */
   /* Check the horizontal component of the reaction and      */
   /* the residual relative sliding in the cohesive elements  */
   /* ------------------------------------------------------- */
 
   // Friction + mode II cohesive behavior
   reac_X = 0.;
 
   for (UInt i = 0; i < mesh.getNbNodes(); ++i) {
     if (pos(i,1) > 0.49)
       reac_X += residual(i,0);
   }
   if (std::abs(reac_X - 12.400313187122208) > eps)
     passed = false;
 
   // Only friction
   friction = 0.;
   friction = friction_force(0,0) + friction_force(1,0);
 
   if (std::abs(friction - 12.523300983293165) > eps)
     passed = false;
 
   // Residual sliding
   Real sliding[2];
   sliding[0] = cohe_opening(0,0);
   sliding[1] = cohe_opening(1,0);
 
   if (std::abs(sliding[0] - (-0.00044246686809147357)) > eps)
     passed = false;
 
 
   if (passed)
     return EXIT_SUCCESS;
   else
     return EXIT_FAILURE;
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_cohesive/test_parallel_cohesive/test_cohesive_parallel_buildfragments/test_cohesive_parallel_buildfragments.cc b/test/test_model/test_solid_mechanics_model/test_cohesive/test_parallel_cohesive/test_cohesive_parallel_buildfragments/test_cohesive_parallel_buildfragments.cc
index f80e75f54..5817e0c22 100644
--- a/test/test_model/test_solid_mechanics_model/test_cohesive/test_parallel_cohesive/test_cohesive_parallel_buildfragments/test_cohesive_parallel_buildfragments.cc
+++ b/test/test_model/test_solid_mechanics_model/test_cohesive/test_parallel_cohesive/test_cohesive_parallel_buildfragments/test_cohesive_parallel_buildfragments.cc
@@ -1,432 +1,432 @@
 /**
  * @file   test_cohesive_parallel_buildfragments.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  *
  * @brief  Test to build fragments in parallel
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <limits>
 #include <fstream>
 #include <iostream>
 #include <algorithm>
 #include <functional>
 /* -------------------------------------------------------------------------- */
 #include "solid_mechanics_model_cohesive.hh"
 #include "material_cohesive.hh"
 #include "fragment_manager.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 void verticalInsertionLimit(SolidMechanicsModelCohesive &);
 void displaceElements(SolidMechanicsModelCohesive &, const Real, const Real);
 bool isInertiaEqual(const Vector<Real> &, const Vector<Real> &);
 void rotateArray(Array<Real> & array, Real angle);
 UInt getNbBigFragments(FragmentManager &, UInt);
 
 const UInt spatial_dimension = 3;
 const UInt total_nb_fragment = 4;
 const Real rotation_angle = M_PI / 4.;
 const Real global_tolerance = 1.e-9;
 
 int main(int argc, char *argv[]) {
   initialize("material.dat", argc, argv);
 
   Math::setTolerance(global_tolerance);
 
   Mesh mesh(spatial_dimension);
 
   const auto & comm = Communicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   akantu::MeshPartition * partition = NULL;
   if(prank == 0) {
     // Read the mesh
     mesh.read("mesh.msh");
 
     /// partition the mesh
     MeshUtils::purifyMesh(mesh);
     partition = new MeshPartitionScotch(mesh, spatial_dimension);
     partition->partitionate(psize);
   }
 
   SolidMechanicsModelCohesive model(mesh);
   model.initParallel(partition, NULL, true);
 
   delete partition;
 
   /// model initialization
   model.initFull(SolidMechanicsModelCohesiveOptions(_explicit_lumped_mass, true));
 
   mesh.computeBoundingBox();
   Real L = mesh.getUpperBounds()(0) - mesh.getLowerBounds()(0);
   Real h = mesh.getUpperBounds()(1) - mesh.getLowerBounds()(1);
   Real rho = model.getMaterial("bulk").getParam<Real>("rho");
 
   Real theoretical_mass = L * h * h * rho;
   Real frag_theo_mass = theoretical_mass / total_nb_fragment;
 
   UInt nb_element = mesh.getNbElement(spatial_dimension, _not_ghost, _ek_regular);
   comm.allReduce(&nb_element, 1, _so_sum);
   UInt nb_element_per_fragment = nb_element / total_nb_fragment;
 
   FragmentManager fragment_manager(model);
 
   fragment_manager.computeAllData();
   getNbBigFragments(fragment_manager, nb_element_per_fragment + 1);
 
   model.setBaseName("extrinsic");
   model.addDumpFieldVector("displacement");
   model.addDumpField("velocity");
   model.addDumpField("stress");
   model.addDumpField("partitions");
   model.addDumpField("fragments");
   model.addDumpField("fragments mass");
   model.addDumpField("moments of inertia");
   model.addDumpField("elements per fragment");
   model.dump();
 
   model.setBaseNameToDumper("cohesive elements", "cohesive_elements_test");
   model.addDumpFieldVectorToDumper("cohesive elements", "displacement");
   model.addDumpFieldToDumper("cohesive elements", "damage");
   model.dump("cohesive elements");
 
   /// set check facets
   verticalInsertionLimit(model);
 
   model.assembleMassLumped();
   model.synchronizeBoundaries();
 
   /// impose initial displacement
   Array<Real> & displacement = model.getDisplacement();
   Array<Real> & velocity = model.getVelocity();
   const Array<Real> & position = mesh.getNodes();
   UInt nb_nodes = mesh.getNbNodes();
 
   for (UInt n = 0; n < nb_nodes; ++n) {
     displacement(n, 0) = position(n, 0) * 0.1;
     velocity(n, 0) = position(n, 0);
   }
 
   rotateArray(mesh.getNodes(), rotation_angle);
   //  rotateArray(displacement, rotation_angle);
   //  rotateArray(velocity, rotation_angle);
 
   model.updateResidual();
   model.checkCohesiveStress();
   model.dump();
   model.dump("cohesive elements");
 
   const Array<Real> & fragment_mass = fragment_manager.getMass();
   const Array<Real> & fragment_center = fragment_manager.getCenterOfMass();
 
   Real el_size = L / total_nb_fragment;
   Real lim = -L/2 + el_size * 0.99;
 
   /// define theoretical inertia moments
   Vector<Real> small_frag_inertia(spatial_dimension);
   small_frag_inertia(0) = frag_theo_mass * (h*h + h*h) / 12.;
   small_frag_inertia(1) = frag_theo_mass * (el_size*el_size + h*h) / 12.;
   small_frag_inertia(2) = frag_theo_mass * (el_size*el_size + h*h) / 12.;
 
   std::sort(small_frag_inertia.storage(),
 	    small_frag_inertia.storage() + spatial_dimension,
 	    std::greater<Real>());
 
   const Array<Real> & inertia_moments = fragment_manager.getMomentsOfInertia();
   Array<Real>::const_iterator< Vector<Real> > inertia_moments_begin
     = inertia_moments.begin(spatial_dimension);
 
   /// displace one fragment each time
   for (UInt frag = 1; frag <= total_nb_fragment; ++frag) {
     if (prank == 0)
       std::cout << "Generating fragment: " << frag << std::endl;
 
     fragment_manager.computeAllData();
 
     /// check number of big fragments
     UInt nb_big_fragment = getNbBigFragments(fragment_manager,
 					     nb_element_per_fragment + 1);
 
     model.dump();
     model.dump("cohesive elements");
 
 
     if (frag < total_nb_fragment) {
       if (nb_big_fragment != 1) {
-	AKANTU_DEBUG_ERROR("The number of big fragments is wrong: " << nb_big_fragment);
+	AKANTU_ERROR("The number of big fragments is wrong: " << nb_big_fragment);
 	return EXIT_FAILURE;
       }
     }
     else {
       if (nb_big_fragment != 0) {
-	AKANTU_DEBUG_ERROR("The number of big fragments is wrong: " << nb_big_fragment);
+	AKANTU_ERROR("The number of big fragments is wrong: " << nb_big_fragment);
 	return EXIT_FAILURE;
       }
     }
 
     /// check number of fragments
     UInt nb_fragment_num = fragment_manager.getNbFragment();
 
     if (nb_fragment_num != frag) {
-      AKANTU_DEBUG_ERROR("The number of fragments is wrong! Numerical: " << nb_fragment_num << " Theoretical: " << frag);
+      AKANTU_ERROR("The number of fragments is wrong! Numerical: " << nb_fragment_num << " Theoretical: " << frag);
       return EXIT_FAILURE;
     }
 
     /// check mass computation
     if (frag < total_nb_fragment) {
       Real total_mass = 0.;
       UInt small_fragments = 0;
 
       for (UInt f = 0; f < nb_fragment_num; ++f) {
 	const Vector<Real> & current_inertia = inertia_moments_begin[f];
 
 	if (Math::are_float_equal(fragment_mass(f, 0), frag_theo_mass)) {
 
 	  /// check center of mass
 	  if (fragment_center(f, 0) > (L * frag / total_nb_fragment - L / 2)) {
-	    AKANTU_DEBUG_ERROR("Fragment center is wrong!");
+	    AKANTU_ERROR("Fragment center is wrong!");
 	    return EXIT_FAILURE;
 	  }
 
 	  /// check moment of inertia
 	  if (!isInertiaEqual(current_inertia, small_frag_inertia)) {
-	    AKANTU_DEBUG_ERROR("Inertia moments are wrong");
+	    AKANTU_ERROR("Inertia moments are wrong");
 	    return EXIT_FAILURE;
 	  }
 
 	  ++small_fragments;
 	  total_mass += frag_theo_mass;
 	}
 	else {
 	  /// check the moment of inertia for the biggest fragment
 	  Real big_frag_mass = frag_theo_mass * (total_nb_fragment - frag + 1);
 	  Real big_frag_size = el_size * (total_nb_fragment - frag + 1);
 
 	  Vector<Real> big_frag_inertia(spatial_dimension);
 	  big_frag_inertia(0) = big_frag_mass * (h*h + h*h) / 12.;
 	  big_frag_inertia(1)
 	    = big_frag_mass * (big_frag_size*big_frag_size + h*h) / 12.;
 	  big_frag_inertia(2)
 	    = big_frag_mass * (big_frag_size*big_frag_size + h*h) / 12.;
 
 	  std::sort(big_frag_inertia.storage(),
 		    big_frag_inertia.storage() + spatial_dimension,
 		    std::greater<Real>());
 
 	  if (!isInertiaEqual(current_inertia, big_frag_inertia)) {
-	    AKANTU_DEBUG_ERROR("Inertia moments are wrong");
+	    AKANTU_ERROR("Inertia moments are wrong");
 	    return EXIT_FAILURE;
 	  }
 
 	}
       }
 
       if (small_fragments != nb_fragment_num - 1) {
-	AKANTU_DEBUG_ERROR("The number of small fragments is wrong!");
+	AKANTU_ERROR("The number of small fragments is wrong!");
 	return EXIT_FAILURE;
       }
 
       if (!Math::are_float_equal(total_mass,
 				 small_fragments * frag_theo_mass)) {
-	AKANTU_DEBUG_ERROR("The mass of small fragments is wrong!");
+	AKANTU_ERROR("The mass of small fragments is wrong!");
 	return EXIT_FAILURE;
       }
     }
 
 
     /// displace fragments
     rotateArray(mesh.getNodes(), -rotation_angle);
     //    rotateArray(displacement, -rotation_angle);
     displaceElements(model, lim, el_size * 2);
     rotateArray(mesh.getNodes(), rotation_angle);
     //    rotateArray(displacement, rotation_angle);
 
     model.updateResidual();
 
     lim += el_size;
   }
 
   model.dump();
   model.dump("cohesive elements");
 
   /// check centers
   const Array<Real> & fragment_velocity = fragment_manager.getVelocity();
 
   Real initial_position = -L / 2. + el_size / 2.;
 
   for (UInt frag = 0; frag < total_nb_fragment; ++frag) {
     Real theoretical_center = initial_position + el_size * frag;
 
     UInt f_index = 0;
     while (f_index < total_nb_fragment &&
   	   !Math::are_float_equal(fragment_center(f_index, 0), theoretical_center))
       ++f_index;
 
     if (f_index == total_nb_fragment) {
-      AKANTU_DEBUG_ERROR("The fragments' center is wrong!");
+      AKANTU_ERROR("The fragments' center is wrong!");
       return EXIT_FAILURE;
     }
 
     f_index = 0;
     while (f_index < total_nb_fragment &&
   	   !Math::are_float_equal(fragment_velocity(f_index, 0),
 				  theoretical_center))
       ++f_index;
 
     if (f_index == total_nb_fragment) {
-      AKANTU_DEBUG_ERROR("The fragments' velocity is wrong!");
+      AKANTU_ERROR("The fragments' velocity is wrong!");
       return EXIT_FAILURE;
     }
   }
 
   finalize();
 
   if (prank == 0)
     std::cout << "OK: test_cohesive_buildfragments was passed!" << std::endl;
   return EXIT_SUCCESS;
 }
 
 void verticalInsertionLimit(SolidMechanicsModelCohesive & model) {
   UInt spatial_dimension = model.getSpatialDimension();
   const Mesh & mesh_facets = model.getMeshFacets();
   const Array<Real> & position = mesh_facets.getNodes();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end();
        ++gt) {
     GhostType ghost_type = *gt;
 
     Mesh::type_iterator it  = mesh_facets.firstType(spatial_dimension - 1, ghost_type);
     Mesh::type_iterator end = mesh_facets.lastType(spatial_dimension - 1, ghost_type);
     for(; it != end; ++it) {
       ElementType type = *it;
 
       Array<bool> & check_facets
 	= model.getElementInserter().getCheckFacets(type, ghost_type);
 
       const Array<UInt> & connectivity = mesh_facets.getConnectivity(type, ghost_type);
       UInt nb_nodes_per_facet = connectivity.getNbComponent();
 
       for (UInt f = 0; f < check_facets.getSize(); ++f) {
 	if (!check_facets(f)) continue;
 
 	UInt nb_aligned_nodes = 1;
 	Real first_node_pos = position(connectivity(f, 0), 0);
 
 	for (; nb_aligned_nodes < nb_nodes_per_facet; ++nb_aligned_nodes) {
 	  Real other_node_pos = position(connectivity(f, nb_aligned_nodes), 0);
 
 	  if (! Math::are_float_equal(first_node_pos, other_node_pos))
 	    break;
 	}
 
 	if (nb_aligned_nodes != nb_nodes_per_facet) {
 	  check_facets(f) = false;
 	}
       }
     }
   }
 }
 
 void displaceElements(SolidMechanicsModelCohesive & model,
 		      const Real lim,
 		      const Real amount) {
   UInt spatial_dimension = model.getSpatialDimension();
   Array<Real> & displacement = model.getDisplacement();
   Mesh & mesh = model.getMesh();
   UInt nb_nodes = mesh.getNbNodes();
   Array<bool> displaced(nb_nodes);
   displaced.clear();
   Vector<Real> barycenter(spatial_dimension);
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end();
        ++gt) {
     GhostType ghost_type = *gt;
 
     Mesh::type_iterator it  = mesh.firstType(spatial_dimension, ghost_type);
     Mesh::type_iterator end = mesh.lastType(spatial_dimension, ghost_type);
     for(; it != end; ++it) {
       ElementType type = *it;
       const Array<UInt> & connectivity = mesh.getConnectivity(type, ghost_type);
       UInt nb_element = connectivity.getSize();
       UInt nb_nodes_per_element = connectivity.getNbComponent();
 
       Array<UInt>::const_vector_iterator conn_el
 	= connectivity.begin(nb_nodes_per_element);
 
       for (UInt el = 0; el < nb_element; ++el) {
 	mesh.getBarycenter(el, type, barycenter.storage(), ghost_type);
 
 	if (barycenter(0) < lim) {
 	  const Vector<UInt> & conn = conn_el[el];
 
 	  for (UInt n = 0; n < nb_nodes_per_element; ++n) {
 	    UInt node = conn(n);
 	    if (!displaced(node)) {
 	      displacement(node, 0) -= amount;
 	      displaced(node) = true;
 	    }
 	  }
 	}
       }
     }
   }
 }
 
 bool isInertiaEqual(const Vector<Real> & a, const Vector<Real> & b) {
   UInt nb_terms = a.size();
   UInt equal_terms = 0;
 
   while (equal_terms < nb_terms &&
 	 std::abs(a(equal_terms) - b(equal_terms)) / a(equal_terms) < Math::getTolerance())
     ++equal_terms;
 
   return equal_terms == nb_terms;
 }
 
 void rotateArray(Array<Real> & array, Real angle) {
   UInt spatial_dimension = array.getNbComponent();
 
   Real rotation_values[] = {std::cos(angle), std::sin(angle), 0,
 			    -std::sin(angle), std::cos(angle), 0,
 			    0, 0, 1};
   Matrix<Real> rotation(rotation_values, spatial_dimension, spatial_dimension);
 
   RVector displaced_node(spatial_dimension);
   Array<Real>::vector_iterator node_it = array.begin(spatial_dimension);
   Array<Real>::vector_iterator node_end = array.end(spatial_dimension);
 
   for (; node_it != node_end; ++node_it) {
     displaced_node.mul<false>(rotation, *node_it);
     *node_it = displaced_node;
   }
 }
 
 UInt getNbBigFragments(FragmentManager & fragment_manager,
 		       UInt minimum_nb_elements) {
   fragment_manager.computeNbElementsPerFragment();
   const Array<UInt> & nb_elements_per_fragment
     = fragment_manager.getNbElementsPerFragment();
   UInt nb_fragment = fragment_manager.getNbFragment();
   UInt nb_big_fragment = 0;
 
   for (UInt frag = 0; frag < nb_fragment; ++frag) {
     if (nb_elements_per_fragment(frag) >= minimum_nb_elements) {
       ++nb_big_fragment;
     }
   }
 
   return nb_big_fragment;
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_embedded_interface/test_embedded_interface_model_prestress.cc b/test/test_model/test_solid_mechanics_model/test_embedded_interface/test_embedded_interface_model_prestress.cc
index 116108dc1..22ec062bd 100644
--- a/test/test_model/test_solid_mechanics_model/test_embedded_interface/test_embedded_interface_model_prestress.cc
+++ b/test/test_model/test_solid_mechanics_model/test_embedded_interface/test_embedded_interface_model_prestress.cc
@@ -1,224 +1,224 @@
 /**
  * @file   test_embedded_interface_model_prestress.cc
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  *
  * @date creation: Tue Apr 28 2015
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Embedded model test for prestressing (bases on stress norm)
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 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 "aka_common.hh"
 #include "embedded_interface_model.hh"
 
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 #define YG 0.483644859
 #define I_eq 0.012488874
 #define A_eq (1e-2 + 1. / 7. * 1.)
 
 /* -------------------------------------------------------------------------- */
 
 struct StressSolution : public BC::Neumann::FromHigherDim {
   Real M;
   Real I;
   Real yg;
   Real pre_stress;
 
   StressSolution(UInt dim, Real M, Real I, Real yg = 0, Real pre_stress = 0) :
     BC::Neumann::FromHigherDim(Matrix<Real>(dim, dim)),
     M(M), I(I), yg(yg), pre_stress(pre_stress)
   {}
 
   virtual ~StressSolution() {}
 
   void operator()(const IntegrationPoint & /*quad_point*/, Vector<Real> & dual,
                   const Vector<Real> & coord,
                   const Vector<Real> & normals) const {
     UInt dim = coord.size();
 
-    if (dim < 2) AKANTU_DEBUG_ERROR("Solution not valid for 1D");
+    if (dim < 2) AKANTU_ERROR("Solution not valid for 1D");
 
     Matrix<Real> stress(dim, dim); stress.clear();
     stress(0, 0) = this->stress(coord(1));
     dual.mul<false>(stress, normals);
   }
 
   inline Real stress(Real height) const {
     return -M / I * (height - yg) + pre_stress;
   }
 
   inline Real neutral_axis() const {
     return -I * pre_stress / M + yg;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 
 int main (int argc, char * argv[]) {
   initialize("prestress.dat", argc, argv);
   debug::setDebugLevel(dblError);
 
   Math::setTolerance(1e-6);
 
   const UInt dim = 2;
 
 /* -------------------------------------------------------------------------- */
 
   Mesh mesh(dim);
   mesh.read("embedded_mesh_prestress.msh");
   // mesh.createGroupsFromMeshData<std::string>("physical_names");
 
   Mesh reinforcement_mesh(dim, "reinforcement_mesh");
   try {
     reinforcement_mesh.read("embedded_mesh_prestress_reinforcement.msh");
   } catch(debug::Exception & e) {}
 
   // reinforcement_mesh.createGroupsFromMeshData<std::string>("physical_names");
 
   EmbeddedInterfaceModel model(mesh, reinforcement_mesh, dim);
   model.initFull(EmbeddedInterfaceModelOptions(_static));
 
 /* -------------------------------------------------------------------------- */
 /* Computation of analytical residual                                         */
 /* -------------------------------------------------------------------------- */
 
   /*
    * q = 1000 N/m
    * L = 20 m
    * a = 1 m
    */
 
   Real steel_area = model.getMaterial("reinforcement").get("area");
   Real pre_stress = model.getMaterial("reinforcement").get("pre_stress");
   Real stress_norm = 0.;
 
   StressSolution * concrete_stress = nullptr, * steel_stress = nullptr;
 
   Real pre_force = pre_stress * steel_area;
   Real pre_moment = -pre_force * (YG - 0.25);
   Real neutral_axis = YG - I_eq / A_eq * pre_force / pre_moment;
 
   concrete_stress = new StressSolution(dim, pre_moment, 7. * I_eq, YG, -pre_force / (7. * A_eq));
   steel_stress = new StressSolution(dim, pre_moment, I_eq, YG, pre_stress - pre_force / A_eq);
 
   stress_norm = std::abs(concrete_stress->stress(1)) * (1 - neutral_axis) * 0.5
     + std::abs(concrete_stress->stress(0)) * neutral_axis * 0.5
     + std::abs(steel_stress->stress(0.25)) * steel_area;
 
   model.applyBC(*concrete_stress, "XBlocked");
   auto end_node = *mesh.getElementGroup("EndNode").getNodeGroup().begin();
 
   Vector<Real> end_node_force = model.getForce().begin(dim)[end_node];
   end_node_force(0) += steel_stress->stress(0.25) * steel_area; 
 
   Array<Real> analytical_residual(mesh.getNbNodes(), dim, "analytical_residual");
   analytical_residual.copy(model.getForce());
   model.getForce().clear();
 
   delete concrete_stress;
   delete steel_stress;
 
 /* -------------------------------------------------------------------------- */
 
   model.applyBC(BC::Dirichlet::FixedValue(0.0, _x), "XBlocked");
   model.applyBC(BC::Dirichlet::FixedValue(0.0, _y), "YBlocked");
 
   try {
     model.solveStep();
   } catch (debug::Exception e) {
     std::cerr << e.what() << std::endl;
     return EXIT_FAILURE;
   }
 
 /* -------------------------------------------------------------------------- */
 /* Computation of FEM residual norm                                           */
 /* -------------------------------------------------------------------------- */
 
   ElementGroup & xblocked = mesh.getElementGroup("XBlocked");
   NodeGroup & boundary_nodes = xblocked.getNodeGroup();
   NodeGroup::const_node_iterator
     nodes_it = boundary_nodes.begin(),
     nodes_end = boundary_nodes.end();
   model.assembleInternalForces();
   Array<Real> residual(mesh.getNbNodes(), dim, "my_residual");
   residual.copy(model.getInternalForce());
   residual -= model.getForce();
 
   Array<Real>::vector_iterator com_res = residual.begin(dim);
   Array<Real>::vector_iterator position = mesh.getNodes().begin(dim);
 
   Real res_sum = 0.;
   UInt lower_node = -1;
   UInt upper_node = -1;
   Real lower_dist = 1;
   Real upper_dist = 1;
 
   for (; nodes_it != nodes_end ; ++nodes_it) {
     UInt node_number = *nodes_it;
     const Vector<Real> res = com_res[node_number];
     const Vector<Real> pos = position[node_number];
 
     if (!Math::are_float_equal(pos(1), 0.25)) {
       if ((std::abs(pos(1) - 0.25) < lower_dist) && (pos(1) < 0.25)) {
         lower_dist = std::abs(pos(1) - 0.25);
         lower_node = node_number;
       }
 
       if ((std::abs(pos(1) - 0.25) < upper_dist) && (pos(1) > 0.25)) {
         upper_dist = std::abs(pos(1) - 0.25);
         upper_node = node_number;
       }
     }
 
     for (UInt i = 0 ; i < dim ; i++) {
       if (!Math::are_float_equal(pos(1), 0.25)) {
         res_sum += std::abs(res(i));
       }
     }
   }
 
   const Vector<Real> upper_res = com_res[upper_node], lower_res = com_res[lower_node];
   const Vector<Real> end_node_res = com_res[end_node];
   Vector<Real> delta = upper_res - lower_res;
   delta *= lower_dist / (upper_dist + lower_dist);
   Vector<Real> concrete_residual = lower_res + delta;
   Vector<Real> steel_residual = end_node_res - concrete_residual;
 
   for (UInt i = 0 ; i < dim ; i++) {
     res_sum += std::abs(concrete_residual(i));
     res_sum += std::abs(steel_residual(i));
   }
 
   Real relative_error = std::abs(res_sum - stress_norm) / stress_norm;
 
   if (relative_error > 1e-3) {
     std::cerr << "Relative error = " << relative_error << std::endl;
     return EXIT_FAILURE;
   }
 
   finalize();
   return 0;
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/test_material_fixtures.hh b/test/test_model/test_solid_mechanics_model/test_materials/test_material_fixtures.hh
index c0a846674..d741bb226 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/test_material_fixtures.hh
+++ b/test/test_model/test_solid_mechanics_model/test_materials/test_material_fixtures.hh
@@ -1,181 +1,184 @@
 /* -------------------------------------------------------------------------- */
 #include "material_elastic.hh"
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 #include <gtest/gtest.h>
 #include <random>
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
-#define TO_IMPLEMENT AKANTU_EXCEPTION("TEST TO IMPLEMENT")
-
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 template <typename T> class FriendMaterial : public T {
 public:
   ~FriendMaterial() = default;
-  
-  virtual void testComputeStress() { TO_IMPLEMENT; };
-  virtual void testComputeTangentModuli() { TO_IMPLEMENT; };
-  virtual void testEnergyDensity() { TO_IMPLEMENT; };
-  virtual void testPushWaveSpeed() { TO_IMPLEMENT; }
-  virtual void testShearWaveSpeed() { TO_IMPLEMENT; }
+
+  virtual void testComputeStress() { AKANTU_TO_IMPLEMENT(); };
+  virtual void testComputeTangentModuli() { AKANTU_TO_IMPLEMENT(); };
+  virtual void testEnergyDensity() { AKANTU_TO_IMPLEMENT(); };
+  virtual void testPushWaveSpeed() { AKANTU_TO_IMPLEMENT(); }
+  virtual void testShearWaveSpeed() { AKANTU_TO_IMPLEMENT(); }
 
   static inline Matrix<Real> getDeviatoricStrain(Real intensity);
 
   static inline Matrix<Real> getHydrostaticStrain(Real intensity);
 
   static inline const Matrix<Real>
   reverseRotation(Matrix<Real> mat, Matrix<Real> rotation_matrix) {
     Matrix<Real> R = rotation_matrix;
     Matrix<Real> m2 = mat * R;
     Matrix<Real> m1 = R.transpose();
     return m1 * m2;
   };
 
   static inline const Matrix<Real>
   applyRotation(Matrix<Real> mat, const Matrix<Real> rotation_matrix) {
     Matrix<Real> R = rotation_matrix;
     Matrix<Real> m2 = mat * R.transpose();
     Matrix<Real> m1 = R;
     return m1 * m2;
   };
 
   static inline Matrix<Real> getRandomRotation3d();
   static inline Matrix<Real> getRandomRotation2d();
 
   using T::T;
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 Matrix<Real> FriendMaterial<T>::getDeviatoricStrain(Real intensity) {
-  Matrix<Real> dev = {{0, 1, 2}, {1, 0, 3}, {2, 3, 0}};
+  Matrix<Real> dev = {{0., 1., 2.}, {1., 0., 3.}, {2., 3., 0.}};
   dev *= intensity;
   return dev;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 Matrix<Real> FriendMaterial<T>::getHydrostaticStrain(Real intensity) {
-  Matrix<Real> dev = {{1, 0, 0}, {0, 2, 0}, {0, 0, 3}};
+  Matrix<Real> dev = {{1., 0., 0.}, {0., 2., 0.}, {0., 0., 3.}};
   dev *= intensity;
   return dev;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> Matrix<Real> FriendMaterial<T>::getRandomRotation3d() {
   constexpr UInt Dim = 3;
   // Seed with a real random value, if available
   std::random_device rd;
   std::mt19937 gen(rd()); // Standard mersenne_twister_engine seeded with rd()
   std::uniform_real_distribution<> dis;
 
   Vector<Real> v1(Dim);
   Vector<Real> v2(Dim);
   Vector<Real> v3(Dim);
 
   for (UInt i = 0; i < Dim; ++i) {
     v1(i) = dis(gen);
     v2(i) = dis(gen);
   }
 
   v1.normalize();
   v2.normalize();
 
   auto d = v1.dot(v2);
   v2 -= v1 * d;
   v2.normalize();
 
   d = v1.dot(v2);
   v2 -= v1 * d;
   v2.normalize();
 
   v3.crossProduct(v1, v2);
 
   Vector<Real> test_axis(3);
   test_axis.crossProduct(v1, v2);
   test_axis -= v3;
   if (test_axis.norm() > 8 * std::numeric_limits<Real>::epsilon()) {
-    AKANTU_DEBUG_ERROR("The axis vectors do not form a right-handed coordinate "
-                       << "system. I. e., ||n1 x n2 - n3|| should be zero, but "
-                       << "it is " << test_axis.norm() << ".");
+    AKANTU_ERROR("The axis vectors do not form a right-handed coordinate "
+                 << "system. I. e., ||n1 x n2 - n3|| should be zero, but "
+                 << "it is " << test_axis.norm() << ".");
   }
 
   Matrix<Real> mat(Dim, Dim);
   for (UInt i = 0; i < Dim; ++i) {
     mat(0, i) = v1[i];
     mat(1, i) = v2[i];
     mat(2, i) = v3[i];
   }
 
   return mat;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> Matrix<Real> FriendMaterial<T>::getRandomRotation2d() {
   constexpr UInt Dim = 2;
   // Seed with a real random value, if available
   std::random_device rd;
   std::mt19937 gen(rd()); // Standard mersenne_twister_engine seeded with rd()
   std::uniform_real_distribution<> dis;
 
   // v1 and v2 are such that they form a right-hand basis with prescribed v3,
   // it's need (at least) for 2d linear elastic anisotropic and (orthotropic)
   // materials to rotate the tangent stiffness
-  
+
   Vector<Real> v1(3);
   Vector<Real> v2(3);
-  Vector<Real> v3 = {0,0,1};
+  Vector<Real> v3 = {0, 0, 1};
 
   for (UInt i = 0; i < Dim; ++i) {
     v1(i) = dis(gen);
     // v2(i) = dis(gen);
   }
 
   v1.normalize();
-  v2.crossProduct(v3,v1);
+  v2.crossProduct(v3, v1);
 
   Matrix<Real> mat(Dim, Dim);
   for (UInt i = 0; i < Dim; ++i) {
     mat(0, i) = v1[i];
     mat(1, i) = v2[i];
   }
 
   return mat;
 }
 
 /* -------------------------------------------------------------------------- */
-template <typename T> class TestMaterialFixture : public ::testing::Test {
+template <typename T, class Model>
+class TestMaterialBaseFixture : public ::testing::Test {
 public:
   using mat_class = typename T::mat_class;
 
   void SetUp() override {
     constexpr auto spatial_dimension = T::Dim;
     mesh = std::make_unique<Mesh>(spatial_dimension);
-    model = std::make_unique<SolidMechanicsModel>(*mesh);
+    model = std::make_unique<Model>(*mesh);
     material = std::make_unique<friend_class>(*model);
   }
 
   void TearDown() override {
     material.reset(nullptr);
     model.reset(nullptr);
     mesh.reset(nullptr);
   }
 
   using friend_class = FriendMaterial<mat_class>;
 
 protected:
   std::unique_ptr<Mesh> mesh;
-  std::unique_ptr<SolidMechanicsModel> model;
+  std::unique_ptr<Model> model;
   std::unique_ptr<friend_class> material;
 };
 
 /* -------------------------------------------------------------------------- */
 template <template <UInt> class T, UInt _Dim> struct Traits {
   using mat_class = T<_Dim>;
   static constexpr UInt Dim = _Dim;
 };
 
 /* -------------------------------------------------------------------------- */
+template <typename T, class Model>
+using TestMaterialFixture = TestMaterialBaseFixture<T, SolidMechanicsModel>;
+
+/* -------------------------------------------------------------------------- */
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/test_multi_material_elastic.cc b/test/test_model/test_solid_mechanics_model/test_materials/test_multi_material_elastic.cc
index 67495b00a..a2bcaf733 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/test_multi_material_elastic.cc
+++ b/test/test_model/test_solid_mechanics_model/test_materials/test_multi_material_elastic.cc
@@ -1,92 +1,92 @@
 #include <solid_mechanics_model.hh>
 #include "non_linear_solver.hh"
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   initialize("test_multi_material_elastic.dat", argc, argv);
 
   UInt spatial_dimension = 2;
   Mesh mesh(spatial_dimension);
 
   mesh.read("test_multi_material_elastic.msh");
 
   SolidMechanicsModel model(mesh);
 
   auto && mat_sel = std::make_shared<MeshDataMaterialSelector<std::string>>("physical_names", model);
   model.setMaterialSelector(mat_sel);
 
   model.initFull(_analysis_method = _static);
 
   model.applyBC(BC::Dirichlet::FlagOnly(_y), "ground");
   model.applyBC(BC::Dirichlet::FlagOnly(_x), "corner");
 
   Vector<Real> trac(spatial_dimension, 0.);
   trac(_y) = 1.;
   model.applyBC(BC::Neumann::FromTraction(trac), "air");
 
   model.addDumpField("external_force");
   model.addDumpField("internal_force");
   model.addDumpField("blocked_dofs");
   model.addDumpField("displacement");
   model.addDumpField("stress");
   model.addDumpField("grad_u");
 
   //model.dump();
   auto & solver = model.getNonLinearSolver("static");
   solver.set("max_iterations", 1);
   solver.set("threshold", 1e-8);
   solver.set("convergence_type", _scc_residual);
 
   model.solveStep();
   //model.dump();
 
   std::map<std::string, Matrix<Real>> ref_strain;
   ref_strain["strong"] = Matrix<Real>(spatial_dimension, spatial_dimension, 0.);
   ref_strain["strong"](_y, _y) = .5;
 
   ref_strain["weak"] = Matrix<Real>(spatial_dimension, spatial_dimension, 0.);
   ref_strain["weak"](_y, _y) = 1;
 
   Matrix<Real> ref_stress(spatial_dimension, spatial_dimension, 0.);
   ref_stress(_y, _y) = 1.;
 
   std::vector<std::string> mats = {"strong", "weak"};
 
   typedef Array<Real>::const_matrix_iterator mat_it;
   auto check = [](mat_it it, mat_it end, const Matrix<Real> & ref) -> bool {
     for(;it != end; ++it) {
       Real dist = (*it - ref).norm<L_2>();
 
       //std::cout << *it << " " << dist << " " << (dist < 1e-10 ? "OK" : "Not OK") << std::endl;
 
       if (dist > 1e-10) return false;
     }
 
     return true;
   };
 
   auto tit = mesh.firstType(spatial_dimension);
   auto tend = mesh.lastType(spatial_dimension);
   for (; tit != tend; ++tit) {
     auto & type = *tit;
 
     for(auto mat_id : mats) {
       auto & stress = model.getMaterial(mat_id).getStress(type);
       auto & grad_u = model.getMaterial(mat_id).getGradU(type);
 
       auto sit = stress.begin(spatial_dimension, spatial_dimension);
       auto send = stress.end(spatial_dimension, spatial_dimension);
 
       auto git = grad_u.begin(spatial_dimension, spatial_dimension);
       auto gend = grad_u.end(spatial_dimension, spatial_dimension);
 
-      if(!check(sit, send, ref_stress)) AKANTU_DEBUG_ERROR("The stresses are not correct");
-      if(!check(git, gend, ref_strain[mat_id])) AKANTU_DEBUG_ERROR("The grad_u are not correct");
+      if(!check(sit, send, ref_stress)) AKANTU_ERROR("The stresses are not correct");
+      if(!check(git, gend, ref_strain[mat_id])) AKANTU_ERROR("The grad_u are not correct");
     }
   }
 
   finalize();
 
    return 0;
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_solid_mechanics_model_reassign_material.cc b/test/test_model/test_solid_mechanics_model/test_solid_mechanics_model_reassign_material.cc
index f43fefe29..a2d5c741b 100644
--- a/test/test_model/test_solid_mechanics_model/test_solid_mechanics_model_reassign_material.cc
+++ b/test/test_model/test_solid_mechanics_model/test_solid_mechanics_model_reassign_material.cc
@@ -1,212 +1,212 @@
 /**
  * @file   test_solid_mechanics_model_reassign_material.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  *
  * @date creation: Mon Feb 10 2014
  * @date last modification: Wed Feb 25 2015
  *
  * @brief  test the function reassign material
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 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 "aka_grid_dynamic.hh"
 #include "material.hh"
 #include "solid_mechanics_model.hh"
 #include "communicator.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 
 
 using namespace akantu;
 
 class StraightInterfaceMaterialSelector : public MaterialSelector {
 public:
   StraightInterfaceMaterialSelector(SolidMechanicsModel & model,
                                     const std::string & mat_1_material,
                                     const std::string & mat_2_material,
                                     bool & horizontal, Real & pos_interface)
       : model(model), mat_1_material(mat_1_material),
         mat_2_material(mat_2_material), horizontal(horizontal),
         pos_interface(pos_interface) {
     Mesh & mesh = model.getMesh();
     UInt spatial_dimension = mesh.getSpatialDimension();
 
     /// store barycenters of all elements
     barycenters.initialize(mesh, _spatial_dimension = spatial_dimension,
                                  _nb_component = spatial_dimension);
 
     for (auto  ghost_type : ghost_types) {
       Element e;
       e.ghost_type = ghost_type;
 
       Mesh::type_iterator it = mesh.firstType(spatial_dimension, ghost_type);
       Mesh::type_iterator last_type =
           mesh.lastType(spatial_dimension, ghost_type);
       for (; it != last_type; ++it) {
         UInt nb_element = mesh.getNbElement(*it, ghost_type);
         e.type = *it;
         Array<Real> & barycenter = barycenters(*it, ghost_type);
         barycenter.resize(nb_element);
 
         Array<Real>::iterator<Vector<Real>> bary_it =
             barycenter.begin(spatial_dimension);
         for (UInt elem = 0; elem < nb_element; ++elem) {
           e.element = elem;
           mesh.getBarycenter(e, *bary_it);
           ++bary_it;
         }
       }
     }
   }
 
   UInt operator()(const Element & elem) {
     UInt spatial_dimension = model.getSpatialDimension();
     const Vector<Real> & bary = barycenters(elem.type, elem.ghost_type)
                                     .begin(spatial_dimension)[elem.element];
 
     /// check for a given element on which side of the material interface plane
     /// the bary center lies and assign corresponding material
     if (bary(!horizontal) < pos_interface) {
       return model.getMaterialIndex(mat_1_material);
       ;
     }
     return model.getMaterialIndex(mat_2_material);
     ;
   }
 
   bool isConditonVerified() {
 
     /// check if material has been (re)-assigned correctly
     Mesh & mesh = model.getMesh();
     UInt spatial_dimension = mesh.getSpatialDimension();
     GhostType ghost_type = _not_ghost;
 
     Mesh::type_iterator it = mesh.firstType(spatial_dimension, ghost_type);
     Mesh::type_iterator last_type =
         mesh.lastType(spatial_dimension, ghost_type);
     for (; it != last_type; ++it) {
       Array<UInt> & mat_indexes = model.getMaterialByElement(*it, ghost_type);
       UInt nb_element = mesh.getNbElement(*it, ghost_type);
       Array<Real>::iterator<Vector<Real>> bary =
           barycenters(*it, ghost_type).begin(spatial_dimension);
       for (UInt elem = 0; elem < nb_element; ++elem, ++bary) {
         /// compare element_index_by material to material index that should be
         /// assigned due to the geometry of the interface
         UInt mat_index;
         if ((*bary)(!horizontal) < pos_interface)
           mat_index = model.getMaterialIndex(mat_1_material);
         else
           mat_index = model.getMaterialIndex(mat_2_material);
 
         if (mat_indexes(elem) != mat_index)
           /// wrong material index, make test fail
           return false;
       }
     }
     return true;
   }
 
   void moveInterface(Real & pos_new, bool & horizontal_new) {
     /// update position and orientation of material interface plane
     pos_interface = pos_new;
     horizontal = horizontal_new;
     model.reassignMaterial();
   }
 
 protected:
   SolidMechanicsModel & model;
   ElementTypeMapArray<Real> barycenters;
   std::string mat_1_material;
   std::string mat_2_material;
   bool horizontal;
   Real pos_interface;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Main                                                                       */
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
 
   bool test_passed;
 
   debug::setDebugLevel(dblWarning);
   initialize("two_materials.dat", argc, argv);
 
   /// specify position and orientation of material interface plane
   bool horizontal = true;
   Real pos_interface = 0.;
 
   UInt spatial_dimension = 3;
 
   const auto & comm =
     Communicator::getStaticCommunicator();
   Int prank = comm.whoAmI();
 
   Mesh mesh(spatial_dimension);
 
   if (prank == 0)     mesh.read("cube_two_materials.msh");
   mesh.distribute();
 
   /// model creation
   SolidMechanicsModel model(mesh);
 
   /// assign the two different materials using the
   /// StraightInterfaceMaterialSelector
 
   auto && mat_selector = std::make_shared<StraightInterfaceMaterialSelector>(
       model, "mat_1", "mat_2", horizontal, pos_interface);
 
   model.setMaterialSelector(mat_selector);
   model.initFull(_analysis_method = _static);
   MeshUtils::buildFacets(mesh);
 
   /// check if different materials have been assigned correctly
   test_passed = mat_selector->isConditonVerified();
   if (!test_passed) {
-    AKANTU_DEBUG_ERROR("materials not correctly assigned");
+    AKANTU_ERROR("materials not correctly assigned");
     return EXIT_FAILURE;
   }
 
   /// change orientation of material interface plane
   horizontal = false;
   mat_selector->moveInterface(pos_interface, horizontal);
 
   // model.dump();
 
   /// test if material has been reassigned correctly
   test_passed = mat_selector->isConditonVerified();
   if (!test_passed) {
-    AKANTU_DEBUG_ERROR("materials not correctly reassigned");
+    AKANTU_ERROR("materials not correctly reassigned");
     return EXIT_FAILURE;
   }
 
   finalize();
 
   if (prank == 0)
     std::cout << "OK: test passed!" << std::endl;
 
   return EXIT_SUCCESS;
 }
 
 /* -------------------------------------------------------------------------- */
diff --git a/test/test_synchronizer/test_dof_data_accessor.hh b/test/test_synchronizer/test_dof_data_accessor.hh
index 45f83c5bd..e5308ea40 100644
--- a/test/test_synchronizer/test_dof_data_accessor.hh
+++ b/test/test_synchronizer/test_dof_data_accessor.hh
@@ -1,117 +1,117 @@
 /**
  * @file   test_dof_data_accessor.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  *
  * @date creation: Tue Dec 09 2014
  *
  * @brief  data accessor class for testing the
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 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 "aka_common.hh"
 #include "data_accessor.hh"
 
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 class TestDOFAccessor : public DataAccessor {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   inline TestDOFAccessor(const Array<Int> & global_dof_equation_numbers);
 
 
   /* ------------------------------------------------------------------------ */
   /* Ghost Synchronizer inherited members                                     */
   /* ------------------------------------------------------------------------ */
 protected:
   inline UInt getNbDataForDOFs(const Array<UInt> & dofs,
 			       SynchronizationTag tag) const;
   inline void packDOFData(CommunicationBuffer & buffer,
 			  const Array<UInt> & dofs,
 			  SynchronizationTag tag) const;
   inline void unpackDOFData(CommunicationBuffer & buffer,
 			    const Array<UInt> & dofs,
 			    SynchronizationTag tag);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   const Array<Int> & global_dof_equation_numbers;
 };
 
 
 /* -------------------------------------------------------------------------- */
 /* TestDOFSynchronizer implementation                                            */
 /* -------------------------------------------------------------------------- */
 inline TestDOFAccessor::TestDOFAccessor(const Array<Int> & global_dof_equation_numbers)
   : global_dof_equation_numbers(global_dof_equation_numbers) { }
 
 inline UInt TestDOFAccessor::getNbDataForDOFs(const Array<UInt> & dofs,
 					       __attribute__ ((unused)) SynchronizationTag tag) const {
   if(dofs.size())
     // return Mesh::getSpatialDimension(elements(0).type) * sizeof(Real) * elements.size();
     return sizeof(Int) * dofs.size();
   else
     return 0;
 }
 
 inline void TestDOFAccessor::packDOFData(CommunicationBuffer & buffer,
 					  const Array<UInt> & dofs,
 					  __attribute__ ((unused)) SynchronizationTag tag) const {
   Array<UInt>::const_scalar_iterator bit  = dofs.begin();
   Array<UInt>::const_scalar_iterator bend = dofs.end();
   for (; bit != bend; ++bit) {
     buffer << this->global_dof_equation_numbers[*bit];
   }
 }
 
 inline void TestDOFAccessor::unpackDOFData(CommunicationBuffer & buffer,
 					    const Array<UInt> & dofs,
 					    __attribute__ ((unused)) SynchronizationTag tag) {
   Array<UInt>::const_scalar_iterator bit  = dofs.begin();
   Array<UInt>::const_scalar_iterator bend = dofs.end();
   for (; bit != bend; ++bit) {
     Int global_dof_eq_nb_local = global_dof_equation_numbers[*bit];
     Int global_dof_eq_nb = 0;
     buffer >> global_dof_eq_nb;
     std::cout << *bit << global_dof_eq_nb_local << std::endl;
     Real tolerance = Math::getTolerance();
       if(!(std::abs(global_dof_eq_nb - global_dof_eq_nb_local) <= tolerance))
-        AKANTU_DEBUG_ERROR("Unpacking an unknown value for the dof: "
+        AKANTU_ERROR("Unpacking an unknown value for the dof: "
                            << *bit
                            << "(global_dof_equation_number = " << global_dof_eq_nb_local
                            << " and buffer = " << global_dof_eq_nb << ") - tag: " << tag);
   }
 }
 
 
 } // namespace akantu
diff --git a/test/test_synchronizer/test_grid_synchronizer.cc b/test/test_synchronizer/test_grid_synchronizer.cc
index 90e97ddcc..135ff3452 100644
--- a/test/test_synchronizer/test_grid_synchronizer.cc
+++ b/test/test_synchronizer/test_grid_synchronizer.cc
@@ -1,299 +1,299 @@
 /**
  * @file   test_grid_synchronizer.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Sep 01 2010
  * @date last modification: Fri Feb 27 2015
  *
  * @brief  test the GridSynchronizer object
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 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 "aka_common.hh"
 #include "aka_grid_dynamic.hh"
 #include "mesh.hh"
 #include "grid_synchronizer.hh"
 #include "mesh_partition.hh"
 #include "synchronizer_registry.hh"
 #include "test_data_accessor.hh"
 #ifdef AKANTU_USE_IOHELPER
 #  include "io_helper.hh"
 #endif //AKANTU_USE_IOHELPER
 
 using namespace akantu;
 
 const UInt spatial_dimension = 2;
 
 typedef std::map<std::pair<Element, Element>, Real> pair_list;
 
 #include "test_grid_tools.hh"
 
 static void updatePairList(const ElementTypeMapArray<Real> & barycenter,
                              const SpatialGrid<Element> & grid,
                              Real radius,
                              pair_list & neighbors,
                              neighbors_map_t<spatial_dimension>::type & neighbors_map) {
   AKANTU_DEBUG_IN();
 
   GhostType ghost_type = _not_ghost;
 
   Element e;
   e.ghost_type = ghost_type;
 
   // generate the pair of neighbor depending of the cell_list
   ElementTypeMapArray<Real>::type_iterator it        = barycenter.firstType(_all_dimensions, ghost_type);
   ElementTypeMapArray<Real>::type_iterator last_type = barycenter.lastType(0, ghost_type);
   for(; it != last_type; ++it) {
     // loop over quad points
 
     e.type = *it;
     e.element = 0;
 
     const Array<Real> & barycenter_vect = barycenter(*it, ghost_type);
     UInt sp = barycenter_vect.getNbComponent();
 
     Array<Real>::const_iterator< Vector<Real> > bary =
       barycenter_vect.begin(sp);
     Array<Real>::const_iterator< Vector<Real> > bary_end =
       barycenter_vect.end(sp);
 
     for(;bary != bary_end; ++bary, e.element++) {
 #if !defined(AKANTU_NDEBUG)
       Point<spatial_dimension> pt1(*bary);
 #endif
 
       SpatialGrid<Element>::CellID cell_id = grid.getCellID(*bary);
       SpatialGrid<Element>::neighbor_cells_iterator first_neigh_cell =
         grid.beginNeighborCells(cell_id);
       SpatialGrid<Element>::neighbor_cells_iterator last_neigh_cell =
         grid.endNeighborCells(cell_id);
 
       // loop over neighbors cells of the one containing the current element
       for (; first_neigh_cell != last_neigh_cell; ++first_neigh_cell) {
         SpatialGrid<Element>::Cell::const_iterator first_neigh_el =
           grid.beginCell(*first_neigh_cell);
         SpatialGrid<Element>::Cell::const_iterator last_neigh_el =
           grid.endCell(*first_neigh_cell);
 
         // loop over the quadrature point in the current cell of the cell list
         for (;first_neigh_el != last_neigh_el; ++first_neigh_el){
           const Element & elem = *first_neigh_el;
 
 	  Array<Real>::const_iterator< Vector<Real> > neigh_it =
 	    barycenter(elem.type, elem.ghost_type).begin(sp);
 
 	  const Vector<Real> & neigh_bary = neigh_it[elem.element];
 
           Real distance = bary->distance(neigh_bary);
           if(distance <= radius) {
 #if !defined(AKANTU_NDEBUG)
             Point<spatial_dimension> pt2(neigh_bary);
             neighbors_map[pt1].push_back(pt2);
 #endif
             std::pair<Element, Element> pair = std::make_pair(e, elem);
             pair_list::iterator p = neighbors.find(pair);
             if(p != neighbors.end()) {
-              AKANTU_DEBUG_ERROR("Pair already registered [" << e << " " << elem << "] -> " << p->second << " " << distance);
+              AKANTU_ERROR("Pair already registered [" << e << " " << elem << "] -> " << p->second << " " << distance);
             } else {
               neighbors[pair] = distance;
             }
           }
         }
       }
     }
   }
   AKANTU_DEBUG_OUT();
 }
 
 
 /* -------------------------------------------------------------------------- */
 /* Main                                                                       */
 /* -------------------------------------------------------------------------- */
 int main(int argc, char *argv[]) {
   akantu::initialize(argc, argv);
 
   Real radius = 0.001;
 
   Mesh mesh(spatial_dimension);
 
   const auto & comm = Communicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
   ElementSynchronizer * dist = NULL;
 
   if(prank == 0) {
     mesh.read("bar.msh");
     MeshPartition * partition = new MeshPartitionScotch(mesh, spatial_dimension);
     partition->partitionate(psize);
     dist = ElementSynchronizer::createDistributedSynchronizerMesh(mesh, partition);
     delete partition;
   } else {
     dist = ElementSynchronizer::createDistributedSynchronizerMesh(mesh, NULL);
   }
 
   mesh.computeBoundingBox();
 
   const Vector<Real> & lower_bounds = mesh.getLowerBounds();
   const Vector<Real> & upper_bounds = mesh.getUpperBounds();
 
   Vector<Real> center = 0.5 * (upper_bounds + lower_bounds);
 
   Vector<Real> spacing(spatial_dimension);
   for (UInt i = 0; i < spatial_dimension; ++i) {
     spacing[i] = radius * 1.2;
   }
 
   SpatialGrid<Element> grid(spatial_dimension, spacing, center);
 
   GhostType ghost_type = _not_ghost;
 
   Mesh::type_iterator it = mesh.firstType(spatial_dimension, ghost_type);
   Mesh::type_iterator last_type = mesh.lastType(spatial_dimension, ghost_type);
 
   ElementTypeMapArray<Real> barycenters("", "");
   mesh.initElementTypeMapArray(barycenters, spatial_dimension, spatial_dimension);
 
   Element e;
   e.ghost_type = ghost_type;
 
   for(; it != last_type; ++it) {
     UInt nb_element = mesh.getNbElement(*it, ghost_type);
     e.type = *it;
     Array<Real> & barycenter = barycenters(*it, ghost_type);
     barycenter.resize(nb_element);
 
     Array<Real>::iterator< Vector<Real> > bary_it = barycenter.begin(spatial_dimension);
     for (UInt elem = 0; elem < nb_element; ++elem) {
       mesh.getBarycenter(elem, *it, bary_it->storage(), ghost_type);
       e.element = elem;
       grid.insert(e, *bary_it);
       ++bary_it;
     }
   }
 
   std::stringstream sstr; sstr << "mesh_" << prank << ".msh";
   mesh.write(sstr.str());
 
   Mesh grid_mesh(spatial_dimension, "grid_mesh", 0);
   std::stringstream sstr_grid; sstr_grid << "grid_mesh_" << prank << ".msh";
   grid.saveAsMesh(grid_mesh);
   grid_mesh.write(sstr_grid.str());
 
 
 
   std::cout << "Pouet 1" << std::endl;
 
   AKANTU_DEBUG_INFO("Creating TestAccessor");
   TestAccessor test_accessor(mesh, barycenters);
   SynchronizerRegistry synch_registry(test_accessor);
 
   GridSynchronizer * grid_communicator = GridSynchronizer::createGridSynchronizer(mesh, grid);
 
   std::cout << "Pouet 2" << std::endl;
 
   ghost_type = _ghost;
 
   it = mesh.firstType(spatial_dimension, ghost_type);
   last_type = mesh.lastType(spatial_dimension, ghost_type);
   e.ghost_type = ghost_type;
   for(; it != last_type; ++it) {
     UInt nb_element = mesh.getNbElement(*it, ghost_type);
     e.type = *it;
     Array<Real> & barycenter = barycenters(*it, ghost_type);
     barycenter.resize(nb_element);
 
     Array<Real>::iterator< Vector<Real> > bary_it = barycenter.begin(spatial_dimension);
     for (UInt elem = 0; elem < nb_element; ++elem) {
       mesh.getBarycenter(elem, *it, bary_it->storage(), ghost_type);
       e.element = elem;
       grid.insert(e, *bary_it);
       ++bary_it;
     }
   }
 
   Mesh grid_mesh_ghost(spatial_dimension, "grid_mesh_ghost", 0);
   std::stringstream sstr_gridg; sstr_gridg << "grid_mesh_ghost_" << prank << ".msh";
   grid.saveAsMesh(grid_mesh_ghost);
   grid_mesh_ghost.write(sstr_gridg.str());
 
   std::cout << "Pouet 3" << std::endl;
 
 
   neighbors_map_t<spatial_dimension>::type neighbors_map;
   pair_list neighbors;
 
   updatePairList(barycenters, grid, radius, neighbors, neighbors_map);
   pair_list::iterator nit  = neighbors.begin();
   pair_list::iterator nend = neighbors.end();
 
   std::stringstream sstrp; sstrp << "pairs_" << prank;
   std::ofstream fout(sstrp.str().c_str());
   for(;nit != nend; ++nit) {
     fout << "[" << nit->first.first << "," << nit->first.second << "] -> "
          << nit->second << std::endl;
   }
 
   std::string file = "neighbors_ref";
   std::stringstream sstrf; sstrf << file << "_" << psize << "_" << prank;
 
   file = sstrf.str();
 
   std::ofstream nout;
   nout.open(file.c_str());
   neighbors_map_t<spatial_dimension>::type::iterator it_n = neighbors_map.begin();
   neighbors_map_t<spatial_dimension>::type::iterator end_n = neighbors_map.end();
   for(;it_n != end_n; ++it_n) {
     std::sort(it_n->second.begin(), it_n->second.end());
 
     std::vector< Point<spatial_dimension> >::iterator it_v = it_n->second.begin();
     std::vector< Point<spatial_dimension> >::iterator end_v = it_n->second.end();
 
     nout << "####" << std::endl;
     nout << it_n->second.size() << std::endl;
     nout << it_n->first << std::endl;
     nout << "#" << std::endl;
     for(;it_v != end_v; ++it_v) {
       nout << *it_v << std::endl;
     }
   }
 
   fout.close();
 
 
   synch_registry.registerSynchronizer(*dist, _gst_smm_mass);
 
   synch_registry.registerSynchronizer(*grid_communicator, _gst_test);
 
   AKANTU_DEBUG_INFO("Synchronizing tag on Dist");
   synch_registry.synchronize(_gst_smm_mass);
 
   AKANTU_DEBUG_INFO("Synchronizing tag on Grid");
   synch_registry.synchronize(_gst_test);
 
   delete grid_communicator;
   delete dist;
   akantu::finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_synchronizer/test_grid_synchronizer_check_neighbors.cc b/test/test_synchronizer/test_grid_synchronizer_check_neighbors.cc
index e5b3eeff6..0faf3713a 100644
--- a/test/test_synchronizer/test_grid_synchronizer_check_neighbors.cc
+++ b/test/test_synchronizer/test_grid_synchronizer_check_neighbors.cc
@@ -1,122 +1,122 @@
 /**
  * @file   test_grid_synchronizer_check_neighbors.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Mar 11 2013
  * @date last modification: Fri Feb 27 2015
  *
  * @brief  Test the generation of neighbors list based on a akaentu::Grid
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 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 <fstream>
 #include <iostream>
 #include <string>
 
 #include "aka_common.hh"
 #include "communicator.hh"
 
 using namespace akantu;
 
 const UInt spatial_dimension = 3;
 
 #include "test_grid_tools.hh"
 
 void readNeighbors(std::ifstream & nin,
                    neighbors_map_t<spatial_dimension>::type & neighbors_map_read) {
   std::string line;
   while (std::getline(nin, line)) {
     std::getline(nin, line);
     std::istringstream iss(line);
     UInt nb_neig;
     iss >> nb_neig;
     std::getline(nin, line);
     Point<spatial_dimension> pt;
     pt.read(line);
     std::getline(nin, line);
     for (UInt i = 0; i < nb_neig; ++i) {
       std::getline(nin, line);
       Point<spatial_dimension> ne;
       ne.read(line);
       neighbors_map_read[pt].push_back(ne);
     }
   }
 }
 
 
 int main(int argc, char *argv[]) {
   initialize(argc, argv);
 
   const auto & comm = Communicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   std::string file_ref = "neighbors_ref_1_0";
   std::string file = "neighbors_ref";
   std::stringstream sstr; sstr << file << "_" << psize << "_" << prank;
   file = sstr.str();
 
   std::ifstream nin;
 
   neighbors_map_t<spatial_dimension>::type neighbors_map_read;
   nin.open(file_ref.c_str());
   readNeighbors(nin, neighbors_map_read);
   nin.close();
 
   neighbors_map_t<spatial_dimension>::type neighbors_map;
   nin.open(file.c_str());
   readNeighbors(nin, neighbors_map);
   nin.close();
 
   neighbors_map_t<spatial_dimension>::type::iterator it_n = neighbors_map.begin();
   neighbors_map_t<spatial_dimension>::type::iterator end_n = neighbors_map.end();
   for(;it_n != end_n; ++it_n) {
     std::sort(it_n->second.begin(), it_n->second.end());
 
     std::vector< Point<spatial_dimension> >::iterator it_v = it_n->second.begin();
     std::vector< Point<spatial_dimension> >::iterator end_v = it_n->second.end();
 
     neighbors_map_t<spatial_dimension>::type::iterator it_nr = neighbors_map_read.find(it_n->first);
     if(it_nr == neighbors_map_read.end())
-      AKANTU_DEBUG_ERROR("Argh what is this point that is not present in the ref file " << it_n->first);
+      AKANTU_ERROR("Argh what is this point that is not present in the ref file " << it_n->first);
 
     std::vector< Point<spatial_dimension> >::iterator it_vr = it_nr->second.begin();
     std::vector< Point<spatial_dimension> >::iterator end_vr = it_nr->second.end();
 
     for(;it_v != end_v && it_vr != end_vr; ++it_v, ++it_vr) {
-      if(*it_vr != *it_v) AKANTU_DEBUG_ERROR("Neighbors does not match " << *it_v << " != " << *it_vr
+      if(*it_vr != *it_v) AKANTU_ERROR("Neighbors does not match " << *it_v << " != " << *it_vr
                                              << " neighbor of " << it_n->first);
     }
 
     if(it_v == end_v && it_vr != end_vr) {
-      AKANTU_DEBUG_ERROR("Some neighbors of " << it_n->first << " are missing!");
+      AKANTU_ERROR("Some neighbors of " << it_n->first << " are missing!");
     }
 
     if(it_v != end_v && it_vr == end_vr)
-      AKANTU_DEBUG_ERROR("Some neighbors of " << it_n->first << " are in excess!");
+      AKANTU_ERROR("Some neighbors of " << it_n->first << " are in excess!");
   }
 
   akantu::finalize();
 
   return EXIT_SUCCESS;
 }