diff --git a/doc/manual/manual-feengine.tex b/doc/manual/manual-feengine.tex
index 415b15d1e..ef64c823e 100644
--- a/doc/manual/manual-feengine.tex
+++ b/doc/manual/manual-feengine.tex
@@ -1,75 +1,75 @@
 \chapter{FEEngine\index{FEEngine}}
 \label{chap:feengine}
 The \code{FEEngine} interface is dedicated to handle the
 finite-element approximations and the numerical integration of the
 weak form. As we will see in Chapter \ref{sect:smm}, \code{Model}
 creates its own \code{FEEngine} object so the explicit creation of the
 object is not required.
 
 \section{Mathematical Operations\label{sect:fe:mathop}}
 Using the \code{FEEngine} object, one can compute a interpolation, an
 integration or a gradient. A simple example is given below.
 
 \begin{cpp}
 // having a FEEngine object
 FEEngine *fem = new FEEngineTemplate<IntegratorGauss,ShapeLagrange>(my_mesh, 
                                                                     dim, 
                                                                     "my_fem");
 // instead of this, a FEEngine object can be get using the model: 
 // model.getFEEngine()
 
 //compute the gradient
 Array<Real> u; //append the values you want
 Array<Real> nablauq; //gradient array to be computed
 // compute the gradient
 fem->gradientOnIntegrationPoints(const Array<Real> &u,
 				 Array<Real> &nablauq,
 				 const UInt nb_degree_of_freedom,
 				 ElementType type);
 
 // interpolate
 Array<Real> uq; //interpolated array to be computed
 // compute the interpolation
 fem->interpolateOnIntegrationPoints(const Array<Real> &u,
                                     Array<Real> &uq,
                                     UInt nb_degree_of_freedom,
                                     ElementType type);
 
 // interpolated function can be integrated over the elements
 Array<Real> int_val_on_elem;
 // integrate
 fem->integrate(const Array<Real> &uq, 
                Array<Real> &int_uq, 
                UInt nb_degree_of_freedom,
                ElementType type);
 \end{cpp}
 
 Another example below shows how to integrate stress and strain fields
 over elements assigned to a particular material.
 
 \begin{cpp}
 UInt sp_dim = 3; //spatial dimension
 UInt m = 1; //material index of interest
 const ElementType type = _tetrahedron_4; //element type
 
 // get the stress and strain arrays associated to the material index m
 const Array<Real> & strain_vec = model.getMaterial(m).getGradU(type);
 const Array<Real> & stress_vec = model.getMaterial(m).getStress(type);
 
 // get the element filter for the material index
-const Array<UInt> & elem_filter = model.getMaterial(m).getElementFilter(type);
+const Array<Idx> & elem_filter = model.getMaterial(m).getElementFilter(type);
 
 // initialize the integrated stress and strain arrays
 Array<Real> int_strain_vec(elem_filter.getSize(), 
                            sp_dim*sp_dim, "int_of_strain");
 Array<Real> int_stress_vec(elem_filter.getSize(), 
                            sp_dim*sp_dim, "int_of_stress");
 
 // integrate the fields      
 model.getFEEngine().integrate(strain_vec, int_strain_vec, 
                               sp_dim*sp_dim, type, _not_ghost, elem_filter);
 model.getFEEngine().integrate(stress_vec, int_stress_vec, 
                               sp_dim*sp_dim, type, _not_ghost, elem_filter);
 \end{cpp}
 
 \input{manual-elements}
diff --git a/doc/manual/manual-gettingstarted.tex b/doc/manual/manual-gettingstarted.tex
index 383b48e38..573f19639 100644
--- a/doc/manual/manual-gettingstarted.tex
+++ b/doc/manual/manual-gettingstarted.tex
@@ -1,466 +1,466 @@
 \chapter{Getting Started}
 \section{Downloading the Code}
 
 The \akantu source code can be requested using the form accessible at the URL
 \url{http://lsms.epfl.ch/akantu}.  There, you will be asked to accept the LGPL
 license terms.
 
 \section{Compiling \akantu}
 
 \akantu is a \code{cmake} project, so to configure it, you can either
 follow the usual way:
 \begin{command}
   > cd akantu
   > mkdir build
   > cd build
   > ccmake ..
   [ Set the options that you need ]
   > make
   > make install
 \end{command}
 
 \noindent Or, use the \code{Makefile} we added for your convenience to
 handle the \code{cmake} configuration
 
 \begin{command}
   > cd akantu
   > make config
   > make
   > make install
 \end{command}
 
 \noindent All the \akantu options are documented in Appendix
 \ref{app:package-dependencies}.
 
 
 \section{Writing a \texttt{main} Function\label{sect:common:main}}
 \label{sec:writing_main}
 
 First of all, \akantu needs to be initialized.  The memory management
 included in the core library handles the correct allocation and
 de-allocation of vectors, structures and/or objects. Moreover, in
 parallel computations, the initialization procedure performs the
 communication setup. This is achieved by a pair of functions
 (\code{initialize} and \code{finalize}) that are used as follows:
 \begin{cpp}
 #include "aka_common.hh"
 #include "..."
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   initialize("input_file.dat", argc, argv);
 
   // your code
   ...
 
   finalize();
 }
 \end{cpp}
 The \code{initialize} function takes the text inpute file and the program
 parameters which can be parsed by \akantu in due form (see \ref{sect:parser}). 
 Obviously it is necessary to include all files needed in main. In this manual
 all provided code implies the usage of \code{akantu} as namespace.
 
 \section{Creating and Loading a Mesh\label{sect:common:mesh}}
 
 In its current state, \akantu supports three types of meshes: Gmsh~\cite{gmsh},
 Abaqus~\cite{abaqus} and Diana~\cite{diana}. Once a \code{Mesh} object is
 created with a given spatial dimension, it can be filled by reading a mesh input file.
 The method \code{read} of the class \code{Mesh} infers the mesh type from the file extension. If a non-standard file extension is used, the mesh type has to be specified.
 
 \begin{cpp}
 UInt spatial_dimension = 2;
 Mesh mesh(spatial_dimension);
 
 // Reading Gmsh files
 mesh.read("my_gmsh_mesh.msh");
 mesh.read("my_gmsh_mesh", _miot_gmsh);
 
 
 // Reading Abaqus files
 mesh.read("my_abaqus_mesh.inp");
 mesh.read("my_abaqus_mesh", _miot_abaqus);
 
 // Reading Diana files
 mesh.read("my_diana_mesh.dat");
 mesh.read("my_diana_mesh", _miot_diana);
 \end{cpp}
 
 The Gmsh reader adds the geometrical and physical tags as mesh data. The physical
 values are stored as a \code{UInt} data called \code{tag\_0}, if a string
 name is provided it is stored as a \code{std::string} data named
 \code{physical\_names}. The geometrical tag is stored as a \code{UInt} data named
 \code{tag\_1}.
 
 
 The Abaqus reader stores the \code{ELSET} in ElementGroups and the \code{NSET}
 in NodeGroups. The material assignment can be retrieved from the
 \code{std::string} mesh data named \code{abaqus\_material}.
 
 % \akantu supports meshes generated with Gmsh~\cite{gmsh}, a free
 % software available at \url{http://geuz.org/gmsh/} where a detailed
 % documentation can be found. Consequently, this manual will not provide
 % Gmsh usage directions. Gmsh outputs meshes in \code{.msh} format that can be read
 % by \akantu. In order to import a mesh, it is necessary to create
 % a \code{Mesh} object through the following function calls:
 % \begin{cpp}
 %   UInt spatial_dimension = 2;
 %   Mesh mesh(spatial_dimension);
 % \end{cpp}
 % The only parameter that has to be specified by the user is the spatial
 % dimension of the problem. Now it is possible to read a \code{.msh} file with
 % a \code{MeshIOMSH} object that takes care of loading a mesh to memory.
 % This step is carried out by:
 % \begin{cpp}
 %   mesh.read("square.msh");
 % \end{cpp}
 % where the \code{MeshIOMSH} object is first created before being
 % used to read the \code{.msh} file. The mesh file name as well as the \code{Mesh}
 % object must be specified by the user.
 
 % The \code{MeshIOMSH} object can also write mesh files. This feature
 % is useful to save a mesh that has been modified during a
 % simulation. The \code{write} method takes care of it:
 % \begin{cpp}
 %   mesh_io.write("square_modified.msh", mesh);
 % \end{cpp}
 % which works exactly like the \code{read} method.
 
 % \akantu supports also meshes generated by
 % DIANA (\url{http://tnodiana.com}), but only in reading mode. A similar
 % procedure applies where the only
 % difference is that the \code{MeshIODiana} object should be used
 % instead of the \code{MeshIOMSH} one. Additional mesh readers can be
 % introduced into \akantu by coding new \code{MeshIO} classes.
 
 \section{Using \texttt{Arrays}}
 
 Data in \akantu can be stored in data containers implemented by
 the \code{Array} class. In its most basic usage, the \code{Array} class
 implemented in \akantu is similar to the \code{vector} class of
 the Standard Template Library (STL) for C++. A simple \code{Array}
 containing a sequence of \code{nb\_element} values (of a given type) can be generated with:
 \begin{cpp}
   Array<type> example_array(nb_element);
 \end{cpp}
 where \code{type} usually is \code{Real}, \code{Int}, \code{UInt} or
 \code{bool}. Each value is associated to an index, so that data can be
 accessed by typing:
 
 \begin{cpp}
   auto & val = example_array(index)
 \end{cpp}
 
 \code{Arrays} can also contain tuples of values for each index. In
 that case, the number of components per tuple must be specified at the
 \code{Array} creation.  For example, if we want to create an
 \code{Array} to store the coordinates (sequences of three values) of
 ten nodes, the appropriate code is the following:
 \begin{cpp}
   UInt nb_nodes = 10;
   UInt spatial_dimension = 3;
 
   Array<Real> position(nb_nodes, spatial_dimension);
 \end{cpp}
 In this case the $x$ position of the eighth node number will be given by
 \code{position(7, 0)} (in C++, numbering starts at 0 and not
 1). If the number of components for the sequences is not specified, the
 default value of 1 is used.
 Here is a list of some basic operations that can be performed on \code{Array}:
 \begin{itemize}
   \item \code{resize(size)} change the size of the \code{Array}.
   \item \code{clear()} set all entries of the \code{Array} to zero.
   \item \code{set(t)} set all entries of the \code{Array} to \code{t}.
   \item \code{copy(const Array<T> $\&$ other)} copy another \code{Array} into the current one. The two \code{Array} should have the same number of components.
   \item \code{push$\_$back(tuple)} append a tuple with the correct number of components at the end of the \code{Array}.
   \item \code{erase(i) erase the value at the i-th position.}
   \item \code{find(value)} search \code{value} in the current \code{Array}. Return position index of the first occurence or $-1$ if not found.
   \item \code{storage()} Return the address of the allocated memory of the \code{Array}. 
 \end{itemize}
 
 \subsection{\texttt{Arrays} iterators}
 
 It is very common in \akantu to loop over arrays to perform a specific
 treatment. This ranges from geometric calculation on nodal quantities
 to tensor algebra (in constitutive laws for example).
 The \code{Array} object has the possibility to request iterators
 in order to make the writing of loops easier and enhance readability.
 For instance, a loop over the nodal coordinates can be performed like:
 \begin{cpp}
   //accessing the nodal coordinates Array (spatial_dimension components)
   const auto & nodes = mesh.getNodes();
 
   //creating the iterators
   auto it  = nodes.begin(spatial_dimension);
   auto end = nodes.end(spatial_dimension);
 
   for (; it != end; ++it){
     const auto & coords = (*it);
     //do what you need
     ....
 
   }
 \end{cpp}
 In that example, each \code{coords} is a \code{Vector<Real>} containing
 geometrical array of size \code{spatial\_dimension} and the iteration is
 conveniently performed by the \code{Array} iterator.
 
 With the switch to \code{c++14} this can be also written as
 \begin{cpp}
   //accessing the nodal coordinates Array (spatial_dimension components)
   const auto & nodes = mesh.getNodes();
 
   for (const auto & coords : make_view(nodes, spatial_dimension) {
     //do what you need
     ....
   }
 \end{cpp}
 
 The \code{Array} object is intensively used to store second order
 tensor values.  In that case, it should be specified that the returned
 object type is a matrix when constructing the iterator. This is done
 when calling the \code{begin} function. For instance, assuming that we
 have a \code{Array} storing stresses, we can loop over the stored
 tensors by:
 
 \begin{cpp}
   //creating the iterators
   auto it = stresses.begin(spatial_dimension, spatial_dimension);
   auto end = stresses.end(spatial_dimension, spatial_dimension);
 
   for (; it != end; ++it){
     Matrix<Real> & stress = (*it);
     //do what you need
     ....
   }
 \end{cpp}
 In that last example, the \code{Matrix} objects are
 \code{spatial\_dimension} $\times$ \code{spatial\_dimension} matrices.
 The light objects \code{Matrix} and \code{Vector} can be used and
 combined to do most common linear algebra. If the number of component
 is 1, it is possible to use a scalar\_iterator rather than the
 vector/matrix one.
 
 
 In general, a mesh consists of several kinds of elements.
 Consequently, the amount of data to be stored can differ for each
 element type.  The straightforward example is the connectivity array,
 namely the sequences of nodes belonging to each element (linear
 triangular elements have fewer nodes than, say, rectangular quadratic
 elements etc.).  A particular data structure called
 \code{ElementTypeMapArray} is provided to easily manage this kind of
 data.  It consists of a group of \code{Arrays}, each associated to an
 element type.  The following code can retrieve the
 \code{ElementTypeMapArray} which stores the connectivity arrays for a
 mesh:
 \begin{cpp}
-  const ElementTypeMapArray<UInt> & connectivities = mesh.getConnectivities();
+  const ElementTypeMapArray<Idx> & connectivities = mesh.getConnectivities();
 \end{cpp}
 Then, the specific array associated to a given element type can be obtained by
 \begin{cpp}
-  const Array<UInt> & connectivity_triangle = connectivities(_triangle_3);
+  const Array<Idx> & connectivity_triangle = connectivities(_triangle_3);
 \end{cpp}
 where the first order 3-node triangular element was used in the presented piece
 of code.
 
 \subsection{Vector \& Matrix}
 
 The \code{Array} iterators as presented in the previous section can be shaped as
 \code{Vector} or \code{Matrix}. This objects represent $1^{st}$ and $2^{nd}$
 order tensors. As such they come with some functionalities that we will present
 a bit more into detail in this here.
 
 \subsubsection{\texttt{Vector<T>}}
 
 \begin{enumerate}
 \item Accessors:
   \begin{itemize}
   \item \code{v(i)} gives the $i^{th}$ component of the vector \code{v}
   \item \code{v[i]} gives the $i^{th}$ component of the vector \code{v}
   \item \code{v.size()} gives the number of component
   \end{itemize}
 \item Level 1: (results are scalars)
   \begin{itemize}
   \item \code{v.norm()} returns the geometrical norm ($L_2$)
   \item \code{v.norm<N>()} returns the $L_N$ norm defined as $\left(\sum_i
     |\code{v(i)}|^N\right)^{1/N}$. N can take any positive
     integer value. There are also some particular values for the most commonly
     used norms, \code{L\_1} for the Manhattan norm, \code{L\_2} for the
     geometrical norm and \code{L\_inf} for the norm infinity.
   \item \code{v.dot(x)} return the dot product of \code{v} and \code{x}
   \item \code{v.distance(x)} return the geometrical norm of $\code{v} -
     \code{x}$
   \end{itemize}
 \item Level 2: (results are vectors)
   \begin{itemize}
   \item \code{v += s}, \code{v -= s}, \code{v *= s}, \code{v /= s} those are
     element-wise operators that sum, substract, multiply or divide all the
     component of \code{v} by the scalar \code{s}
   \item \code{v += x}, \code{v -= x} sums or substracts the vector \code{x}
     to/from \code{v}
   \item \code{v.mul(A, x, alpha)} stores the result of $\alpha \mat{A} \vec{x}$ in \code{v},
     $\alpha$ is equal to 1 by default
   \item \code{v.solve(A, b)} stores the result of the resolution of the system $\mat{A} \vec{x} =
     \vec{b}$ in \code{v}
   \item \code{v.crossProduct(v1, v2)} computes the cross product of \code{v1} and \code{v2} and
     stores the result in \code{v}
   \end{itemize}
 \end{enumerate}
 
 \subsubsection{\texttt{Matrix<T>}}
 \begin{enumerate}
 \item Accessors:
   \begin{itemize}
   \item \code{A(i, j)} gives the component $A_{ij}$ of the matrix \code{A}
   \item \code{A(i)} gives the $i^{th}$ column of the matrix as a \code{Vector}
   \item \code{A[k]} gives the $k^{th}$ component of the matrix, matrices are
     stored in a column major way, which means that to access $A_{ij}$, $k = i +
     j M$
   \item \code{A.rows()} gives the number of rows of \code{A} ($M$)
   \item \code{A.cols()} gives the number of columns of \code{A} ($N$)
   \item \code{A.size()} gives the number of component in the matrix ($M \times N$)
   \end{itemize}
 \item Level 1: (results are scalars)
 
   \begin{itemize}
   \item \code{A.norm()} is equivalent to \code{A.norm<L\_2>()}
   \item \code{A.norm<N>()} returns the $L_N$ norm defined as
     $\left(\sum_i\sum_j |\code{A(i,j)}|^N\right)^{1/N}$. N can take
     any positive integer value. There are also some particular values
     for the most commonly used norms, \code{L\_1} for the Manhattan
     norm, \code{L\_2} for the geometrical norm and \code{L\_inf} for
     the norm infinity.
   \item \code{A.trace()} return the trace of \code{A}
   \item \code{A.det()} return the determinant of \code{A}
   \item \code{A.doubleDot(B)} return the double dot product of \code{A} and
     \code{B}, $\mat{A}:\mat{B}$
   \end{itemize}
 \item Level 3: (results are matrices)
   \begin{itemize}
   \item \code{A.eye(s)}, \code{Matrix<T>::eye(s)} fills/creates a matrix with
     the $s\mat{I}$ with $\mat{I}$ the identity matrix
   \item \code{A.inverse(B)} stores $\mat{B}^{-1}$ in \code{A}
   \item \code{A.transpose()} returns  $\mat{A}^{t}$
   \item \code{A.outerProduct(v1, v2)} stores $\vec{v_1} \vec{v_2}^{t}$ in
     \code{A}
   \item \code{C.mul<t\_A, t\_B>(A, B, alpha)}: stores the result of the product of
     \code{A} and code{B} time the scalar \code{alpha} in \code{C}. \code{t\_A}
     and \code{t\_B} are boolean defining if \code{A} and \code{B} should be
     transposed or not.
 
     \begin{tabular}{ccl}
       \toprule
       \code{t\_A} & \code{t\_B} & result \\
       \midrule
       false & false & $\mat{C} = \alpha \mat{A} \mat{B}$\\
       false & true  & $\mat{C} = \alpha \mat{A} \mat{B}^t$\\
       true  & false & $\mat{C} = \alpha \mat{A}^t \mat{B}$\\
       true  & true  & $\mat{C} = \alpha \mat{A}^t \mat{B}^t$\\
       \bottomrule
     \end{tabular}
   \item \code{A.eigs(d, V)} this method computes the eigenvalues and
     eigenvectors of \code{A} and store the results in \code{d} and \code{V} such
     that $\code{d(i)} = \lambda_i$ and $\code{V(i)} = \vec{v_i}$ with
     $\mat{A}\vec{v_i} = \lambda_i\vec{v_i}$ and $\lambda_1 > ... > \lambda_i >
     ... > \lambda_N$
   \end{itemize}
 \end{enumerate}
 
 \subsubsection{\texttt{Tensor3<T>}}
 Accessors:
 \begin{itemize}
   \item \code{t(i, j, k)} gives the component $T_{ijk}$ of the tensor \code{t}
   \item \code{t(k)} gives the $k^{th}$ two-dimensional tensor as a \code{Matrix}
   \item \code{t[k]} gives the $k^{th}$ two-dimensional tensor as a \code{Matrix}
 \end{itemize}
 
 
 \section{Manipulating group of nodes and/or elements\label{sect:common:groups}}
 \akantu provides the possibility to manipulate
 subgroups of elements and nodes.
 Any \code{ElementGroup} and/or \code{NodeGroup} must be managed
 by a \code{GroupManager}. Such a manager has the role to
 associate group objects to names. This is a useful feature,
 in particular for the application of the boundary conditions,
 as will be demonstrated in section \ref{sect:smm:boundary}.
 To most general group manager is the \code{Mesh} class
 which inheritates from the \code{GroupManager} class.
 
 For instance, the following code shows how to request
 an element group to a mesh:
 
 \begin{cpp}
   // request creation of a group of nodes
   NodeGroup & my_node_group = mesh.createNodeGroup("my_node_group");
   // request creation of a group of elements
   ElementGroup & my_element_group = mesh.createElementGroup("my_element_group");
 
   /* fill and use the groups */
 \end{cpp}
 
 
 \subsection{The \texttt{NodeGroup} object}
 A group of nodes is stored in \code{NodeGroup} objects.
 They are quite simple objects which store the indexes
-of the selected nodes in a \code{Array<UInt>}.
+of the selected nodes in a \code{Array<Idx>}.
 Nodes are selected by adding them when calling
 \code{NodeGroup::add}. For instance you can select nodes
 having a positive $X$ coordinate with the following code:
 \begin{cpp}
   const auto & nodes = mesh.getNodes();
   auto & group = mesh.createNodeGroup("XpositiveNode");
 
   for (auto && data : enumerate(make_view(nodes, spatial_dimension))){
     auto node = std::get<0>(data);
     const auto & position = std::get<1>(data);
     if (position(0) > 0) group.add(node);
   }
 \end{cpp}
 
 \subsection{The \texttt{ElementGroup} object}
 A group of elements is stored in \code{ElementGroup} objects.
 Since a group can contain elements of various types
 the \code{ElementGroup} object stores indexes in
-a \code{ElementTypeMapArray<UInt>} object.
+a \code{ElementTypeMapArray<Idx>} object.
 Then elements can be added to the group by calling \code{addElement}.
 
 For instance, selecting the elements for which the barycenter of the nodes
 has a positive $X$ coordinate can be made with:
 
 \begin{cpp}
   auto & group = mesh.createElementGroup("XpositiveElement");
   Vector<Real> barycenter(spatial_dimension);
 
   for(auto type : mesh.elementTypes()){
     UInt nb_element  = mesh.getNbElement(type);
 
     for(UInt e = 0; e < nb_element; ++e) {
       Element element{type, e, _not_ghost};
 
       mesh.getBarycenter(element, barycenter);
       if (barycenter(_x) > 0.) group.add(element);
     }
   }
 \end{cpp}
 
 \section{Compiling your simulation}
 The easiest way to compile your simulation is to create a \code{cmake} project by putting all your code in some directory of your choosing. Then, make sure that you have \code{cmake} installed and create a \code{CMakeLists.txt} file. An example of a minimal \code{CMakeLists.txt} file would look like this:
 
 \begin{cmake}
   project(my_simu)
   cmake_minimum_required(VERSION 3.0.0)
 
   find_package(Akantu REQUIRED)
 
   add_akantu_simulation(my_simu my_simu.cc)
 \end{cmake}
 %
 Then create a directory called \code{build} and inside it execute \code{ccmake ..} which opens a configuration screen. If you installed \akantu in a standard directory such as \code{/usr/local} (using \code{make install}), you should be able to compile by hitting the \code{c} key, setting \code{CMAKE\textunderscore{}BUILD\textunderscore{}TYPE} to \code{Release}, hitting the \code{c} key again a few times and then finishing the configuration with the \code{g} key. After that, you can type \code{make} to build your simulation. If you change your simulation code later on, you only need to type \code{make} again.
 
 If you get an error that \code{FindAkantu.cmake} was not found, you have to set the \code{Akantu\textunderscore{}DIR} variable, which will appear after dismissing the error message. If you built \akantu without running \code{make install}, the variable should be set to the \code{build} subdirectory of the \akantu source code. If you installed it in \code{\$PREFIX}, set the variable to \code{\$PREFIX/share/cmake/Akantu} instead.
 
 %%% Local Variables:
 %%% mode: latex
 %%% TeX-master: "manual"
 %%% End:
diff --git a/examples/implicit/implicit_dynamic.cc b/examples/implicit/implicit_dynamic.cc
index 16ed54d00..593aeca26 100644
--- a/examples/implicit/implicit_dynamic.cc
+++ b/examples/implicit/implicit_dynamic.cc
@@ -1,151 +1,151 @@
 /**
  * @file   implicit_dynamic.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification: Fri Feb 28 2020
  *
  * @brief  Example of solid mechanics in implicit dynamic
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "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.getExternalForce();
   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 =
+  const Array<Idx> & trac_nodes =
       mesh.getElementGroup("traction").getNodeGroup().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_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("external_force");
   model.addDumpField("internal_force");
   model.dump();
 
   model.setTimeStep(time_step);
 
   auto & solver = model.getNonLinearSolver();
   solver.set("max_iterations", 100);
   solver.set("threshold", 1e-12);
   solver.set("convergence_type", SolveConvergenceCriteria::_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/examples/io/dumper/dumpable_interface.cc b/examples/io/dumper/dumpable_interface.cc
index fa5b6d2ea..41f7b92ea 100644
--- a/examples/io/dumper/dumpable_interface.cc
+++ b/examples/io/dumper/dumpable_interface.cc
@@ -1,191 +1,191 @@
 /**
  * @file   dumpable_interface.cc
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Aug 17 2015
  * @date last modification: Tue Sep 29 2020
  *
  * @brief  Example usnig the dumper interface directly
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "element_group.hh"
 #include "group_manager_inline_impl.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 #include "dumpable_inline_impl.hh"
 #include "dumper_iohelper_paraview.hh"
 /* -------------------------------------------------------------------------- */
 #include "locomotive_tools.hh"
 /* -------------------------------------------------------------------------- */
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
 
   /*
     In this example, we present dumpers::Dumpable which is an interface
     for other classes who want to dump themselves.
     Several classes of Akantu inheritate from Dumpable (Model, Mesh, ...).
     In this example we reproduce the same tasks as example_dumper_low_level.cc
     using this time Dumpable interface inherted by Mesh, NodeGroup and
     ElementGroup.
     It is then advised to read first example_dumper_low_level.cc.
   */
 
   initialize(argc, argv);
 
   // To start let us load the swiss train mesh and its mesh data information.
   UInt spatial_dimension = 2;
   Mesh mesh(spatial_dimension);
   mesh.read("swiss_train.msh");
 
   /*
     swiss_train.msh has the following physical groups that can be viewed with
     GMSH:
     "$MeshFormat
      2.2 0 8
      $EndMeshFormat
      $PhysicalNames
      6
      2 1 "red"
      2 2 "white"
      2 3 "lwheel_1"
      2 4 "lwheel_2"
      2 5 "rwheel_2"
      2 6 "rwheel_1"
      $EndPhysicalNames
      ..."
    */
 
   // Grouping nodes and elements belonging to train wheels (=four mesh data).
   ElementGroup & wheels_elements =
       mesh.createElementGroup("wheels", spatial_dimension);
   wheels_elements.append(mesh.getElementGroup("lwheel_1"));
   wheels_elements.append(mesh.getElementGroup("lwheel_2"));
   wheels_elements.append(mesh.getElementGroup("rwheel_1"));
   wheels_elements.append(mesh.getElementGroup("rwheel_2"));
 
-  const Array<UInt> & lnode_1 =
+  const Array<Idx> & lnode_1 =
       (mesh.getElementGroup("lwheel_1")).getNodeGroup().getNodes();
-  const Array<UInt> & lnode_2 =
+  const Array<Idx> & lnode_2 =
       (mesh.getElementGroup("lwheel_2")).getNodeGroup().getNodes();
-  const Array<UInt> & rnode_1 =
+  const Array<Idx> & rnode_1 =
       (mesh.getElementGroup("rwheel_1")).getNodeGroup().getNodes();
-  const Array<UInt> & rnode_2 =
+  const Array<Idx> & rnode_2 =
       (mesh.getElementGroup("rwheel_2")).getNodeGroup().getNodes();
 
   Array<Real> & node = mesh.getNodes();
   UInt nb_nodes = mesh.getNbNodes();
 
   // This time a 2D Array is created and a padding size of 3 is passed to
   // NodalField in order to warp train deformation on Paraview.
   Array<Real> displacement(nb_nodes, spatial_dimension);
 
   // Create an ElementTypeMapArray for the colour
   ElementTypeMapArray<UInt> colour("colour");
   colour.initialize(mesh, _with_nb_element = true);
 
   /* ------------------------------------------------------------------------ */
   /* Creating dumpers                                                         */
   /* ------------------------------------------------------------------------ */
 
   // Create dumper for the complete mesh and register it as default dumper.
   auto && dumper = std::make_shared<DumperParaview>("train", "./paraview/dumpable", false);
   mesh.registerExternalDumper(dumper, "train", true);
   mesh.addDumpMesh(mesh);
 
   // The dumper for the filtered mesh can be directly taken from the
   // ElementGroup and then registered as "wheels_elements" dumper.
   auto && wheels = mesh.getGroupDumper("paraview_wheels", "wheels");
 
   mesh.registerExternalDumper(wheels.shared_from_this(), "wheels");
   mesh.setDirectoryToDumper("wheels", "./paraview/dumpable");
 
   // Arrays and ElementTypeMapArrays can be added as external fields directly
   mesh.addDumpFieldExternal("displacement", displacement);
 
   ElementTypeMapArrayFilter<UInt> filtered_colour(
       colour, wheels_elements.getElements());
 
   auto colour_field_wheel =
       std::make_shared<dumpers::ElementalField<UInt, Vector, true>>(
           filtered_colour);
   mesh.addDumpFieldExternal("color", colour_field_wheel);
 
   mesh.addDumpFieldExternalToDumper("wheels", "displacement", displacement);
   mesh.addDumpFieldExternalToDumper("wheels", "colour", colour);
 
   // For some specific cases the Fields should be created, as when you want to
   // pad an array
   auto displacement_vector_field =
       mesh.createNodalField(&displacement, "all", 3);
   mesh.addDumpFieldExternal("displacement_as_paraview_vector",
                             displacement_vector_field);
   mesh.addDumpFieldExternalToDumper("wheels", "displacement_as_paraview_vector",
                                     displacement_vector_field);
 
   /* ------------------------------------------------------------------------ */
   /* ------------------------------------------------------------------------ */
 
   // Fill the ElementTypeMapArray colour.
   fillColour(mesh, colour);
 
   /// Apply displacement and wheels rotation.
   Real tot_displacement = 50.;
   Real radius = 1.;
   UInt nb_steps = 100;
   Real theta = tot_displacement / radius;
 
   Vector<Real> l_center(spatial_dimension);
   Vector<Real> r_center(spatial_dimension);
 
   for (UInt i = 0; i < spatial_dimension; ++i) {
     l_center(i) = node(14, i);
     r_center(i) = node(2, i);
   }
 
   for (UInt i = 0; i < nb_steps; ++i) {
     displacement.zero();
 
     Real step_ratio = Real(i) / Real(nb_steps);
     Real angle = step_ratio * theta;
 
     applyRotation(l_center, angle, node, displacement, lnode_1);
     applyRotation(l_center, angle, node, displacement, lnode_2);
     applyRotation(r_center, angle, node, displacement, rnode_1);
     applyRotation(r_center, angle, node, displacement, rnode_2);
 
     for (UInt j = 0; j < nb_nodes; ++j) {
       displacement(j, _x) += step_ratio * tot_displacement;
     }
     /// Dump call is finally made through Dumpable interface.
     mesh.dump();
     mesh.dump("wheels");
   }
 
   finalize();
 
   return 0;
 }
diff --git a/examples/io/dumper/dumper_low_level.cc b/examples/io/dumper/dumper_low_level.cc
index 820834668..1121dcadc 100644
--- a/examples/io/dumper/dumper_low_level.cc
+++ b/examples/io/dumper/dumper_low_level.cc
@@ -1,200 +1,200 @@
 /**
  * @file   dumper_low_level.cc
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Aug 17 2015
  * @date last modification: Tue Sep 29 2020
  *
  * @brief  Example using the low level dumper interface
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "element_group.hh"
 #include "group_manager.hh"
 #include "mesh.hh"
 
 #include "dumper_elemental_field.hh"
 #include "dumper_nodal_field.hh"
 
 #include "dumper_iohelper_paraview.hh"
 #include "locomotive_tools.hh"
 
 /* -------------------------------------------------------------------------- */
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
 
   /* This example aims at illustrating how to manipulate low-level methods of
      DumperIOHelper.
      The aims is to visualize a colorized moving train with Paraview */
 
   initialize(argc, argv);
 
   // To start let us load the swiss train mesh and its mesh data information.
   // We aknowledge here a weel-known swiss industry for mesh donation.
   UInt spatial_dimension = 2;
   Mesh mesh(spatial_dimension);
   mesh.read("swiss_train.msh");
 
   Array<Real> & nodes = mesh.getNodes();
   UInt nb_nodes = mesh.getNbNodes();
 
   /* swiss_train.msh has the following physical groups that can be viewed with
     GMSH:
     "$MeshFormat
      2.2 0 8
      $EndMeshFormat
      $PhysicalNames
      6
      2 1 "red"
      2 2 "white"
      2 3 "lwheel_1"
      2 4 "lwheel_2"
      2 5 "rwheel_2"
      2 6 "rwheel_1"
      $EndPhysicalNames
      ..."
    */
 
   // Grouping nodes and elements belonging to train wheels (=four mesh data)
   ElementGroup & wheels_elements =
       mesh.createElementGroup("wheels", spatial_dimension);
   wheels_elements.append(mesh.getElementGroup("lwheel_1"));
   wheels_elements.append(mesh.getElementGroup("lwheel_2"));
   wheels_elements.append(mesh.getElementGroup("rwheel_1"));
   wheels_elements.append(mesh.getElementGroup("rwheel_2"));
 
-  const Array<UInt> & lnode_1 =
+  const Array<Idx> & lnode_1 =
       (mesh.getElementGroup("lwheel_1")).getNodeGroup().getNodes();
-  const Array<UInt> & lnode_2 =
+  const Array<Idx> & lnode_2 =
       (mesh.getElementGroup("lwheel_2")).getNodeGroup().getNodes();
-  const Array<UInt> & rnode_1 =
+  const Array<Idx> & rnode_1 =
       (mesh.getElementGroup("rwheel_1")).getNodeGroup().getNodes();
-  const Array<UInt> & rnode_2 =
+  const Array<Idx> & rnode_2 =
       (mesh.getElementGroup("rwheel_2")).getNodeGroup().getNodes();
 
   /* Note this Array is constructed with three components in order to warp train
      deformation on Paraview. A more appropriate way to do this is to set a
      padding in the NodalField (See example_dumpable_interface.cc.) */
   Array<Real> displacement(nb_nodes, 3);
 
   // ElementalField are constructed with an ElementTypeMapArray.
   ElementTypeMapArray<UInt> colour;
   colour.initialize(mesh, _with_nb_element = true);
 
   /* ------------------------------------------------------------------------ */
   /* Dumper creation                                                          */
   /* ------------------------------------------------------------------------ */
 
   // Creation of two DumperParaview. One for full mesh, one for a filtered
   // mesh.
   DumperParaview dumper("train", "./paraview/dumper", false);
   DumperParaview wheels("wheels", "./paraview/dumper", false);
 
   // Register the full mesh
   dumper.registerMesh(mesh);
 
   // Register a filtered mesh limited to nodes and elements from wheels groups
   wheels.registerFilteredMesh(mesh, wheels_elements.getElements(),
                               wheels_elements.getNodeGroup().getNodes());
 
   // Generate an output file of the two mesh registered.
   dumper.dump();
   wheels.dump();
 
   /* At this stage no fields are attached to the two dumpers.  To do so, a
      dumpers::Field object has to be created.  Several types of dumpers::Field
      exist. In this example we present two of them.
 
      NodalField to describe nodal displacements of our train.
      ElementalField handling the color of our different part.
   */
 
   // NodalField are constructed with an Array.
   auto displ_field = std::make_shared<dumpers::NodalField<Real>>(displacement);
   auto colour_field = std::make_shared<dumpers::ElementalField<UInt>>(colour);
 
   // Register the freshly created fields to our dumper.
   dumper.registerField("displacement", displ_field);
   dumper.registerField("colour", colour_field);
 
   // For the dumper wheels, fields have to be filtered at registration.
   // Filtered NodalField can be simply registered by adding an Array<UInt>
   // listing the nodes.
   auto displ_field_wheel = std::make_shared<dumpers::NodalField<Real, true>>(
       displacement, 0, 0, &(wheels_elements.getNodeGroup().getNodes()));
   wheels.registerField("displacement", displ_field_wheel);
 
   // For the ElementalField, an ElementTypeMapArrayFilter has to be created.
   ElementTypeMapArrayFilter<UInt> filtered_colour(
       colour, wheels_elements.getElements());
 
   auto colour_field_wheel =
       std::make_shared<dumpers::ElementalField<UInt, Vector, true>>(
           filtered_colour);
   wheels.registerField("colour", colour_field_wheel);
 
   /* ------------------------------------------------------------------------ */
   // Now that the dumpers are created and the fields are associated, let's
   // paint and move the train!
 
   // Fill the ElementTypeMapArray colour according to mesh data information.
   fillColour(mesh, colour);
 
   // Apply displacement and wheels rotation.
   Real tot_displacement = 50.;
   Real radius = 1.;
   UInt nb_steps = 100;
   Real theta = tot_displacement / radius;
 
   Vector<Real> l_center(3);
   Vector<Real> r_center(3);
 
   for (UInt i = 0; i < spatial_dimension; ++i) {
     l_center(i) = nodes(14, i);
     r_center(i) = nodes(2, i);
   }
 
   for (UInt i = 0; i < nb_steps; ++i) {
     displacement.zero();
 
     Real angle = (Real)i / (Real)nb_steps * theta;
     applyRotation(l_center, angle, nodes, displacement, lnode_1);
     applyRotation(l_center, angle, nodes, displacement, lnode_2);
     applyRotation(r_center, angle, nodes, displacement, rnode_1);
     applyRotation(r_center, angle, nodes, displacement, rnode_2);
 
     for (UInt j = 0; j < nb_nodes; ++j) {
       displacement(j, 0) += (Real)i / (Real)nb_steps * tot_displacement;
     }
     // Output results after each moving steps for main and wheel dumpers.
     dumper.dump();
     wheels.dump();
   }
 
   finalize();
 
   return 0;
 }
diff --git a/examples/io/dumper/locomotive_tools.cc b/examples/io/dumper/locomotive_tools.cc
index bc550fdfa..e5b26bf99 100644
--- a/examples/io/dumper/locomotive_tools.cc
+++ b/examples/io/dumper/locomotive_tools.cc
@@ -1,92 +1,92 @@
 /**
  * @file   locomotive_tools.cc
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  *
  * @date creation: Mon Aug 17 2015
  * @date last modification: Fri Feb 28 2020
  *
  * @brief  Small helper code for the dumper examples
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 #include "locomotive_tools.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 void applyRotation(const Vector<Real> & center, Real angle,
                    const Array<Real> & nodes, Array<Real> & displacement,
-                   const Array<UInt> & node_group) {
+                   const Array<Idx> & node_group) {
   auto nodes_it = nodes.begin(nodes.getNbComponent());
   auto disp_it = displacement.begin(center.size());
-  Array<UInt>::const_scalar_iterator node_num_it = node_group.begin();
-  Array<UInt>::const_scalar_iterator node_num_end = node_group.end();
+  Array<Idx>::const_scalar_iterator node_num_it = node_group.begin();
+  Array<Idx>::const_scalar_iterator node_num_end = node_group.end();
 
   Vector<Real> pos_rel(center.size());
 
   for (; node_num_it != node_num_end; ++node_num_it) {
     const Vector<Real> pos = nodes_it[*node_num_it];
     for (UInt i = 0; i < pos.size(); ++i)
       pos_rel(i) = pos(i);
 
     Vector<Real> dis = disp_it[*node_num_it];
 
     pos_rel -= center;
     Real radius = pos_rel.norm();
 
     if (std::abs(radius) < Math::getTolerance())
       continue;
 
     Real phi_i = std::acos(pos_rel(_x) / radius);
     if (pos_rel(_y) < 0)
       phi_i *= -1;
 
     dis(_x) = std::cos(phi_i - angle) * radius - pos_rel(_x);
     dis(_y) = std::sin(phi_i - angle) * radius - pos_rel(_y);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void fillColour(const Mesh & mesh, ElementTypeMapArray<UInt> & colour) {
   const ElementTypeMapArray<std::string> & phys_data =
       mesh.getData<std::string>("physical_names");
   const Array<std::string> & txt_colour = phys_data(_triangle_3);
   Array<UInt> & id_colour = colour(_triangle_3);
 
   for (UInt i = 0; i < txt_colour.size(); ++i) {
     std::string phy_name = txt_colour(i);
 
     if (phy_name == "red")
       id_colour(i) = 3;
     else if (phy_name == "white" || phy_name == "lwheel_1" ||
              phy_name == "rwheel_1")
       id_colour(i) = 2;
     else
       id_colour(i) = 1;
   }
 }
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 87262a9f1..3b22858f2 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,602 +1,602 @@
 /**
  * @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
  *
  *
  * 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 "non_local_manager.hh"
 #include "parser.hh"
 #include "sparse_matrix.hh"
 /* -------------------------------------------------------------------------- */
 #include <string>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 SolidMechanicsModelRVE::SolidMechanicsModelRVE(Mesh & mesh,
                                                bool use_RVE_mat_selector,
                                                UInt nb_gel_pockets, UInt dim,
                                                const ID & id)
     : SolidMechanicsModel(mesh, dim, 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->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->addDumpField("delta_T");
 
   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::applyHomogeneousTemperature(
     const Real & temperature) {
 
   for (UInt m = 0; m < this->getNbMaterials(); ++m) {
     Material & mat = this->getMaterial(m);
 
-    const ElementTypeMapArray<UInt> & filter_map = mat.getElementFilter();
+    const ElementTypeMapArray<Idx> & filter_map = mat.getElementFilter();
 
     // Loop over all element types
     for (auto && type : filter_map.elementTypes(spatial_dimension)) {
-      const Array<UInt> & filter = filter_map(type);
+      const Array<Idx> & filter = filter_map(type);
       if (filter.size() == 0)
         continue;
 
       Array<Real> & delta_T = mat.getArray<Real>("delta_T", type);
       Array<Real>::scalar_iterator delta_T_it = delta_T.begin();
       Array<Real>::scalar_iterator delta_T_end = delta_T.end();
 
       for (; delta_T_it != delta_T_end; ++delta_T_it) {
         *delta_T_it = temperature;
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 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_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(spatial_dimension, _not_ghost, _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", SolveConvergenceCriteria::_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;
 
   GhostType gt = _not_ghost;
   for (auto element_type :
        mesh.elementTypes(spatial_dimension, gt, _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_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.zero();
   H(1, 1) = 0.01;
   this->performVirtualTesting(H, stresses, strains, 1);
 
   /// virtual test 3:
   H.zero();
   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", SolveConvergenceCriteria::_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;
   }
 
   this->assignMaterialToElements();
   // synchronize the element material arrays
   this->synchronize(SynchronizationTag::_material_id);
 
   for (auto & material : materials) {
     /// init internals properties
     const auto type = material->getID();
     if (type.find("material_FE2") != std::string::npos)
       continue;
     material->initMaterial();
   }
 
   this->synchronize(SynchronizationTag::_smm_init_mat);
 
   if (this->non_local_manager) {
     this->non_local_manager->initialize();
   }
   // 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_FE2/solid_mechanics_model_RVE.hh b/extra_packages/extra-materials/src/material_FE2/solid_mechanics_model_RVE.hh
index 771229c53..516b25e59 100644
--- a/extra_packages/extra-materials/src/material_FE2/solid_mechanics_model_RVE.hh
+++ b/extra_packages/extra-materials/src/material_FE2/solid_mechanics_model_RVE.hh
@@ -1,231 +1,231 @@
 /**
  * @file   solid_mechanics_model_RVE.hh
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @date   Wed Jan 13 14:54:18 2016
  *
  * @brief  SMM for RVE computations in FE2 simulations
  *
  *
  * 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_SOLID_MECHANICS_MODEL_RVE_HH_
 #define AKANTU_SOLID_MECHANICS_MODEL_RVE_HH_
 
 /* -------------------------------------------------------------------------- */
 #include "aka_grid_dynamic.hh"
 #include "solid_mechanics_model.hh"
 #include <unordered_set>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 class SolidMechanicsModelRVE : public SolidMechanicsModel {
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
   SolidMechanicsModelRVE(Mesh & mesh, bool use_RVE_mat_selector = true,
                          UInt nb_gel_pockets = 400,
                          UInt spatial_dimension = _all_dimensions,
                          const ID & id = "solid_mechanics_model");
 
   virtual ~SolidMechanicsModelRVE();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 protected:
   void initFullImpl(const ModelOptions & option) override;
 
   /// initialize the materials
   void initMaterials() override;
 
 public:
   /// apply boundary contions based on macroscopic deformation gradient
   virtual void
   applyBoundaryConditions(const Matrix<Real> & displacement_gradient);
 
   /// apply homogeneous temperature field from the macroscale level to the RVEs
   virtual void applyHomogeneousTemperature(const Real & temperature);
 
   /// advance the reactions -> grow gel and apply homogenized properties
   void advanceASR(const Matrix<Real> & prestrain);
 
   /// compute average stress or strain in the model
   Real averageTensorField(UInt row_index, UInt col_index,
                           const ID & field_type);
 
   /// compute effective stiffness of the RVE
   void homogenizeStiffness(Matrix<Real> & C_macro);
 
   /// compute average eigenstrain
   void homogenizeEigenGradU(Matrix<Real> & eigen_gradu_macro);
 
   /* ------------------------------------------------------------------------ */
   /* Data Accessor inherited members                                          */
   /* ------------------------------------------------------------------------ */
 
   inline void unpackData(CommunicationBuffer & buffer,
-                         const Array<UInt> & index,
+                         const Array<Idx> & index,
                          const SynchronizationTag & tag) override;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors */
   /* ------------------------------------------------------------------------ */
 public:
-  AKANTU_GET_MACRO(CornerNodes, corner_nodes, const Array<UInt> &);
+  AKANTU_GET_MACRO(CornerNodes, corner_nodes, const Array<Idx> &);
   AKANTU_GET_MACRO(Volume, volume, Real);
 
 private:
   /// find the corner nodes
   void findCornerNodes();
 
   /// perform virtual testing
   void performVirtualTesting(const Matrix<Real> & H,
                              Matrix<Real> & eff_stresses,
                              Matrix<Real> & eff_strains, const UInt test_no);
 
   void fillCracks(ElementTypeMapReal & saved_damage);
   void drainCracks(const ElementTypeMapReal & saved_damage);
   /* ------------------------------------------------------------------------ */
   /* Members */
   /* ------------------------------------------------------------------------ */
 
   /// volume of the RVE
   Real volume;
 
   /// corner nodes 1, 2, 3, 4 (see Leonardo's thesis, page 98)
-  Array<UInt> corner_nodes;
+  Array<Idx> corner_nodes;
 
   /// bottom nodes
   std::unordered_set<UInt> bottom_nodes;
 
   /// left nodes
   std::unordered_set<UInt> left_nodes;
 
   /// standard mat selector or user one
   bool use_RVE_mat_selector;
 
   /// the number of gel pockets inside the RVE
   UInt nb_gel_pockets;
 
   /// dump counter
   UInt nb_dumps;
 };
 
 inline void SolidMechanicsModelRVE::unpackData(CommunicationBuffer & buffer,
-                                               const Array<UInt> & index,
+                                               const Array<Idx> & index,
                                                const SynchronizationTag & tag) {
   SolidMechanicsModel::unpackData(buffer, index, tag);
 
   //  if (tag == SynchronizationTag::_smm_uv) {
   //    auto disp_it = displacement->begin(spatial_dimension);
   //
   //    for (auto node : index) {
   //      Vector<Real> current_disp(disp_it[node]);
   //
   //      // if node is at the bottom, u_bottom = u_top +u_2 -u_3
   //      if (bottom_nodes.count(node)) {
   //        current_disp += Vector<Real>(disp_it[corner_nodes(1)]);
   //        current_disp -= Vector<Real>(disp_it[corner_nodes(2)]);
   //      }
   //      // if node is at the left, u_left = u_right +u_4 -u_3
   //      else if (left_nodes.count(node)) {
   //        current_disp += Vector<Real>(disp_it[corner_nodes(3)]);
   //        current_disp -= Vector<Real>(disp_it[corner_nodes(2)]);
   //      }
   //    }
   //  }
 }
 
 /* -------------------------------------------------------------------------- */
 /* ASR material selector                                                      */
 /* -------------------------------------------------------------------------- */
 class GelMaterialSelector : public MeshDataMaterialSelector<std::string> {
 public:
   GelMaterialSelector(SolidMechanicsModel & model, const Real box_size,
                       const std::string & gel_material,
                       const UInt nb_gel_pockets, Real /*tolerance*/ = 0.)
       : MeshDataMaterialSelector<std::string>("physical_names", model),
         model(model), gel_material(gel_material),
         nb_gel_pockets(nb_gel_pockets), nb_placed_gel_pockets(0),
         box_size(box_size) {
     Mesh & mesh = this->model.getMesh();
     UInt spatial_dimension = model.getSpatialDimension();
     Element el{_triangle_3, 0, _not_ghost};
     UInt nb_element = mesh.getNbElement(el.type, el.ghost_type);
     Array<Real> barycenter(nb_element, spatial_dimension);
 
     for (auto && data : enumerate(make_view(barycenter, spatial_dimension))) {
       el.element = std::get<0>(data);
       auto & bary = std::get<1>(data);
       mesh.getBarycenter(el, bary);
     }
 
     /// generate the gel pockets
     srand(0.);
     Vector<Real> center(spatial_dimension);
     UInt placed_gel_pockets = 0;
     std::set<int> checked_baries;
     while (placed_gel_pockets != nb_gel_pockets) {
       /// get a random bary center
       UInt bary_id = rand() % nb_element;
       if (checked_baries.find(bary_id) != checked_baries.end())
         continue;
       checked_baries.insert(bary_id);
       el.element = bary_id;
       if (MeshDataMaterialSelector<std::string>::operator()(el) == 1)
         continue; /// element belongs to paste
       gel_pockets.push_back(el);
       placed_gel_pockets += 1;
     }
   }
 
   UInt operator()(const Element & elem) {
     UInt temp_index = MeshDataMaterialSelector<std::string>::operator()(elem);
     if (temp_index == 1)
       return temp_index;
     std::vector<Element>::const_iterator iit = gel_pockets.begin();
     std::vector<Element>::const_iterator eit = gel_pockets.end();
     if (std::find(iit, eit, elem) != eit) {
       nb_placed_gel_pockets += 1;
       std::cout << nb_placed_gel_pockets << " gelpockets placed" << std::endl;
       return model.getMaterialIndex(gel_material);
       ;
     }
     return 0;
   }
 
 protected:
   SolidMechanicsModel & model;
   std::string gel_material;
   std::vector<Element> gel_pockets;
   UInt nb_gel_pockets;
   UInt nb_placed_gel_pockets;
   Real box_size;
 };
 
 } // namespace akantu
 
 ///#include "material_selector_tmpl.hh"
 
 #endif /* AKANTU_SOLID_MECHANICS_MODEL_RVE_HH_ */
diff --git a/extra_packages/extra-materials/src/material_damage/material_brittle.cc b/extra_packages/extra-materials/src/material_damage/material_brittle.cc
index 70011de6f..4ca218474 100644
--- a/extra_packages/extra-materials/src/material_damage/material_brittle.cc
+++ b/extra_packages/extra-materials/src/material_damage/material_brittle.cc
@@ -1,123 +1,123 @@
 /**
  * @file   material_brittle.cc
  *
  * @author Aranda Ruiz Josue <josue.arandaruiz@epfl.ch>
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  *
  *
  * @brief  Specialization of the material class for the brittle material
  *
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "material_brittle.hh"
 #include "solid_mechanics_model.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 MaterialBrittle<spatial_dimension>::MaterialBrittle(SolidMechanicsModel & model,
                                                     const ID & id)
     : MaterialDamage<spatial_dimension>(model, id),
       strain_rate_brittle("strain_rate_brittle", *this) {
   AKANTU_DEBUG_IN();
 
   this->registerParam("S_0", S_0, 157e6, _pat_parsable | _pat_modifiable);
   this->registerParam("E_0", E_0, 27e3, _pat_parsable, "Strain rate threshold");
   this->registerParam("A", A, 1.622e-5, _pat_parsable,
                       "Polynome cubic constant");
   this->registerParam("B", B, -1.3274, _pat_parsable,
                       "Polynome quadratic constant");
   this->registerParam("C", C, 3.6544e4, _pat_parsable,
                       "Polynome linear constant");
   this->registerParam("D", D, -181.38e6, _pat_parsable, "Polynome constant");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialBrittle<spatial_dimension>::initMaterial() {
   AKANTU_DEBUG_IN();
   MaterialDamage<spatial_dimension>::initMaterial();
 
   this->strain_rate_brittle.initialize(spatial_dimension * spatial_dimension);
 
   updateInternalParameters();
 
   // this->Yd.resize();
   // const Mesh & mesh = this->model.getFEEngine().getMesh();
 
   // Mesh::type_iterator it = mesh.firstType(spatial_dimension);
   // Mesh::type_iterator last_type = mesh.lastType(spatial_dimension);
 
   // for(; it != last_type; ++it) {
   //   UInt nb_element  = this->element_filter(*it).getSize();
   //   UInt nb_quad = this->model.getFEEngine().getNbQuadraturePoints(*it);
 
   //   Array <Real> & Yd_rand_vec = Yd_rand(*it);
   //   for(UInt e = 0; e < nb_element; ++e) {
   //     Real rand_part = (2 * drand48()-1) * Yd_randomness * Yd;
 
   //     for(UInt q = 0; q < nb_quad; ++q)
   //    Yd_rand_vec(nb_quad*e+q,0) = Yd + rand_part;
   //   }
   // }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialBrittle<spatial_dimension>::updateInternalParameters() {
   MaterialDamage<spatial_dimension>::updateInternalParameters();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialBrittle<spatial_dimension>::computeStress(ElementType el_type,
                                                        GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Real * dam = this->damage(el_type, ghost_type).storage();
 
   Array<Real> & velocity = this->model.getVelocity();
   Array<Real> & strain_rate_brittle =
       this->strain_rate_brittle(el_type, ghost_type);
-  Array<UInt> & elem_filter = this->element_filter(el_type, ghost_type);
+  Array<Idx> & elem_filter = this->element_filter(el_type, ghost_type);
 
   this->model.getFEEngine().gradientOnIntegrationPoints(
       velocity, strain_rate_brittle, spatial_dimension, el_type, ghost_type,
       elem_filter);
 
   Array<Real>::iterator<Matrix<Real>> strain_rate_it =
       this->strain_rate_brittle(el_type, ghost_type)
           .begin(spatial_dimension, spatial_dimension);
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
 
   Real sigma_equivalent = 0;
   Real fracture_stress = 0;
   Matrix<Real> & grad_v = *strain_rate_it;
 
   computeStressOnQuad(grad_u, grad_v, sigma, *dam, sigma_equivalent,
                       fracture_stress);
 
   ++strain_rate_it;
   ++dam;
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 INSTANTIATE_MATERIAL(brittle, MaterialBrittle);
 
 } // namespace akantu
diff --git a/extra_packages/extra-materials/src/material_damage/material_brittle_non_local_inline_impl.hh b/extra_packages/extra-materials/src/material_damage/material_brittle_non_local_inline_impl.hh
index 8790b4350..8c164010c 100644
--- a/extra_packages/extra-materials/src/material_damage/material_brittle_non_local_inline_impl.hh
+++ b/extra_packages/extra-materials/src/material_damage/material_brittle_non_local_inline_impl.hh
@@ -1,116 +1,116 @@
 /**
  * @file   material_brittle_non_local_inline_impl.hh
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  *
  *
  * @brief  MaterialBrittleNonLocal inline function implementation
  *
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
 
 #if defined(AKANTU_DEBUG_TOOLS)
 #include "aka_debug_tools.hh"
 #include <string>
 #endif
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 MaterialBrittleNonLocal<spatial_dimension>::MaterialBrittleNonLocal(
     SolidMechanicsModel & model, const ID & id)
     : Material(model, id), MaterialBrittleNonLocalParent(model, id),
       Sigma_max("Sigma max", *this), Sigma_maxnl("Sigma_max non local", *this),
       Sigma_fracture("Sigma_fracture", *this) {
   AKANTU_DEBUG_IN();
   this->is_non_local = true;
   this->Sigma_max.initialize(1);
   this->Sigma_maxnl.initialize(1);
   this->Sigma_fracture.initialize(1);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialBrittleNonLocal<spatial_dimension>::initMaterial() {
   AKANTU_DEBUG_IN();
   this->model.getNonLocalManager().registerNonLocalVariable(
       this->Sigma_max.getName(), Sigma_maxnl.getName(), 1);
   MaterialBrittleNonLocalParent::initMaterial();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialBrittleNonLocal<spatial_dimension>::computeStress(
     ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Real * dam = this->damage(el_type, ghost_type).storage();
   Real * Sigma_maxt = this->Sigma_max(el_type, ghost_type).storage();
   Real * fracture_stress = this->Sigma_fracture(el_type, ghost_type).storage();
 
   Array<Real> & velocity = this->model.getVelocity();
   Array<Real> & strain_rate_brittle =
       this->strain_rate_brittle(el_type, ghost_type);
-  Array<UInt> & elem_filter = this->element_filter(el_type, ghost_type);
+  Array<Idx> & elem_filter = this->element_filter(el_type, ghost_type);
 
   this->model.getFEEngine().gradientOnIntegrationPoints(
       velocity, strain_rate_brittle, spatial_dimension, el_type, ghost_type,
       elem_filter);
 
   Array<Real>::iterator<Matrix<Real>> strain_rate_it =
       this->strain_rate_brittle(el_type, ghost_type)
           .begin(spatial_dimension, spatial_dimension);
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
 
   Matrix<Real> & grad_v = *strain_rate_it;
 
   MaterialBrittle<spatial_dimension>::computeStressOnQuad(
       grad_u, grad_v, sigma, *dam, *Sigma_maxt, *fracture_stress);
   ++dam;
   ++strain_rate_it;
   ++Sigma_maxt;
   ++fracture_stress;
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialBrittleNonLocal<spatial_dimension>::computeNonLocalStress(
     ElementType type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Real * dam = this->damage(type, ghost_type).storage();
   Real * Sigma_maxnlt = this->Sigma_maxnl(type, ghost_type).storage();
   Real * fracture_stress = this->Sigma_fracture(type, ghost_type).storage();
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(type, ghost_type);
   this->computeDamageAndStressOnQuad(sigma, *dam, *Sigma_maxnlt,
                                      *fracture_stress);
 
   ++dam;
   ++Sigma_maxnlt;
   ++fracture_stress;
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialBrittleNonLocal<
     spatial_dimension>::nonLocalVariableToNeighborhood() {
   this->model.getNonLocalManager().nonLocalVariableToNeighborhood(
       Sigma_maxnl.getName(), this->name);
 }
diff --git a/extra_packages/extra-materials/src/material_damage/material_vreepeerlings_tmpl.hh b/extra_packages/extra-materials/src/material_damage/material_vreepeerlings_tmpl.hh
index 2becb9bf1..579f68e9f 100644
--- a/extra_packages/extra-materials/src/material_damage/material_vreepeerlings_tmpl.hh
+++ b/extra_packages/extra-materials/src/material_damage/material_vreepeerlings_tmpl.hh
@@ -1,106 +1,106 @@
 /**
  * @file   material_vreepeerlings_tmpl.hh
  *
  * @author Cyprien Wolff <cyprien.wolff@epfl.ch>
  *
  *
  * @brief  Specialization of the material class for the VreePeerlings material
  *
  *
  * 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>
 MaterialVreePeerlings<spatial_dimension, MatParent>::MaterialVreePeerlings(
     SolidMechanicsModel & model, const ID & id)
     : Material(model, id), MaterialVreePeerlingsParent(model, id),
       Kapa("Kapa", *this),
       strain_rate_vreepeerlings("strain-rate-vreepeerlings", *this),
       Full_dam_value_strain("fulldam-valstrain", *this),
       Full_dam_value_strain_rate("fulldam-valstrain-rate", *this),
       Number_damage("number-damage", *this), equi_strain("equi-strain", *this),
       equi_strain_rate("equi-strain-rate", *this) {
   AKANTU_DEBUG_IN();
 
   this->registerParam("Kapaoi", Kapaoi, 0.0001, _pat_parsable);
   this->registerParam("Kapac", Kapac, 0.0002, _pat_parsable);
   this->registerParam("Arate", Arate, 0., _pat_parsable);
   this->registerParam("Brate", Brate, 1., _pat_parsable);
   this->registerParam("Crate", Brate, 1., _pat_parsable);
   this->registerParam("Kct", Kct, 1., _pat_parsable);
   this->registerParam("Kapao_randomness", Kapao_randomness, 0., _pat_parsable);
 
   this->Kapa.initialize(1);
   this->equi_strain.initialize(1);
   this->equi_strain_rate.initialize(1);
   this->Full_dam_value_strain.initialize(1);
   this->Full_dam_value_strain_rate.initialize(1);
   this->Number_damage.initialize(1);
   this->strain_rate_vreepeerlings.initialize(spatial_dimension *
                                              spatial_dimension);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension, template <UInt> class MatParent>
 void MaterialVreePeerlings<spatial_dimension, MatParent>::initMaterial() {
   AKANTU_DEBUG_IN();
   MaterialVreePeerlingsParent::initMaterial();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension, template <UInt> class MatParent>
 void MaterialVreePeerlings<spatial_dimension, MatParent>::computeStress(
     ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   MaterialVreePeerlingsParent::computeStress(el_type, ghost_type);
 
   Real * dam = this->damage(el_type, ghost_type).storage();
   Real * equi_straint = equi_strain(el_type, ghost_type).storage();
   Real * equi_straint_rate = equi_strain_rate(el_type, ghost_type).storage();
   Real * Kapaq = Kapa(el_type, ghost_type).storage();
   Real * FullDam_Valstrain =
       Full_dam_value_strain(el_type, ghost_type).storage();
   Real * FullDam_Valstrain_rate =
       Full_dam_value_strain_rate(el_type, ghost_type).storage();
   Real * Nb_damage = Number_damage(el_type, ghost_type).storage();
   Real dt = this->model.getTimeStep();
 
-  Array<UInt> & elem_filter = this->element_filter(el_type, ghost_type);
+  Array<Idx> & elem_filter = this->element_filter(el_type, ghost_type);
   Array<Real> & velocity = this->model.getVelocity();
   Array<Real> & strain_rate_vrplgs =
       this->strain_rate_vreepeerlings(el_type, ghost_type);
 
   this->model.getFEEngine().gradientOnIntegrationPoints(
       velocity, strain_rate_vrplgs, spatial_dimension, el_type, ghost_type,
       elem_filter);
 
   Array<Real>::matrix_iterator strain_rate_vrplgs_it =
       strain_rate_vrplgs.begin(spatial_dimension, spatial_dimension);
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
 
   Matrix<Real> & strain_rate = *strain_rate_vrplgs_it;
 
   computeStressOnQuad(grad_u, sigma, *dam, *equi_straint, *equi_straint_rate,
                       *Kapaq, dt, strain_rate, *FullDam_Valstrain,
                       *FullDam_Valstrain_rate, *Nb_damage);
   ++dam;
   ++equi_straint;
   ++equi_straint_rate;
   ++Kapaq;
   ++strain_rate_vrplgs_it;
   ++FullDam_Valstrain;
   ++FullDam_Valstrain_rate;
   ++Nb_damage;
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
 
   AKANTU_DEBUG_OUT();
 }
diff --git a/extra_packages/extra-materials/src/material_viscoelastic/material_stiffness_proportional.cc b/extra_packages/extra-materials/src/material_viscoelastic/material_stiffness_proportional.cc
index d6ddc6d49..bbc232c9e 100644
--- a/extra_packages/extra-materials/src/material_viscoelastic/material_stiffness_proportional.cc
+++ b/extra_packages/extra-materials/src/material_viscoelastic/material_stiffness_proportional.cc
@@ -1,121 +1,121 @@
 /**
  * @file   material_stiffness_proportional.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  *
  * @brief  Special. of the material class for the caughey viscoelastic material
  *
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "material_stiffness_proportional.hh"
 #include "solid_mechanics_model.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 MaterialStiffnessProportional<spatial_dimension>::MaterialStiffnessProportional(
     SolidMechanicsModel & model, const ID & id)
     : MaterialElastic<spatial_dimension>(model, id),
       stress_viscosity("stress_viscosity", *this),
       stress_elastic("stress_elastic", *this) {
   AKANTU_DEBUG_IN();
 
   this->registerParam("Alpha", alpha, 0., _pat_parsable | _pat_modifiable,
                       "Artificial viscous ratio");
 
   this->stress_viscosity.initialize(spatial_dimension * spatial_dimension);
   this->stress_elastic.initialize(spatial_dimension * spatial_dimension);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialStiffnessProportional<spatial_dimension>::initMaterial() {
   AKANTU_DEBUG_IN();
   MaterialElastic<spatial_dimension>::initMaterial();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialStiffnessProportional<spatial_dimension>::computeStress(
     ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
-  Array<UInt> & elem_filter = this->element_filter(el_type, ghost_type);
+  Array<Idx> & elem_filter = this->element_filter(el_type, ghost_type);
   Array<Real> & stress_visc = stress_viscosity(el_type, ghost_type);
   Array<Real> & stress_el = stress_elastic(el_type, ghost_type);
 
   MaterialElastic<spatial_dimension>::computeStress(el_type, ghost_type);
 
   Array<Real> & velocity = this->model.getVelocity();
 
   Array<Real> strain_rate(0, spatial_dimension * spatial_dimension,
                           "strain_rate");
 
   this->model.getFEEngine().gradientOnIntegrationPoints(
       velocity, strain_rate, spatial_dimension, el_type, ghost_type,
       elem_filter);
 
   Array<Real>::matrix_iterator strain_rate_it =
       strain_rate.begin(spatial_dimension, spatial_dimension);
   Array<Real>::matrix_iterator stress_visc_it =
       stress_visc.begin(spatial_dimension, spatial_dimension);
   Array<Real>::matrix_iterator stress_el_it =
       stress_el.begin(spatial_dimension, spatial_dimension);
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
   Matrix<Real> & grad_v = *strain_rate_it;
   Matrix<Real> & sigma_visc = *stress_visc_it;
   Matrix<Real> & sigma_el = *stress_el_it;
 
   MaterialElastic<spatial_dimension>::computeStressOnQuad(grad_v, sigma_visc);
 
   sigma_visc *= alpha;
   sigma_el.copy(sigma);
   sigma += sigma_visc;
 
   ++strain_rate_it;
   ++stress_visc_it;
   ++stress_el_it;
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialStiffnessProportional<spatial_dimension>::computePotentialEnergy(
     ElementType el_type) {
   AKANTU_DEBUG_IN();
 
   Array<Real> & stress_el = stress_elastic(el_type);
   Array<Real>::matrix_iterator stress_el_it =
       stress_el.begin(spatial_dimension, spatial_dimension);
 
   Real * epot = this->potential_energy(el_type).storage();
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, _not_ghost);
   Matrix<Real> & sigma_el = *stress_el_it;
   MaterialElastic<spatial_dimension>::computePotentialEnergyOnQuad(
       grad_u, sigma_el, *epot);
   epot++;
   ++stress_el_it;
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 INSTANTIATE_MATERIAL(ve_stiffness_prop, MaterialStiffnessProportional);
 
 } // namespace akantu
diff --git a/extra_packages/extra-materials/test/test_material_damage/test_material_damage_iterative_non_local_parallel.cc b/extra_packages/extra-materials/test/test_material_damage/test_material_damage_iterative_non_local_parallel.cc
index 02c42a19e..02aaf953c 100644
--- a/extra_packages/extra-materials/test/test_material_damage/test_material_damage_iterative_non_local_parallel.cc
+++ b/extra_packages/extra-materials/test/test_material_damage/test_material_damage_iterative_non_local_parallel.cc
@@ -1,359 +1,359 @@
 /**
  * @file   test_material_damage_iterative_non_local_parallel.cc
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @date   Thu Nov 26 12:20:15 2015
  *
  * @brief  test the material damage iterative non local in parallel
  *
  *
  * 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 "material_damage_iterative.hh"
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 using namespace akantu;
 
 bool checkDisplacement(SolidMechanicsModel & model, ElementType type,
                        std::ofstream & error_output, UInt step,
                        bool barycenters);
 
 /* -------------------------------------------------------------------------- */
 /* Main                                                                       */
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
 
   debug::setDebugLevel(dblWarning);
   ElementType element_type = _triangle_3;
 
   initialize("two_materials.dat", argc, argv);
 
   const UInt spatial_dimension = 2;
   StaticCommunicator & comm =
       akantu::StaticCommunicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   /// read the mesh and partion it
   Mesh mesh(spatial_dimension);
   akantu::MeshPartition * partition = NULL;
 
   if (prank == 0) {
 
     mesh.read("one_circular_inclusion.msh");
 
     /// partition the mesh
     partition = new MeshPartitionScotch(mesh, spatial_dimension);
 
     partition->partitionate(psize);
   }
 
   /// model creation
   SolidMechanicsModel model(mesh);
   model.initParallel(partition);
   delete partition;
 
   /// assign the material
   MeshDataMaterialSelector<std::string> * mat_selector;
   mat_selector =
       new MeshDataMaterialSelector<std::string>("physical_names", model);
   model.setMaterialSelector(*mat_selector);
   mesh.createGroupsFromMeshData<std::string>(
       "physical_names"); // creates groups from mesh names
   /// initialization of the model
   model.initFull(SolidMechanicsModelOptions(_static));
 
   /// boundary conditions
   /// Dirichlet BC
   model.applyBC(BC::Dirichlet::FixedValue(0, _x), "left");
   model.applyBC(BC::Dirichlet::FixedValue(0, _y), "bottom");
   model.applyBC(BC::Dirichlet::FixedValue(2., _y), "top");
 
   /// add fields that should be dumped
   model.setBaseName("material_damage_iterative_test");
   model.addDumpFieldVector("displacement");
   ;
   model.addDumpField("stress");
   model.addDumpField("blocked_dofs");
   model.addDumpField("residual");
   model.addDumpField("grad_u");
   model.addDumpField("damage");
   model.addDumpField("partitions");
   model.addDumpField("material_index");
   model.addDumpField("Sc");
   model.addDumpField("force");
   model.addDumpField("equivalent_stress");
 
   model.dump();
 
   std::stringstream error_stream;
   error_stream << "error"
                << ".csv";
   std::ofstream error_output;
   error_output.open(error_stream.str().c_str());
   error_output << "# Step, Average, Max, Min" << std::endl;
 
   checkDisplacement(model, element_type, error_output, 0, true);
 
   MaterialDamageIterative<spatial_dimension> & aggregate =
       dynamic_cast<MaterialDamageIterative<spatial_dimension> &>(
           model.getMaterial(0));
   MaterialDamageIterative<spatial_dimension> & paste =
       dynamic_cast<MaterialDamageIterative<spatial_dimension> &>(
           model.getMaterial(1));
 
   Real error;
   bool converged = false;
   UInt nb_damaged_elements = 0;
   Real max_eq_stress_agg = 0;
   Real max_eq_stress_paste = 0;
 
   /// solve the system
   converged =
       model.solveStep<_scm_newton_raphson_tangent_modified,
                       SolveConvergenceCriteria::_increment>(1e-12, error, 2);
 
   if (converged == false) {
     std::cout << "The error is: " << error << std::endl;
     AKANTU_DEBUG_ASSERT(converged, "Did not converge");
   }
 
   if (!checkDisplacement(model, element_type, error_output, 1, false)) {
     finalize();
     return EXIT_FAILURE;
   }
 
   model.dump();
 
   /// get the maximum equivalent stress in both materials
   max_eq_stress_agg = aggregate.getNormMaxEquivalentStress();
   max_eq_stress_paste = paste.getNormMaxEquivalentStress();
 
   nb_damaged_elements = 0;
   if (max_eq_stress_agg > max_eq_stress_paste)
     nb_damaged_elements = aggregate.updateDamage();
   else
     nb_damaged_elements = paste.updateDamage();
 
   if (prank == 0 && nb_damaged_elements)
     std::cout << nb_damaged_elements << " elements damaged" << std::endl;
 
   /// resolve the system
   converged =
       model.solveStep<_scm_newton_raphson_tangent_modified,
                       SolveConvergenceCriteria::_increment>(1e-12, error, 2);
 
   if (converged == false) {
     std::cout << "The error is: " << error << std::endl;
     AKANTU_DEBUG_ASSERT(converged, "Did not converge");
   }
 
   if (!checkDisplacement(model, element_type, error_output, 2, false)) {
     finalize();
     return EXIT_FAILURE;
   }
 
   model.dump();
 
   finalize();
 
   return EXIT_SUCCESS;
 }
 
 /* -------------------------------------------------------------------------- */
 bool checkDisplacement(SolidMechanicsModel & model, ElementType type,
                        std::ofstream & error_output, UInt step,
                        bool barycenters) {
 
   Mesh & mesh = model.getMesh();
   UInt spatial_dimension = mesh.getSpatialDimension();
-  const Array<UInt> & connectivity = mesh.getConnectivity(type);
+  const Array<Idx> & connectivity = mesh.getConnectivity(type);
   const Array<Real> & displacement = model.getDisplacement();
   UInt nb_element = mesh.getNbElement(type);
   UInt nb_nodes_per_elem = Mesh::getNbNodesPerElement(type);
 
   StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   if (psize == 1) {
     std::stringstream displacement_file;
     displacement_file << "displacement/displacement_" << std::setfill('0')
                       << std::setw(6) << step;
     std::ofstream displacement_output;
     displacement_output.open(displacement_file.str().c_str());
 
     for (UInt el = 0; el < nb_element; ++el) {
       for (UInt n = 0; n < nb_nodes_per_elem; ++n) {
         UInt node = connectivity(el, n);
 
         for (UInt dim = 0; dim < spatial_dimension; ++dim) {
           displacement_output << std::setprecision(15)
                               << displacement(node, dim) << " ";
         }
         displacement_output << std::endl;
       }
     }
 
     displacement_output.close();
 
     if (barycenters) {
       std::stringstream barycenter_file;
       barycenter_file << "displacement/barycenters";
       std::ofstream barycenter_output;
       barycenter_output.open(barycenter_file.str().c_str());
 
       Element element(type, 0);
       Vector<Real> bary(spatial_dimension);
 
       for (UInt el = 0; el < nb_element; ++el) {
         element.element = el;
         mesh.getBarycenter(element, bary);
 
         for (UInt dim = 0; dim < spatial_dimension; ++dim) {
           barycenter_output << std::setprecision(15) << bary(dim) << " ";
         }
         barycenter_output << std::endl;
       }
 
       barycenter_output.close();
     }
   } else {
 
     if (barycenters)
       return true;
 
     /// read data
     std::stringstream displacement_file;
     displacement_file << "displacement/displacement_" << std::setfill('0')
                       << std::setw(6) << step;
     std::ifstream displacement_input;
     displacement_input.open(displacement_file.str().c_str());
 
     Array<Real> displacement_serial(0, spatial_dimension);
     Vector<Real> disp_tmp(spatial_dimension);
 
     while (displacement_input.good()) {
       for (UInt i = 0; i < spatial_dimension; ++i)
         displacement_input >> disp_tmp(i);
 
       displacement_serial.push_back(disp_tmp);
     }
 
     std::stringstream barycenter_file;
     barycenter_file << "displacement/barycenters";
     std::ifstream barycenter_input;
     barycenter_input.open(barycenter_file.str().c_str());
 
     Array<Real> barycenter_serial(0, spatial_dimension);
 
     while (barycenter_input.good()) {
       for (UInt dim = 0; dim < spatial_dimension; ++dim)
         barycenter_input >> disp_tmp(dim);
 
       barycenter_serial.push_back(disp_tmp);
     }
 
     Element element(type, 0);
     Vector<Real> bary(spatial_dimension);
 
     Array<Real>::iterator<Vector<Real>> it;
     Array<Real>::iterator<Vector<Real>> begin =
         barycenter_serial.begin(spatial_dimension);
     Array<Real>::iterator<Vector<Real>> end =
         barycenter_serial.end(spatial_dimension);
 
     Array<Real>::const_iterator<Vector<Real>> disp_it;
     Array<Real>::iterator<Vector<Real>> disp_serial_it;
 
     Vector<Real> difference(spatial_dimension);
     Array<Real> error;
 
     /// compute error
     for (UInt el = 0; el < nb_element; ++el) {
       element.element = el;
       mesh.getBarycenter(element, bary);
 
       /// find element
       for (it = begin; it != end; ++it) {
         UInt matched_dim = 0;
 
         while (matched_dim < spatial_dimension &&
                Math::are_float_equal(bary(matched_dim), (*it)(matched_dim)))
           ++matched_dim;
 
         if (matched_dim == spatial_dimension)
           break;
       }
 
       if (it == end) {
         std::cout << "Element barycenter not found!" << std::endl;
         return false;
       }
 
       UInt matched_el = it - begin;
 
       disp_serial_it = displacement_serial.begin(spatial_dimension) +
                        matched_el * nb_nodes_per_elem;
 
       for (UInt n = 0; n < nb_nodes_per_elem; ++n, ++disp_serial_it) {
         UInt node = connectivity(el, n);
         if (!mesh.isLocalOrMasterNode(node))
           continue;
 
         disp_it = displacement.begin(spatial_dimension) + node;
 
         difference = *disp_it;
         difference -= *disp_serial_it;
 
         error.push_back(difference.norm());
       }
     }
 
     /// compute average error
     Real average_error = std::accumulate(error.begin(), error.end(), 0.);
     comm.allReduce(&average_error, 1, _so_sum);
 
     UInt error_size = error.getSize();
     comm.allReduce(&error_size, 1, _so_sum);
 
     average_error /= error_size;
 
     /// compute maximum and minimum
     Real max_error = *std::max_element(error.begin(), error.end());
     comm.allReduce(&max_error, 1, _so_max);
 
     Real min_error = *std::min_element(error.begin(), error.end());
     comm.allReduce(&min_error, 1, _so_min);
 
     /// output data
     if (prank == 0) {
       error_output << step << ", " << average_error << ", " << max_error << ", "
                    << min_error << std::endl;
     }
 
     if (max_error > 1.e-9) {
       std::cout << "Displacement error of " << max_error << " is too big!"
                 << std::endl;
       return false;
     }
   }
 
   return true;
 }
diff --git a/extra_packages/igfem/src/fe_engine_template_tmpl_igfem.hh b/extra_packages/igfem/src/fe_engine_template_tmpl_igfem.hh
index 78a9392c6..31c2db877 100644
--- a/extra_packages/igfem/src/fe_engine_template_tmpl_igfem.hh
+++ b/extra_packages/igfem/src/fe_engine_template_tmpl_igfem.hh
@@ -1,117 +1,117 @@
 /**
  * @file   shape_igfem_inline_impl.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  *
  * @brief  ShapeIGFEM inline implementation
  *
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "integrator_gauss_igfem.hh"
 #include "shape_igfem.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_FE_ENGINE_TEMPLATE_TMPL_IGFEM_HH_
 #define AKANTU_FE_ENGINE_TEMPLATE_TMPL_IGFEM_HH_
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* compatibility functions */
 /* -------------------------------------------------------------------------- */
 
 template <>
 inline void FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_igfem,
                              DefaultIntegrationOrderFunctor>::
     initShapeFunctions(const Array<Real> & nodes,
                        GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Mesh::type_iterator it =
       mesh.firstType(element_dimension, ghost_type, _ek_igfem);
   Mesh::type_iterator end =
       mesh.lastType(element_dimension, ghost_type, _ek_igfem);
   for (; it != end; ++it) {
     ElementType type = *it;
     integrator.initIntegrator(nodes, type, ghost_type);
 
 #define INIT(_type)                                                            \
   do {                                                                         \
     const Matrix<Real> & all_quads =                                           \
         integrator.getIntegrationPoints<_type>(ghost_type);                    \
     const Matrix<Real> & quads_1 = integrator.getIntegrationPoints<            \
         ElementClassProperty<_type>::sub_element_type_1>(ghost_type);          \
     const Matrix<Real> & quads_2 = integrator.getIntegrationPoints<            \
         ElementClassProperty<_type>::sub_element_type_2>(ghost_type);          \
     shape_functions.initShapeFunctions(nodes, all_quads, quads_1, quads_2,     \
                                        _type, ghost_type);                     \
   } while (0)
 
     AKANTU_BOOST_IGFEM_ELEMENT_SWITCH(INIT);
 #undef INIT
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_igfem,
                              DefaultIntegrationOrderFunctor>::
     computeIntegrationPointsCoordinates(
         Array<Real> & quadrature_points_coordinates, ElementType type,
         GhostType ghost_type,
         const Array<Int> & filter_elements) const {
 
   const Array<Real> & nodes_coordinates = mesh.getNodes();
   UInt spatial_dimension = mesh.getSpatialDimension();
   /// create an array with the nodal coordinates that need to be
   /// interpolated. The nodal coordinates of the enriched nodes need
   /// to be set to zero, because they represent the enrichment of the
   /// position field, and the enrichments for this field are all zero!
   /// There is no gap in the mesh!
   Array<Real> igfem_nodes(nodes_coordinates.getSize(), spatial_dimension);
   shape_functions.extractValuesAtStandardNodes(nodes_coordinates, igfem_nodes,
                                                ghost_type);
 
   interpolateOnIntegrationPoints(igfem_nodes, quadrature_points_coordinates,
                                  spatial_dimension, type, ghost_type,
                                  filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_igfem,
                              DefaultIntegrationOrderFunctor>::
     computeIntegrationPointsCoordinates(
         ElementTypeMapArray<Real> & quadrature_points_coordinates,
-        const ElementTypeMapArray<UInt> * filter_elements) const {
+        const ElementTypeMapArray<Idx> * filter_elements) const {
 
   const Array<Real> & nodes_coordinates = mesh.getNodes();
   UInt spatial_dimension = mesh.getSpatialDimension();
   /// create an array with the nodal coordinates that need to be
   /// interpolated. The nodal coordinates of the enriched nodes need
   /// to be set to zero, because they represent the enrichment of the
   /// position field, and the enrichments for this field are all zero!
   /// There is no gap in the mesh!
   Array<Real> igfem_nodes(nodes_coordinates.getSize(), spatial_dimension);
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     GhostType ghost_type = *gt;
     shape_functions.extractValuesAtStandardNodes(nodes_coordinates, igfem_nodes,
                                                  ghost_type);
   }
 
   interpolateOnIntegrationPoints(igfem_nodes, quadrature_points_coordinates,
                                  filter_elements);
 }
 
 } // namespace akantu
 
 #endif /* AKANTU_FE_ENGINE_TEMPLATE_TMPL_IGFEM_HH_ */
diff --git a/extra_packages/igfem/src/material_igfem/material_igfem.cc b/extra_packages/igfem/src/material_igfem/material_igfem.cc
index dceb3322f..f2d4f466a 100644
--- a/extra_packages/igfem/src/material_igfem/material_igfem.cc
+++ b/extra_packages/igfem/src/material_igfem/material_igfem.cc
@@ -1,367 +1,367 @@
 /**
  * @file   element_class_igfem.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  *
  * @brief  Implementation parent material for IGFEM
  *
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 
 #include "material_igfem.hh"
 #include "aka_math.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 MaterialIGFEM::MaterialIGFEM(SolidMechanicsModel & model, const ID & id)
     : Material(model, id), nb_sub_materials(2),
       sub_material("sub_material", *this), name_sub_mat_1(""),
       name_sub_mat_2("") {
   AKANTU_DEBUG_IN();
 
   this->model = dynamic_cast<SolidMechanicsModelIGFEM *>(&model);
   this->fem = &(model.getFEEngineClass<MyFEEngineIGFEMType>("IGFEMFEEngine"));
 
   this->model->getMesh().initElementTypeMapArray(
       element_filter, 1, spatial_dimension, false, _ek_igfem);
 
   this->initialize();
 
   AKANTU_DEBUG_OUT();
 };
 
 /* -------------------------------------------------------------------------- */
 
 MaterialIGFEM::~MaterialIGFEM() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MaterialIGFEM::initialize() {
 
   this->gradu.setElementKind(_ek_igfem);
   this->stress.setElementKind(_ek_igfem);
   this->eigengradu.setElementKind(_ek_igfem);
 
   this->gradu.setFEEngine(*fem);
   this->stress.setFEEngine(*fem);
   this->eigengradu.setFEEngine(*fem);
 
   registerParam("name_sub_mat_1", name_sub_mat_1, std::string(),
                 _pat_parsable | _pat_readable);
   registerParam("name_sub_mat_2", name_sub_mat_2, std::string(),
                 _pat_parsable | _pat_readable);
 
   this->sub_material.initialize(1);
 }
 
 /* -------------------------------------------------------------------------- */
 void MaterialIGFEM::computeQuadraturePointsCoordinates(
     ElementTypeMapArray<Real> & quadrature_points_coordinates,
     GhostType ghost_type) const {
   AKANTU_DEBUG_IN();
 
   /// compute quadrature points position in undeformed configuration
   Array<Real> & nodes_coordinates = this->fem->getMesh().getNodes();
   Mesh::type_iterator it =
       this->element_filter.firstType(spatial_dimension, ghost_type, _ek_igfem);
   Mesh::type_iterator last_type =
       this->element_filter.lastType(spatial_dimension, ghost_type, _ek_igfem);
   for (; it != last_type; ++it) {
-    const Array<UInt> & elem_filter = this->element_filter(*it, ghost_type);
+    const Array<Idx> & elem_filter = this->element_filter(*it, ghost_type);
     UInt nb_element = elem_filter.getSize();
     if (nb_element) {
       UInt nb_tot_quad =
           this->fem->getNbIntegrationPoints(*it, ghost_type) * nb_element;
 
       Array<Real> & quads = quadrature_points_coordinates(*it, ghost_type);
       quads.resize(nb_tot_quad);
 
       this->model->getFEEngine("IGFEMFEEngine")
           .interpolateOnIntegrationPoints(nodes_coordinates, quads,
                                           spatial_dimension, *it, ghost_type,
                                           elem_filter);
     }
   }
 
   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 MaterialIGFEM::computeAllStresses(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model->getSpatialDimension();
 
   Mesh::type_iterator it =
       this->fem->getMesh().firstType(spatial_dimension, ghost_type, _ek_igfem);
   Mesh::type_iterator last_type =
       this->fem->getMesh().lastType(spatial_dimension, ghost_type, _ek_igfem);
 
   for (; it != last_type; ++it) {
-    Array<UInt> & elem_filter = element_filter(*it, ghost_type);
+    Array<Idx> & elem_filter = element_filter(*it, ghost_type);
     if (elem_filter.getSize()) {
       Array<Real> & gradu_vect = gradu(*it, ghost_type);
 
       /// compute @f$\nabla u@f$
       this->fem->gradientOnIntegrationPoints(model->getDisplacement(),
                                              gradu_vect, spatial_dimension, *it,
                                              ghost_type, elem_filter);
 
       gradu_vect -= eigengradu(*it, ghost_type);
 
       /// compute @f$\mathbf{\sigma}_q@f$ from @f$\nabla u@f$
       computeStress(*it, ghost_type);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /// extrapolate internal values
 void MaterialIGFEM::extrapolateInternal(const ID & id, const Element & element,
                                         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).getSize();
     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() > Math::getTolerance()) {
         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;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void MaterialIGFEM::setSubMaterial(const Array<Element> & element_list,
                                    GhostType ghost_type) {
   AKANTU_DEBUG_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void MaterialIGFEM::setSubMaterial<_igfem_triangle_5>(
     const Array<Element> & element_list, GhostType ghost_type) {
   SolidMechanicsModelIGFEM * igfem_model =
       static_cast<SolidMechanicsModelIGFEM *>(this->model);
   Vector<UInt> sub_material_index(this->nb_sub_materials);
   Array<Element>::const_iterator<Element> el_begin = element_list.begin();
   Array<Element>::const_iterator<Element> el_end = element_list.end();
   const Mesh & mesh = this->model->getMesh();
   Array<Real> nodes_coordinates(mesh.getNodes(), true);
   Array<Real>::const_vector_iterator nodes_it =
       nodes_coordinates.begin(spatial_dimension);
   Element el;
   el.kind = _ek_igfem;
   el.type = _igfem_triangle_5;
   el.ghost_type = ghost_type;
   UInt nb_nodes_per_el = mesh.getNbNodesPerElement(el.type);
   UInt nb_parent_nodes = IGFEMHelper::getNbParentNodes(el.type);
   Vector<bool> is_inside(nb_parent_nodes);
-  const Array<UInt> & connectivity = mesh.getConnectivity(el.type, ghost_type);
-  Array<UInt>::const_vector_iterator connec_it =
+  const Array<Idx> & connectivity = mesh.getConnectivity(el.type, ghost_type);
+  Array<Idx>::const_vector_iterator connec_it =
       connectivity.begin(nb_nodes_per_el);
 
   /// get the number of quadrature points for the two sub-elements
   UInt quads_1 = IGFEMHelper::getNbQuadraturePoints(el.type, 0);
   UInt quads_2 = IGFEMHelper::getNbQuadraturePoints(el.type, 1);
   UInt nb_total_quads = quads_1 + quads_2;
 
   UInt * sub_mat_ptr = this->sub_material(el.type, ghost_type).storage();
 
   /// loop all elements for the given type
-  const Array<UInt> & filter = this->element_filter(el.type, ghost_type);
+  const Array<Idx> & filter = this->element_filter(el.type, ghost_type);
   UInt nb_elements = filter.getSize();
   for (UInt e = 0; e < nb_elements; ++e, ++connec_it) {
     el.element = filter(e);
     if (std::find(el_begin, el_end, el) == el_end) {
       sub_mat_ptr += nb_total_quads;
       continue;
     }
 
     for (UInt i = 0; i < nb_parent_nodes; ++i) {
       Vector<Real> node = nodes_it[(*connec_it)(i)];
       is_inside(i) = igfem_model->isInside(node, this->name_sub_mat_1);
     }
 
     UInt orientation = IGFEMHelper::getElementOrientation(el.type, is_inside);
 
     switch (orientation) {
     case 0: {
       sub_material_index(0) = 0;
       sub_material_index(1) = 1;
       break;
     }
 
     case 1: {
       sub_material_index(0) = 1;
       sub_material_index(1) = 0;
       break;
     }
 
     case 2: {
       sub_material_index(0) = 0;
       sub_material_index(1) = 0;
       break;
     }
     case 3: {
       sub_material_index(0) = 1;
       sub_material_index(0) = 1;
       break;
     }
     }
 
     for (UInt q = 0; q < quads_1; ++q, ++sub_mat_ptr) {
       UInt index = sub_material_index(0);
       *sub_mat_ptr = index;
     }
     for (UInt q = 0; q < quads_2; ++q, ++sub_mat_ptr) {
       UInt index = sub_material_index(1);
       *sub_mat_ptr = index;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void MaterialIGFEM::setSubMaterial<_igfem_triangle_4>(
     const Array<Element> & element_list, GhostType ghost_type) {
   SolidMechanicsModelIGFEM * igfem_model =
       static_cast<SolidMechanicsModelIGFEM *>(this->model);
   Vector<UInt> sub_material_index(this->nb_sub_materials);
   Array<Element>::const_iterator<Element> el_begin = element_list.begin();
   Array<Element>::const_iterator<Element> el_end = element_list.end();
   const Mesh & mesh = this->model->getMesh();
   Element el;
   el.kind = _ek_igfem;
   el.ghost_type = ghost_type;
   el.type = _igfem_triangle_4;
   UInt nb_nodes_per_el = mesh.getNbNodesPerElement(el.type);
   Vector<Real> barycenter(spatial_dimension);
-  const Array<UInt> & connectivity = mesh.getConnectivity(el.type, ghost_type);
-  Array<UInt>::const_vector_iterator connec_it =
+  const Array<Idx> & connectivity = mesh.getConnectivity(el.type, ghost_type);
+  Array<Idx>::const_vector_iterator connec_it =
       connectivity.begin(nb_nodes_per_el);
 
   /// get the number of quadrature points for the two sub-elements
   UInt quads_1 = IGFEMHelper::getNbQuadraturePoints(el.type, 0);
   UInt quads_2 = IGFEMHelper::getNbQuadraturePoints(el.type, 1);
   UInt nb_total_quads = quads_1 + quads_2;
 
   UInt * sub_mat_ptr = this->sub_material(el.type, ghost_type).storage();
 
   /// loop all elements for the given type
-  const Array<UInt> & filter = this->element_filter(el.type, ghost_type);
+  const Array<Idx> & filter = this->element_filter(el.type, ghost_type);
   UInt nb_elements = filter.getSize();
   for (UInt e = 0; e < nb_elements; ++e, ++connec_it) {
     el.element = filter(e);
     if (std::find(el_begin, el_end, el) == el_end) {
       sub_mat_ptr += nb_total_quads;
       continue;
     }
 
     for (UInt s = 0; s < this->nb_sub_materials; ++s) {
       igfem_model->getSubElementBarycenter(el.element, s, el.type, barycenter,
                                            ghost_type);
       sub_material_index(s) =
           1 - igfem_model->isInside(barycenter, this->name_sub_mat_1);
     }
 
     for (UInt q = 0; q < quads_1; ++q, ++sub_mat_ptr) {
       UInt index = sub_material_index(0);
       *sub_mat_ptr = index;
     }
 
     for (UInt q = 0; q < quads_2; ++q, ++sub_mat_ptr) {
       UInt index = sub_material_index(1);
       *sub_mat_ptr = index;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void MaterialIGFEM::applyEigenGradU(
     const Matrix<Real> & prescribed_eigen_grad_u, const ID & id,
     const GhostType ghost_type) {
 
   std::map<UInt, ID>::const_iterator sub_mat_it =
       this->sub_material_names.begin();
   for (; sub_mat_it != sub_material_names.end(); ++sub_mat_it) {
     if (sub_mat_it->second == id) {
       UInt sub_element_index = sub_mat_it->first;
 
-      ElementTypeMapArray<UInt>::type_iterator it =
+      ElementTypeMapArray<Idx>::type_iterator it =
           this->element_filter.firstType(_all_dimensions, ghost_type,
                                          _ek_not_defined);
-      ElementTypeMapArray<UInt>::type_iterator end =
+      ElementTypeMapArray<Idx>::type_iterator end =
           element_filter.lastType(_all_dimensions, ghost_type, _ek_not_defined);
 
       for (; it != end; ++it) {
         ElementType type = *it;
         if (!element_filter(type, ghost_type).getSize())
           continue;
         Array<Real>::matrix_iterator eigen_it =
             this->eigengradu(type, ghost_type)
                 .begin(spatial_dimension, spatial_dimension);
         Array<Real>::matrix_iterator eigen_end =
             this->eigengradu(type, ghost_type)
                 .end(spatial_dimension, spatial_dimension);
         UInt * sub_mat_ptr = this->sub_material(type, ghost_type).storage();
 
         for (; eigen_it != eigen_end; ++eigen_it, ++sub_mat_ptr) {
           if (*sub_mat_ptr == sub_element_index) {
             Matrix<Real> & current_eigengradu = *eigen_it;
             current_eigengradu = prescribed_eigen_grad_u;
           }
         }
       }
     }
   }
 }
 
 } // namespace akantu
diff --git a/extra_packages/igfem/src/material_igfem/material_igfem.hh b/extra_packages/igfem/src/material_igfem/material_igfem.hh
index 1d708d2ec..fe3d02c04 100644
--- a/extra_packages/igfem/src/material_igfem/material_igfem.hh
+++ b/extra_packages/igfem/src/material_igfem/material_igfem.hh
@@ -1,134 +1,134 @@
 /**
  * @file   element_class_igfem.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  *
  * @brief  Parent material for IGFEM
  *
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "igfem_internal_field.hh"
 #include "material.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_MATERIAL_IGFEM_HH_
 #define AKANTU_MATERIAL_IGFEM_HH_
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 class SolidMechanicsModelIGFEM;
 }
 
 namespace akantu {
 
 class MaterialIGFEM : public virtual Material {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   typedef FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_igfem>
       MyFEEngineIGFEMType;
 
   MaterialIGFEM(SolidMechanicsModel & model, const ID & id = "");
 
   virtual ~MaterialIGFEM();
 
 protected:
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   virtual void computeAllStresses(GhostType ghost_type = _not_ghost);
 
   virtual void extrapolateInternal(const ID & id, const Element & element,
                                    const Matrix<Real> & point,
                                    Matrix<Real> & extrapolated);
 
   /// apply a constant eigengrad_u everywhere in the material
   virtual void applyEigenGradU(const Matrix<Real> & prescribed_eigen_grad_u,
                                const ID & sub_mat_name,
                                const GhostType = _not_ghost);
 
   /* ------------------------------------------------------------------------ */
   /* MeshEventHandler inherited members                                       */
   /* ------------------------------------------------------------------------ */
 public:
   /* ------------------------------------------------------------------------ */
   virtual void computeQuadraturePointsCoordinates(
       ElementTypeMapArray<Real> & quadrature_points_coordinates,
       GhostType ghost_type) const;
   // virtual void onElementsAdded(const Array<Element> & element_list,
   //                              const NewElementsEvent & event) {};
 
   // virtual void onElementsRemoved(const Array<Element> & element_list,
-  //                                const ElementTypeMapArray<UInt> &
+  //                                const ElementTypeMapArray<Idx> &
   //                                new_numbering,
   //                                const RemovedElementsEvent & event) {};
 protected:
   /// constitutive law
   virtual void computeStress(__attribute__((unused)) ElementType el_type,
                              __attribute__((unused))
                              GhostType ghost_type = _not_ghost) {}
   void initialize();
 
   template <ElementType type>
   void setSubMaterial(const Array<Element> & element_list,
                       GhostType ghost_type);
 
   /* ------------------------------------------------------------------------ */
   /* DataAccessor inherited members                                           */
   /* ------------------------------------------------------------------------ */
 public:
   virtual inline UInt getNbDataForElements(const Array<Element> & elements,
                                            SynchronizationTag tag) const;
 
   virtual inline void packElementData(CommunicationBuffer & buffer,
                                       const Array<Element> & elements,
                                       SynchronizationTag tag) const;
 
   virtual inline void unpackElementData(CommunicationBuffer & buffer,
                                         const Array<Element> & elements,
                                         SynchronizationTag tag);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 
 protected:
   const UInt nb_sub_materials;
 
   /// pointer to the solid mechanics model for igfem elements
   SolidMechanicsModelIGFEM * model;
 
   /// internal field of bool to know to which sub-material a quad point belongs
   IGFEMInternalField<UInt> sub_material;
 
   /// material name of first sub-material
   std::string name_sub_mat_1;
 
   /// material name of first sub-material
   std::string name_sub_mat_2;
 
   /// map the index of the sub-materials to the names
   std::map<UInt, ID> sub_material_names;
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 #include "material_igfem_inline_impl.hh"
 
 } // namespace akantu
 
 #include "igfem_internal_field_tmpl.hh"
 
 #endif /* AKANTU_MATERIAL_IGFEM_HH_ */
diff --git a/extra_packages/igfem/src/material_igfem/material_igfem_elastic.cc b/extra_packages/igfem/src/material_igfem/material_igfem_elastic.cc
index 085a2a94c..a331e82ab 100644
--- a/extra_packages/igfem/src/material_igfem/material_igfem_elastic.cc
+++ b/extra_packages/igfem/src/material_igfem/material_igfem_elastic.cc
@@ -1,241 +1,241 @@
 /**
  * @file   material_igfem_elastic.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  *
  *
  * @brief  Specializaton of material class for the igfem elastic material
  *
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "material_igfem_elastic.hh"
 #include "material_elastic.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <Int dim>
 MaterialIGFEMElastic<dim>::MaterialIGFEMElastic(SolidMechanicsModel & model,
                                                 const ID & id)
     : Material(model, id), Parent(model, id), lambda("lambda", *this),
       mu("mu", *this), kpa("kappa", *this) {
   AKANTU_DEBUG_IN();
   this->initialize();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int dim> void MaterialIGFEMElastic<dim>::initialize() {
   this->lambda.initialize(1);
   this->mu.initialize(1);
   this->kpa.initialize(1);
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int dim> void MaterialIGFEMElastic<dim>::initMaterial() {
   AKANTU_DEBUG_IN();
 
   Parent::initMaterial();
 
   /// insert the sub_material names into the map
   this->sub_material_names[0] = this->name_sub_mat_1;
   this->sub_material_names[1] = this->name_sub_mat_2;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialIGFEMElastic<spatial_dimension>::updateElasticInternals(
     const Array<Element> & element_list) {
 
   /// compute the Lamé constants for both sub-materials
   Vector<Real> lambda_per_sub_mat(this->nb_sub_materials);
   Vector<Real> mu_per_sub_mat(this->nb_sub_materials);
   Vector<Real> kpa_per_sub_mat(this->nb_sub_materials);
   for (UInt i = 0; i < this->nb_sub_materials; ++i) {
     ID mat_name = this->sub_material_names[i];
     const MaterialElastic<spatial_dimension> & mat =
         dynamic_cast<MaterialElastic<spatial_dimension> &>(
             this->model->getMaterial(mat_name));
     lambda_per_sub_mat(i) = mat.getLambda();
     mu_per_sub_mat(i) = mat.getMu();
     kpa_per_sub_mat(i) = mat.getKappa();
   }
 
   for (ghost_type_t::iterator g = ghost_type_t::begin();
        g != ghost_type_t::end(); ++g) {
     GhostType ghost_type = *g;
     /// loop over all types in the material
-    typedef ElementTypeMapArray<UInt>::type_iterator iterator;
+    typedef ElementTypeMapArray<Idx>::type_iterator iterator;
     iterator it = this->element_filter.firstType(spatial_dimension, ghost_type,
                                                  _ek_igfem);
     iterator last_type =
         this->element_filter.lastType(spatial_dimension, ghost_type, _ek_igfem);
     /// loop over all types in the filter
     for (; it != last_type; ++it) {
       ElementType el_type = *it;
       if (el_type == _igfem_triangle_4)
         this->template setSubMaterial<_igfem_triangle_4>(element_list,
                                                          ghost_type);
       else if (el_type == _igfem_triangle_5)
         this->template setSubMaterial<_igfem_triangle_5>(element_list,
                                                          ghost_type);
       else
         AKANTU_ERROR("There is currently no other IGFEM type implemented");
 
       UInt nb_element = this->element_filter(el_type, ghost_type).getSize();
       UInt nb_quads = this->fem->getNbIntegrationPoints(el_type);
       /// get pointer to internals for given type
       Real * lambda_ptr = this->lambda(el_type, ghost_type).storage();
       Real * mu_ptr = this->mu(el_type, ghost_type).storage();
       Real * kpa_ptr = this->kpa(el_type, ghost_type).storage();
       UInt * sub_mat_ptr = this->sub_material(el_type, ghost_type).storage();
       for (UInt q = 0; q < nb_element * nb_quads;
            ++q, ++lambda_ptr, ++mu_ptr, ++kpa_ptr, ++sub_mat_ptr) {
         UInt index = *sub_mat_ptr;
         *lambda_ptr = lambda_per_sub_mat(index);
         *mu_ptr = mu_per_sub_mat(index);
         *kpa_ptr = kpa_per_sub_mat(index);
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialIGFEMElastic<spatial_dimension>::computeStress(
     ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Parent::computeStress(el_type, ghost_type);
 
   if (!this->finite_deformation) {
     /// get pointer to internals
     Real * lambda_ptr = this->lambda(el_type, ghost_type).storage();
     Real * mu_ptr = this->mu(el_type, ghost_type).storage();
     MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
     this->computeStressOnQuad(grad_u, sigma, *lambda_ptr, *mu_ptr);
     ++lambda_ptr;
     ++mu_ptr;
     MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
   } else {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialIGFEMElastic<spatial_dimension>::computeTangentModuli(
     __attribute__((unused)) ElementType el_type,
     Array<Real> & tangent_matrix,
     __attribute__((unused)) GhostType ghost_type) {
   AKANTU_DEBUG_IN();
   /// get pointer to internals
   Real * lambda_ptr = this->lambda(el_type, ghost_type).storage();
   Real * mu_ptr = this->mu(el_type, ghost_type).storage();
   MATERIAL_TANGENT_QUADRATURE_POINT_LOOP_BEGIN(tangent_matrix);
   this->computeTangentModuliOnQuad(tangent, *lambda_ptr, *mu_ptr);
   ++lambda_ptr;
   ++mu_ptr;
   MATERIAL_TANGENT_QUADRATURE_POINT_LOOP_END;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialIGFEMElastic<spatial_dimension>::computePotentialEnergy(
     ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   // MaterialThermal<spatial_dimension>::computePotentialEnergy(el_type,
   // ghost_type);
 
   // if(ghost_type != _not_ghost) return;
   // Array<Real>::scalar_iterator epot = this->potential_energy(el_type,
   // ghost_type).begin();
 
   // if (!this->finite_deformation) {
   //   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
 
   //   this->computePotentialEnergyOnQuad(grad_u, sigma, *epot);
   //   ++epot;
 
   //   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
   // } else {
   //   Matrix<Real> E(spatial_dimension, spatial_dimension);
 
   //   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
   //   this->template gradUToGreenStrain<spatial_dimension>(grad_u, E);
 
   //   this->computePotentialEnergyOnQuad(E, sigma, *epot);
   //   ++epot;
 
   //   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
   // }
 
   AKANTU_DEBUG_TO_IMPLEMENT();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialIGFEMElastic<spatial_dimension>::computePotentialEnergyByElement(
     ElementType type, UInt index, Vector<Real> & epot_on_quad_points) {
   // 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);
 
   // if (this->finite_deformation)
   //   stress_it = this->piola_kirchhoff_2(type).begin(spatial_dimension,
   //                                                        spatial_dimension);
 
   // UInt nb_quadrature_points =
   // this->model->getFEEngine().getNbQuadraturePoints(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) {
 
   //   if (this->finite_deformation)
   //     this->template gradUToGreenStrain<spatial_dimension>(*gradu_it,
   //     grad_u);
   //   else
   //     grad_u.copy(*gradu_it);
 
   //   this->computePotentialEnergyOnQuad(grad_u, *stress_it, *epot_quad);
   // }
   AKANTU_DEBUG_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialIGFEMElastic<spatial_dimension>::onElementsAdded(
     const Array<Element> & element_list, const NewElementsEvent & event) {
 
   Parent::onElementsAdded(element_list, event);
   updateElasticInternals(element_list);
 };
 
 INSTANTIATE_MATERIAL(MaterialIGFEMElastic);
 
 } // namespace akantu
diff --git a/extra_packages/igfem/src/material_igfem/material_igfem_iterative_stiffness_reduction.cc b/extra_packages/igfem/src/material_igfem/material_igfem_iterative_stiffness_reduction.cc
index 34e564db6..7ab8bcd37 100644
--- a/extra_packages/igfem/src/material_igfem/material_igfem_iterative_stiffness_reduction.cc
+++ b/extra_packages/igfem/src/material_igfem/material_igfem_iterative_stiffness_reduction.cc
@@ -1,288 +1,288 @@
 /**
  * @file   material_igfem_iterative_stiffness_reduction.cc
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @date   Thu Mar 10 08:37:43 2016
  *
  * @brief  Implementation of igfem material iterative stiffness reduction
  *
  *
  * 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 "material_igfem_iterative_stiffness_reduction.hh"
 #include <math.h>
 
 namespace akantu {
 template <Int spatial_dimension>
 
 /* -------------------------------------------------------------------------- */
 MaterialIGFEMIterativeStiffnessReduction<spatial_dimension>::
     MaterialIGFEMIterativeStiffnessReduction(SolidMechanicsModel & model,
                                              const ID & id)
     : Material(model, id), MaterialIGFEMSawToothDamage<spatial_dimension>(model,
                                                                           id),
       eps_u("ultimate_strain", *this), reduction_step("damage_step", *this),
       D("tangent", *this), Gf(0.), crack_band_width(0.), max_reductions(0),
       reduction_constant(0.) {
   AKANTU_DEBUG_IN();
 
   this->eps_u.initialize(1);
   this->D.initialize(1);
   this->reduction_step.initialize(1);
 
   this->internals_to_transfer.push_back("ultimate_strain");
   this->internals_to_transfer.push_back("tangent");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int dim>
 void MaterialIGFEMIterativeStiffnessReduction<dim>::initMaterial() {
   AKANTU_DEBUG_IN();
 
   MaterialIGFEMSawToothDamage<dim>::initMaterial();
 
   /// get the parameters for the sub-material that can be damaged
   ID mat_name = this->sub_material_names[1];
   const Material & mat = this->model->getMaterial(mat_name);
   this->crack_band_width = mat.getParam<Real>("crack_band_width");
   this->max_reductions = mat.getParam<UInt>("max_reductions");
   this->reduction_constant = mat.getParam<Real>("reduction_constant");
   this->Gf = mat.getParam<Real>("Gf");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialIGFEMIterativeStiffnessReduction<spatial_dimension>::
     computeNormalizedEquivalentStress(const Array<Real> & grad_u,
                                       ElementType el_type,
                                       GhostType ghost_type) {
   AKANTU_DEBUG_IN();
   /// storage for the current stress
   Matrix<Real> sigma(spatial_dimension, spatial_dimension);
   /// Vector to store eigenvalues of current stress tensor
   Vector<Real> eigenvalues(spatial_dimension);
 
   /// iterators on the needed internal fields
   Array<Real>::const_scalar_iterator Sc_it =
       this->Sc(el_type, ghost_type).begin();
   Array<Real>::scalar_iterator dam_it =
       this->damage(el_type, ghost_type).begin();
   Array<Real>::scalar_iterator equivalent_stress_it =
       this->equivalent_stress(el_type, ghost_type).begin();
   Array<Real>::const_matrix_iterator grad_u_it =
       grad_u.begin(spatial_dimension, spatial_dimension);
   Array<Real>::const_matrix_iterator grad_u_end =
       grad_u.end(spatial_dimension, spatial_dimension);
   Real * mu_ptr = this->mu(el_type, ghost_type).storage();
   Real * lambda_ptr = this->lambda(el_type, ghost_type).storage();
 
   /// loop over all the quadrature points and compute the equivalent stress
   for (; grad_u_it != grad_u_end; ++grad_u_it) {
     /// compute the stress
     sigma.zero();
     MaterialIGFEMElastic<spatial_dimension>::computeStressOnQuad(
         *grad_u_it, sigma, *lambda_ptr, *mu_ptr);
     MaterialIGFEMSawToothDamage<
         spatial_dimension>::computeDamageAndStressOnQuad(sigma, *dam_it);
     /// compute eigenvalues
     sigma.eig(eigenvalues);
 
     /// find max eigenvalue and normalize by tensile strength
     *equivalent_stress_it =
         *(std::max_element(eigenvalues.storage(),
                            eigenvalues.storage() + spatial_dimension)) /
         (*Sc_it);
     ++Sc_it;
     ++equivalent_stress_it;
     ++dam_it;
     ++lambda_ptr;
     ++mu_ptr;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 UInt MaterialIGFEMIterativeStiffnessReduction<
     spatial_dimension>::updateDamage() {
   UInt nb_damaged_elements = 0;
 
   if (this->norm_max_equivalent_stress >= 1.) {
 
     AKANTU_DEBUG_IN();
 
     /// update the damage only on non-ghosts elements! Doesn't make sense to
     /// update on ghost.
     GhostType ghost_type = _not_ghost;
     ;
 
     Mesh::type_iterator it = this->model->getFEEngine().getMesh().firstType(
         spatial_dimension, ghost_type, _ek_igfem);
     Mesh::type_iterator last_type =
         this->model->getFEEngine().getMesh().lastType(spatial_dimension,
                                                       ghost_type, _ek_igfem);
 
     /// get the Young's modulus of the damageable sub-material
     ID mat_name = this->sub_material_names[1];
 
     Real E = this->model->getMaterial(mat_name).template getParam<Real>("E");
 
     /// loop over all the elements
     for (; it != last_type; ++it) {
       ElementType el_type = *it;
 
       /// get iterators on the needed internal fields
-      const Array<UInt> & sub_mat = this->sub_material(el_type, ghost_type);
-      Array<UInt>::const_scalar_iterator sub_mat_it = sub_mat.begin();
+      const Array<Idx> & sub_mat = this->sub_material(el_type, ghost_type);
+      Array<Idx>::const_scalar_iterator sub_mat_it = sub_mat.begin();
       Array<Real>::const_scalar_iterator equivalent_stress_it =
           this->equivalent_stress(el_type, ghost_type).begin();
       Array<Real>::const_scalar_iterator equivalent_stress_end =
           this->equivalent_stress(el_type, ghost_type).end();
       Array<Real>::scalar_iterator dam_it =
           this->damage(el_type, ghost_type).begin();
-      Array<UInt>::scalar_iterator reduction_it =
+      Array<Idx>::scalar_iterator reduction_it =
           this->reduction_step(el_type, ghost_type).begin();
       Array<Real>::const_scalar_iterator eps_u_it =
           this->eps_u(el_type, ghost_type).begin();
       Array<Real>::scalar_iterator Sc_it =
           this->Sc(el_type, ghost_type).begin();
       Array<Real>::const_scalar_iterator D_it =
           this->D(el_type, ghost_type).begin();
 
       /// loop over all the elements of the given type
       UInt nb_element = this->element_filter(el_type, ghost_type).getSize();
       UInt nb_quads = this->fem->getNbIntegrationPoints(el_type, ghost_type);
       bool damage_element = false;
       for (UInt e = 0; e < nb_element; ++e) {
         damage_element = false;
         /// check if damage occurs in the element
         for (UInt q = 0; q < nb_quads;
              ++q, ++reduction_it, ++sub_mat_it, ++equivalent_stress_it) {
           if (*equivalent_stress_it >= (1 - this->dam_tolerance) *
                                            this->norm_max_equivalent_stress &&
               *sub_mat_it != 0) {
             /// check if this element can still be damaged
             if (*reduction_it == this->max_reductions)
               continue;
             damage_element = true;
           }
         }
 
         if (damage_element) {
           /// damage the element
           nb_damaged_elements += 1;
           sub_mat_it -= nb_quads;
           reduction_it -= nb_quads;
           for (UInt q = 0; q < nb_quads; ++q) {
             if (*sub_mat_it) {
               /// increment the counter of stiffness reduction steps
               *reduction_it += 1;
               if (*reduction_it == this->max_reductions)
                 *dam_it = this->max_damage;
               else {
                 /// update the damage on this quad
                 *dam_it = 1. - (1. / std::pow(this->reduction_constant,
                                               *reduction_it));
                 /// update the stiffness on this quad
                 *Sc_it = (*eps_u_it) * (1. - (*dam_it)) * E * (*D_it) /
                          ((1. - (*dam_it)) * E + (*D_it));
               }
             }
             ++sub_mat_it;
             ++dam_it;
             ++reduction_it;
             ++eps_u_it;
             ++Sc_it;
             ++D_it;
           }
         } else {
           dam_it += nb_quads;
           eps_u_it += nb_quads;
           Sc_it += nb_quads;
           D_it += nb_quads;
         }
       }
     }
   }
   StaticCommunicator & comm =
       akantu::StaticCommunicator::getStaticCommunicator();
   comm.allReduce(&nb_damaged_elements, 1, _so_sum);
   AKANTU_DEBUG_OUT();
   return nb_damaged_elements;
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialIGFEMIterativeStiffnessReduction<
     spatial_dimension>::onElementsAdded(__attribute__((unused))
                                         const Array<Element> & element_list,
                                         __attribute__((unused))
                                         const NewElementsEvent & event) {
 
   MaterialIGFEMSawToothDamage<spatial_dimension>::onElementsAdded(element_list,
                                                                   event);
   /// set the correct damage iteration step (is UInt->cannot be interpolated)
   Real val = 0.;
   for (ghost_type_t::iterator g = ghost_type_t::begin();
        g != ghost_type_t::end(); ++g) {
     GhostType ghost_type = *g;
     /// loop over all types in the material
-    typedef ElementTypeMapArray<UInt>::type_iterator iterator;
+    typedef ElementTypeMapArray<Idx>::type_iterator iterator;
     iterator it = this->element_filter.firstType(spatial_dimension, ghost_type,
                                                  _ek_igfem);
     iterator last_type =
         this->element_filter.lastType(spatial_dimension, ghost_type, _ek_igfem);
     /// loop over all types in the filter
     for (; it != last_type; ++it) {
       const ElementType el_type = *it;
       Array<Real>::scalar_iterator dam_it =
           this->damage(el_type, ghost_type).begin();
-      Array<UInt>::scalar_iterator reduction_it =
+      Array<Idx>::scalar_iterator reduction_it =
           this->reduction_step(el_type, ghost_type).begin();
       UInt nb_element = this->element_filter(el_type, ghost_type).getSize();
       UInt nb_quads = this->fem->getNbIntegrationPoints(el_type);
       UInt * sub_mat_ptr = this->sub_material(el_type, ghost_type).storage();
       for (UInt q = 0; q < nb_element * nb_quads;
            ++q, ++sub_mat_ptr, ++dam_it, ++reduction_it) {
         if (*sub_mat_ptr) {
           if (Math::are_float_equal(*dam_it, this->max_damage))
             *reduction_it = this->max_reductions;
           else {
             for (UInt i = 0; i < this->max_reductions; ++i) {
               val = 1 - (1. / std::pow(this->reduction_constant, i));
               if (Math::are_float_equal(val, *dam_it))
                 *reduction_it = i;
             }
           }
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 INSTANTIATE_MATERIAL(MaterialIGFEMIterativeStiffnessReduction);
 
 } // namespace akantu
diff --git a/extra_packages/igfem/src/material_igfem/material_igfem_saw_tooth_damage.cc b/extra_packages/igfem/src/material_igfem/material_igfem_saw_tooth_damage.cc
index 5d35bddf3..5936ca6b1 100644
--- a/extra_packages/igfem/src/material_igfem/material_igfem_saw_tooth_damage.cc
+++ b/extra_packages/igfem/src/material_igfem/material_igfem_saw_tooth_damage.cc
@@ -1,466 +1,466 @@
 /**
  * @file   material_igfem_saw_tooth_damage.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  *
  *
  * @brief  Implementation of the squentially linear saw-tooth damage model for
  * IGFEM elements
  *
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "material_igfem_saw_tooth_damage.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <Int dim>
 MaterialIGFEMSawToothDamage<dim>::MaterialIGFEMSawToothDamage(
     SolidMechanicsModel & model, const ID & id)
     : Material(model, id), Parent(model, id), Sc("Sc", *this),
       equivalent_stress("equivalent_stress", *this),
       norm_max_equivalent_stress(0) {
   AKANTU_DEBUG_IN();
 
   this->Sc.initialize(1);
   this->equivalent_stress.initialize(1);
   this->damage.setElementKind(_ek_igfem);
   this->damage.setFEEngine(*(this->fem));
 
   this->internals_to_transfer.push_back("damage");
   this->internals_to_transfer.push_back("Sc");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int dim> void MaterialIGFEMSawToothDamage<dim>::initMaterial() {
   AKANTU_DEBUG_IN();
 
   Parent::initMaterial();
 
   /// get the parameters for the sub-material that can be damaged
   ID mat_name = this->sub_material_names[1];
   const Material & mat = this->model->getMaterial(mat_name);
   this->prescribed_dam = mat.getParam<Real>("prescribed_dam");
   this->dam_threshold = mat.getParam<Real>("dam_threshold");
   this->dam_tolerance = mat.getParam<Real>("dam_tolerance");
   this->max_damage = mat.getParam<Real>("max_damage");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialIGFEMSawToothDamage<spatial_dimension>::
     computeNormalizedEquivalentStress(const Array<Real> & grad_u,
                                       ElementType el_type,
                                       GhostType ghost_type) {
   AKANTU_DEBUG_IN();
   /// Vector to store eigenvalues of current stress tensor
   Vector<Real> eigenvalues(spatial_dimension);
 
   Array<Real>::const_iterator<Real> Sc_it = Sc(el_type, ghost_type).begin();
   Array<Real>::iterator<Real> equivalent_stress_it =
       equivalent_stress(el_type, ghost_type).begin();
 
   Array<Real>::const_matrix_iterator grad_u_it =
       grad_u.begin(spatial_dimension, spatial_dimension);
   Array<Real>::const_matrix_iterator grad_u_end =
       grad_u.end(spatial_dimension, spatial_dimension);
   /// get pointer to internals
   Real * lambda_ptr = this->lambda(el_type, ghost_type).storage();
   Real * mu_ptr = this->mu(el_type, ghost_type).storage();
   Real * dam = this->damage(el_type, ghost_type).storage();
   Matrix<Real> sigma(spatial_dimension, spatial_dimension);
   for (; grad_u_it != grad_u_end; ++grad_u_it) {
     MaterialIGFEMElastic<spatial_dimension>::computeStressOnQuad(
         *grad_u_it, sigma, *lambda_ptr, *mu_ptr);
     computeDamageAndStressOnQuad(sigma, *dam);
 
     /// compute eigenvalues
     sigma.eig(eigenvalues);
     /// find max eigenvalue and normalize by tensile strength
     *equivalent_stress_it =
         *(std::max_element(eigenvalues.storage(),
                            eigenvalues.storage() + spatial_dimension)) /
         *(Sc_it);
     ++Sc_it;
     ++equivalent_stress_it;
     ++dam;
     ++lambda_ptr;
     ++mu_ptr;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialIGFEMSawToothDamage<spatial_dimension>::computeAllStresses(
     GhostType ghost_type) {
   AKANTU_DEBUG_IN();
   /// reset normalized maximum equivalent stress
   if (ghost_type == _not_ghost)
     norm_max_equivalent_stress = 0;
 
   Parent::computeAllStresses(ghost_type);
 
   /// find global Gauss point with highest stress
   StaticCommunicator & comm =
       akantu::StaticCommunicator::getStaticCommunicator();
   comm.allReduce(&norm_max_equivalent_stress, 1, _so_max);
 
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialIGFEMSawToothDamage<spatial_dimension>::
     findMaxNormalizedEquivalentStress(ElementType el_type,
                                       GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   if (ghost_type == _not_ghost) {
 
     const Array<Real> & e_stress = equivalent_stress(el_type);
     Array<Real>::const_iterator<Real> equivalent_stress_it = e_stress.begin();
     Array<Real>::const_iterator<Real> equivalent_stress_end = e_stress.end();
     Array<Real> & dam = this->damage(el_type);
     Array<Real>::iterator<Real> dam_it = dam.begin();
-    Array<UInt> & sub_mat = this->sub_material(el_type);
-    Array<UInt>::iterator<UInt> sub_mat_it = sub_mat.begin();
+    Array<Idx> & sub_mat = this->sub_material(el_type);
+    Array<Idx>::iterator<UInt> sub_mat_it = sub_mat.begin();
 
     for (; equivalent_stress_it != equivalent_stress_end;
          ++equivalent_stress_it, ++dam_it, ++sub_mat_it) {
       /// check if max equivalent stress for this element type is greater than
       /// the current norm_max_eq_stress and if the element is not already fully
       /// damaged
       if ((*equivalent_stress_it > norm_max_equivalent_stress &&
            *dam_it < max_damage) &&
           *sub_mat_it != 0) {
         norm_max_equivalent_stress = *equivalent_stress_it;
       }
     }
   }
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialIGFEMSawToothDamage<spatial_dimension>::computeStress(
     ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Parent::computeStress(el_type, ghost_type);
 
   Real * dam = this->damage(el_type, ghost_type).storage();
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
 
   computeDamageAndStressOnQuad(sigma, *dam);
   ++dam;
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
 
   computeNormalizedEquivalentStress(this->gradu(el_type, ghost_type), el_type,
                                     ghost_type);
   norm_max_equivalent_stress = 0;
   findMaxNormalizedEquivalentStress(el_type, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 UInt MaterialIGFEMSawToothDamage<spatial_dimension>::updateDamage() {
   UInt nb_damaged_elements = 0;
   AKANTU_DEBUG_ASSERT(prescribed_dam > 0.,
                       "Your prescribed damage must be greater than zero");
 
   if (norm_max_equivalent_stress >= 1.) {
 
     AKANTU_DEBUG_IN();
     GhostType ghost_type = _not_ghost;
     ;
 
     Mesh::type_iterator it = this->model->getMesh().firstType(
         spatial_dimension, ghost_type, _ek_igfem);
     Mesh::type_iterator last_type = this->model->getMesh().lastType(
         spatial_dimension, ghost_type, _ek_igfem);
 
     for (; it != last_type; ++it) {
       ElementType el_type = *it;
-      Array<UInt> & sub_mat = this->sub_material(el_type);
-      Array<UInt>::iterator<UInt> sub_mat_it = sub_mat.begin();
+      Array<Idx> & sub_mat = this->sub_material(el_type);
+      Array<Idx>::iterator<UInt> sub_mat_it = sub_mat.begin();
       const Array<Real> & e_stress = equivalent_stress(el_type);
       Array<Real>::const_iterator<Real> equivalent_stress_it = e_stress.begin();
       Array<Real>::const_iterator<Real> equivalent_stress_end = e_stress.end();
       Array<Real> & dam = this->damage(el_type);
       Array<Real>::iterator<Real> dam_it = dam.begin();
 
       /// loop over all the elements of the given type
       UInt nb_element = this->element_filter(el_type, ghost_type).getSize();
       UInt nb_quads = this->fem->getNbIntegrationPoints(el_type, ghost_type);
       bool damage_element = false;
       for (UInt e = 0; e < nb_element; ++e) {
         damage_element = false;
         /// check if damage occurs in the element
         for (UInt q = 0; q < nb_quads; ++q) {
           if (*equivalent_stress_it >=
                   (1 - dam_tolerance) * norm_max_equivalent_stress &&
               *sub_mat_it != 0) {
             damage_element = true;
           }
           ++sub_mat_it;
           ++equivalent_stress_it;
         }
 
         if (damage_element) {
           nb_damaged_elements += 1;
           /// damage the element
           sub_mat_it -= nb_quads;
           for (UInt q = 0; q < nb_quads; ++q) {
             if (*sub_mat_it) {
               if (*dam_it < dam_threshold)
                 *dam_it += prescribed_dam;
               else
                 *dam_it = max_damage;
             }
             ++sub_mat_it;
             ++dam_it;
           }
         } else {
           dam_it += nb_quads;
         }
       }
     }
   }
 
   StaticCommunicator & comm =
       akantu::StaticCommunicator::getStaticCommunicator();
   comm.allReduce(&nb_damaged_elements, 1, _so_sum);
   AKANTU_DEBUG_OUT();
   return nb_damaged_elements;
 }
 /* -------------------------------------------------------------------------- */
 // template<UInt spatial_dimension>
 // void
 // MaterialIGFEMSawToothDamage<spatial_dimension>::updateEnergiesAfterDamage(ElementType
 // el_type, GhostType ghost_type) {
 //   MaterialDamage<spatial_dimension>::updateEnergies(el_type, ghost_type);
 // }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 void MaterialIGFEMSawToothDamage<spatial_dimension>::onElementsAdded(
     __attribute__((unused)) const Array<Element> & element_list,
     __attribute__((unused)) const NewElementsEvent & event) {
 
   /// update elastic constants
   MaterialIGFEMElastic<spatial_dimension>::onElementsAdded(element_list, event);
   IGFEMInternalField<Real> quadrature_points_coordinates(
       "quadrature_points_coordinates", *this);
   quadrature_points_coordinates.initialize(spatial_dimension);
   this->computeQuadraturePointsCoordinates(quadrature_points_coordinates,
                                            _not_ghost);
   this->computeQuadraturePointsCoordinates(quadrature_points_coordinates,
                                            _ghost);
 
   Array<Element>::const_iterator<Element> el_begin = element_list.begin();
   Array<Element>::const_iterator<Element> el_end = element_list.end();
   Element el;
   el.kind = _ek_igfem;
   /// loop over all the elements in the filter
   for (ghost_type_t::iterator g = ghost_type_t::begin();
        g != ghost_type_t::end(); ++g) {
     GhostType ghost_type = *g;
     /// loop over all types in the material
-    typedef ElementTypeMapArray<UInt>::type_iterator iterator;
+    typedef ElementTypeMapArray<Idx>::type_iterator iterator;
     iterator it = this->element_filter.firstType(spatial_dimension, ghost_type,
                                                  _ek_igfem);
     iterator last_type =
         this->element_filter.lastType(spatial_dimension, ghost_type, _ek_igfem);
     for (; it != last_type; ++it) {
       /// store the elements added to this material
       std::vector<Element> new_elements;
-      Array<UInt> & elem_filter = this->element_filter(*it, ghost_type);
+      Array<Idx> & elem_filter = this->element_filter(*it, ghost_type);
       UInt nb_element = elem_filter.getSize();
       UInt nb_quads =
           quadrature_points_coordinates.getFEEngine().getNbIntegrationPoints(
               *it, ghost_type);
       Array<Real> added_quads(0, spatial_dimension);
       const Array<Real> & quads =
           quadrature_points_coordinates(*it, ghost_type);
       Array<Real>::const_vector_iterator quad = quads.begin(spatial_dimension);
       el.type = *it;
       el.ghost_type = ghost_type;
 
       for (UInt e = 0; e < nb_element; ++e) {
         /// global number of element
         el.element = elem_filter(e);
         if (std::find(el_begin, el_end, el) != el_end) {
           new_elements.push_back(el);
           for (UInt q = 0; q < nb_quads; ++q) {
             added_quads.push_back(*quad);
             ++quad;
           }
         } else
           quad += nb_quads;
       }
 
       /// get the extrapolated values
       for (UInt i = 0; i < this->internals_to_transfer.size(); ++i) {
         if (!new_elements.size())
           continue;
         const ID name = this->getID() + ":" + this->internals_to_transfer[i];
         Array<Real> & internal =
             (*(this->internal_vectors_real[name]))(*it, ghost_type);
         UInt nb_component = internal.getNbComponent();
         /// Array<Real>::vector_iterator internal_it =
         /// internal.begin(nb_component);
         Array<Real> extrapolated_internal_values(new_elements.size() * nb_quads,
                                                  nb_component);
         this->model->transferInternalValues(this->internals_to_transfer[i],
                                             new_elements, added_quads,
                                             extrapolated_internal_values);
 
         UInt * sub_mat_ptr = this->sub_material(*it, ghost_type).storage();
         Array<Real>::const_vector_iterator extrapolated_it =
             extrapolated_internal_values.begin(nb_component);
         Array<Real>::vector_iterator internal_it = internal.begin(nb_component);
         /// copy back the results
         for (UInt j = 0; j < new_elements.size(); ++j) {
           Element element_local = this->convertToLocalElement(new_elements[j]);
           for (UInt q = 0; q < nb_quads; ++q, ++extrapolated_it) {
             if (sub_mat_ptr[element_local.element * nb_quads + q])
               internal_it[element_local.element * nb_quads + q] =
                   *extrapolated_it;
           }
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 // template<UInt spatial_dimension>
 // void
 // MaterialIGFEMSawToothDamage<spatial_dimension>::transferInternals(Material &
 // old_mat,
 // 								       std::vector<ElementPair> & element_pairs)
 // {
 
 // Element new_el_global;
 // Element new_el_local;
 // Element old_el_global;
 // Element old_el_local;
 
 // /// get the fe-engine of the old material
 // FEEngine & fem_old_mat = old_mat.getFEEngine();
 // for (UInt e = 0; e < element_pairs.size(); ++e) {
 //   new_el_global = element_pairs[e].first;
 //   old_el_global = element_pairs[e].second;
 //   /// get the number of the elements in their materials
 //   old_el_local = old_el_global;
-//   Array<UInt> & mat_local_numbering =
+//   Array<Idx> & mat_local_numbering =
 //   this->model->getMaterialLocalNumbering(old_el_global.type,
 //   old_el_global.ghost_type);
 //   old_el_local.element = mat_local_numbering(old_el_global.element);
 //   new_el_local = this->convertToLocalElement(new_el_global);
 //   UInt nb_old_quads = fem_old_mat.getNbIntegrationPoints(old_el_global.type,
 //   old_el_global.ghost_type);
 //   UInt nb_new_quads = this->fem->getNbIntegrationPoints(new_el_global.type,
 //   new_el_global.ghost_type);
 
 //   if (old_mat.isInternal("damage", Mesh::getKind(old_el_global.type))
 // 	&& old_mat.isInternal("Sc", Mesh::getKind(old_el_global.type)) ) {
 
 //     UInt quad;
 //     Vector<Real> el_old_damage(nb_old_quads);
 //     Vector<Real> el_old_Sc(nb_old_quads);
 //     Vector<Real> el_new_damage(nb_new_quads);
 //     Vector<Real> el_new_Sc(nb_new_quads);
 //     const Array<Real> & old_Sc = old_mat.getArray("Sc", old_el_global.type,
 //     old_el_global.ghost_type);
 //     const Array<Real> & old_damage = old_mat.getArray("damage",
 //     old_el_global.type, old_el_global.ghost_type);
 //     Array<Real> & new_Sc = this->Sc(new_el_global.type,
 //     new_el_global.ghost_type);
 //     Array<Real> & new_damage = this->damage(new_el_global.type,
 //     new_el_global.ghost_type);
 
 //     for (UInt q = 0; q < nb_old_quads; ++q) {
 // 	quad = old_el_local.element * nb_old_quads + q;
 // 	el_old_damage(q) = old_damage(quad);
 // 	el_old_Sc(q) = old_Sc(quad);
 //     }
 
 //     this->interpolateInternal(new_el_global, old_el_global, el_new_damage,
 //     el_old_damage, nb_new_quads, nb_old_quads);
 //     this->interpolateInternal(new_el_global, old_el_global, el_new_Sc,
 //     el_old_Sc, nb_new_quads, nb_old_quads);
 
 //     for (UInt q = 0; q < nb_new_quads; ++q) {
 // 	quad = new_el_local.element * nb_new_quads + q;
 // 	if (this->sub_material(new_el_global.type,new_el_global.ghost_type)(quad)) {
 // 	  new_damage(quad) = el_new_damage(q);
 // 	  new_Sc(quad) = el_new_damage(q);
 // 	}
 //     }
 //   }
 
 //   else
 //     AKANTU_DEBUG_ASSERT((!old_mat.isInternal("damage",
 //     Mesh::getKind(old_el_global.type))
 // 			   && !old_mat.isInternal("Sc", Mesh::getKind(old_el_global.type))
 // ),
 // 			  "old material has damage or Sc but not both!!!!");
 // }
 // }
 
 /* -------------------------------------------------------------------------- */
 
 INSTANTIATE_MATERIAL(MaterialIGFEMSawToothDamage);
 
 } // namespace akantu
 
 /*     /// get the material index in the model from this current material
     UInt this_mat_idx =  this->model->getMaterialIndex(this->name);
 
     /// number of elements in this event
     UInt nb_new_elements = element_list.getSize();
 
     // const Array<Element> & old_elements = igfem_event->getOldElementsList();
 
     // std::map<UInt, std::vector<ElementPair> > elements_by_old_mat;
 
     /// store the old elements sorted by their material
     for (UInt e = 0; e < nb_new_elements; ++e) {
       const Element new_el = element_list(e);
-      const Array<UInt> & mat_idx =
+      const Array<Idx> & mat_idx =
    this->model->getMaterialByElement(new_el.type, new_el.ghost_type);
       if ( mat_idx(new_el.element) != this_mat_idx )
     continue; /// new element is not part of this material: nothing to be done
       /// get the corresponding old element and store new and old one as pair
       const Element old_el = old_elements(e);
       ElementPair el_pair(new_el, old_el);
-      const Array<UInt> & old_mat_idx =
+      const Array<Idx> & old_mat_idx =
    this->model->getMaterialByElement(old_el.type, old_el.ghost_type);
       UInt mat_old_idx = old_mat_idx(old_el.element);
       elements_by_old_mat[mat_old_idx].push_back(el_pair);
     }
 
 
     /// loop over all the element pairs in the map
     for (std::map<UInt, std::vector<ElementPair> >::iterator map_it =
    elements_by_old_mat.begin();
      map_it != elements_by_old_mat.end(); ++map_it) {
       /// get the vector of old and new element pairs
       std::vector<ElementPair > & element_pairs = map_it->second;
       Material & old_mat = this->model->getMaterial(map_it->first);
       this->transferInternals(old_mat, element_pairs);
     }
 */
diff --git a/extra_packages/igfem/src/material_igfem/material_igfem_saw_tooth_damage_inline_impl.hh b/extra_packages/igfem/src/material_igfem/material_igfem_saw_tooth_damage_inline_impl.hh
index 45d8c6bac..8bc139cb9 100644
--- a/extra_packages/igfem/src/material_igfem/material_igfem_saw_tooth_damage_inline_impl.hh
+++ b/extra_packages/igfem/src/material_igfem/material_igfem_saw_tooth_damage_inline_impl.hh
@@ -1,66 +1,66 @@
 /**
  * @file   material_igfem_saw_tooth_damage_inline_impl.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  *
  *
  * @brief Implementation of inline functions of the squentially linear
  * saw-tooth damage model for IGFEM elements
  *
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 inline void
 MaterialIGFEMSawToothDamage<spatial_dimension>::computeDamageAndStressOnQuad(
     Matrix<Real> & sigma, Real & dam) {
   sigma *= 1 - dam;
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int spatial_dimension>
 UInt MaterialIGFEMSawToothDamage<spatial_dimension>::updateDamage(
     UInt quad_index, const Real eq_stress, ElementType el_type,
     GhostType ghost_type) {
   AKANTU_DEBUG_ASSERT(prescribed_dam > 0.,
                       "Your prescribed damage must be greater than zero");
 
   Array<Real> & dam = this->damage(el_type, ghost_type);
   Real & dam_on_quad = dam(quad_index);
 
   /// check if damage occurs
   if (equivalent_stress(el_type, ghost_type)(quad_index) >=
       (1 - dam_tolerance) * norm_max_equivalent_stress) {
     /// damage the entire sub-element -> get the element index
     UInt el_index =
         quad_index / this->element_filter(el_type, ghost_type).getSize();
     UInt nb_quads = this->fem->getNbIntegrationPoints(el_type, ghost_type);
     UInt start_idx = el_index * nb_quads;
-    Array<UInt> & sub_mat = this->sub_material(el_type, ghost_type);
+    Array<Idx> & sub_mat = this->sub_material(el_type, ghost_type);
     UInt damaged_quads = 0;
     if (dam_on_quad < dam_threshold) {
       for (UInt q = 0; q < nb_quads; ++q, ++start_idx) {
         if (sub_mat(start_idx)) {
           dam(start_idx) += prescribed_dam;
           damaged_quads += 1;
         }
       }
     } else {
       for (UInt q = 0; q < nb_quads; ++q, ++start_idx) {
         if (sub_mat(start_idx)) {
           dam(start_idx) += max_damage;
           damaged_quads += 1;
         }
       }
     }
     return damaged_quads;
   }
 
   return 0;
 }
 
 /* -------------------------------------------------------------------------- */
diff --git a/extra_packages/igfem/src/mesh_igfem_spherical_growing_gel.hh b/extra_packages/igfem/src/mesh_igfem_spherical_growing_gel.hh
index 10a101e6e..c052ed89e 100644
--- a/extra_packages/igfem/src/mesh_igfem_spherical_growing_gel.hh
+++ b/extra_packages/igfem/src/mesh_igfem_spherical_growing_gel.hh
@@ -1,220 +1,220 @@
 /**
  * @file mesh_igfem_spherical_growing_gel.hh
  *
  * @author Clement Roux-Langlois <clement.roux@epfl.ch>
  *
  * @date creation: Mon Jul 13 2015
  *
  * @brief Computation of mesh intersection with sphere(s) and growing of these
  *        spheres. This class handle the intersectors templated for every
  * element
  *        types.
  *
  *
  * Copyright (©) 2010-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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 //#if 0
 #ifndef AKANTU_MESH_IGFEM_SPHERICAL_GROWING_GEL_HH_
 #define AKANTU_MESH_IGFEM_SPHERICAL_GROWING_GEL_HH_
 
 #include "aka_common.hh"
 #include "mesh_sphere_intersector.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* classes for new igfem elements mesh events */
 /* -------------------------------------------------------------------------- */
 
 class NewIGFEMElementsEvent : public NewElementsEvent {
 public:
   AKANTU_GET_MACRO_NOT_CONST(OldElementsList, old_elements, Array<Element> &);
   AKANTU_GET_MACRO(OldElementsList, old_elements, const Array<Element> &);
 
 protected:
   Array<Element> old_elements;
 };
 
 class NewIGFEMNodesEvent : public NewNodesEvent {
 public:
-  void setNewNodePerElem(const Array<UInt> & new_node_per_elem) {
+  void setNewNodePerElem(const Array<Idx> & new_node_per_elem) {
     this->new_node_per_elem = &new_node_per_elem;
   }
   void setType(ElementType new_type) { type = new_type; }
   void setGhostType(GhostType new_type) { ghost_type = new_type; }
-  AKANTU_GET_MACRO(NewNodePerElem, *new_node_per_elem, const Array<UInt> &);
+  AKANTU_GET_MACRO(NewNodePerElem, *new_node_per_elem, const Array<Idx> &);
   AKANTU_GET_MACRO(ElementType, type, ElementType);
   AKANTU_GET_MACRO(GhostType, ghost_type, GhostType);
 
 protected:
   ElementType type;
   GhostType ghost_type;
-  const Array<UInt> * new_node_per_elem;
+  const Array<Idx> * new_node_per_elem;
 };
 
 /* -------------------------------------------------------------------------- */
 template <Int dim> class MeshIgfemSphericalGrowingGel {
 // definition of the element list
 #define ELEMENT_LIST (_triangle_3)(_igfem_triangle_4)(_igfem_triangle_5)
 
 // Solution 1
 /* #define INTERSECTOR_DEFINITION(type)			\
    MeshSphereIntersector<2, type> intersector##type(mesh);*/
 
 // Solution 2
 #define INSTANTIATOR(_type)                                                    \
   intersectors(_type, ghost_type) =                                            \
       new MeshSphereIntersector<dim, _type>(this->mesh)
 
   /* --------------------------------------------------------------------------
    */
   /* Constructor/Destructor */
   /* --------------------------------------------------------------------------
    */
 
 public:
   /// Construct from mesh
   MeshIgfemSphericalGrowingGel(Mesh & mesh);
 
   /// Destructor
   ~MeshIgfemSphericalGrowingGel() {
     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(dim, ghost_type, _ek_not_defined);
       Mesh::type_iterator end = mesh.lastType(dim, ghost_type, _ek_not_defined);
 
       for (; it != end; ++it) {
         delete intersectors(*it, ghost_type);
       }
     }
   }
 
   /* --------------------------------------------------------------------------
    */
   /* Methods */
   /* --------------------------------------------------------------------------
    */
 public:
   void init();
 
   /// Remove the additionnal nodes
   void removeAdditionalNodes();
 
   /// Compute the intersection points between the mesh and the query list for
   /// all element types and send the NewNodeEvent
   void computeMeshQueryListIntersectionPoint(
       const std::list<SK::Sphere_3> & query_list);
 
   /// increase sphere radius and build the new intersection points between the
   /// mesh and the query list for all element types and send the NewNodeEvent
   void computeMeshQueryListIntersectionPoint(
       const std::list<SK::Sphere_3> & query_list, Real inf_fact) {
     std::list<SK::Sphere_3>::const_iterator query_it = query_list.begin(),
                                             query_end = query_list.end();
     std::list<SK::Sphere_3> sphere_list;
     for (; query_it != query_end; ++query_it) {
       SK::Sphere_3 sphere(query_it->center(),
                           query_it->squared_radius() * inf_fact * inf_fact);
       sphere_list.push_back(sphere);
     }
     computeMeshQueryListIntersectionPoint(sphere_list);
   }
 
   /// Build the IGFEM mesh from intersection points
   void buildIGFEMMesh();
 
   /// Build the IGFEM mesh from spheres
   void buildIGFEMMeshFromSpheres(const std::list<SK::Sphere_3> & query_list) {
     computeMeshQueryListIntersectionPoint(query_list);
     buildIGFEMMesh();
   }
 
   /// Build the IGFEM mesh from spheres with increase factor
   void buildIGFEMMeshFromSpheres(const std::list<SK::Sphere_3> & query_list,
                                  Real inf_fact) {
     computeMeshQueryListIntersectionPoint(query_list, inf_fact);
     buildIGFEMMesh();
   }
 
   /// set the distributed synchronizer
   void setDistributedSynchronizer(DistributedSynchronizer * dist) {
     synchronizer = dist;
     buildSegmentConnectivityToNodeType();
   }
 
   /// update node type
-  void updateNodeType(const Array<UInt> & nodes_list,
-                      const Array<UInt> & new_node_per_elem, ElementType type,
+  void updateNodeType(const Array<Idx> & nodes_list,
+                      const Array<Idx> & new_node_per_elem, ElementType type,
                       GhostType ghost_type);
 
 protected:
   /// Build the unordered_map needed to assign the node type to new nodes in
   /// parallel
   void buildSegmentConnectivityToNodeType();
 
   /* --------------------------------------------------------------------------
    */
   /* Accessors */
   /* --------------------------------------------------------------------------
    */
 public:
   AKANTU_GET_MACRO(NbStandardNodes, nb_nodes_fem, UInt);
   AKANTU_GET_MACRO(NbEnrichedNodes, nb_enriched_nodes, UInt);
 
   /* --------------------------------------------------------------------------
    */
   /* Class Members */
   /* --------------------------------------------------------------------------
    */
 protected:
   /// Mesh used to construct the primitives
   Mesh & mesh;
 
   /// number of fem nodes in the initial mesh
   UInt nb_nodes_fem;
 
   /// number of enriched nodes before intersection
   UInt nb_enriched_nodes;
 
   // Solution 2
   /// map of the elements types in the mesh and the corresponding intersectors
   ElementTypeMap<MeshAbstractIntersector<SK::Sphere_3> *> intersectors;
 
   /// Map linking pairs of nodes to a node type. The pairs of nodes
   /// contain the connectivity of the primitive segments that are
   /// intersected.
   unordered_map<std::pair<UInt, UInt>, Int>::type segment_conn_to_node_type;
 
   /// Pointer to the distributed synchronizer of the model
   DistributedSynchronizer * synchronizer;
 };
 
 } // namespace akantu
 
 #include "mesh_igfem_spherical_growing_gel_tmpl.hh"
 
 #endif // AKANTU_MESH_IGFEM_SPHERICAL_GROWING_GEL_HH_
 
 //#endif //
diff --git a/extra_packages/igfem/src/mesh_igfem_spherical_growing_gel_tmpl.hh b/extra_packages/igfem/src/mesh_igfem_spherical_growing_gel_tmpl.hh
index d9e9ce065..09b591bfb 100644
--- a/extra_packages/igfem/src/mesh_igfem_spherical_growing_gel_tmpl.hh
+++ b/extra_packages/igfem/src/mesh_igfem_spherical_growing_gel_tmpl.hh
@@ -1,531 +1,531 @@
 /**
  * @file   mesh_igfem_spherical_growing_gel.cc
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  * @date   Mon Sep 21 12:42:11 2015
  *
  * @brief  Implementation of the functions of MeshIgfemSphericalGrowingGel
  *
  *
  * 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_utils.hh"
 #include <algorithm>
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <Int dim>
 MeshIgfemSphericalGrowingGel<dim>::MeshIgfemSphericalGrowingGel(Mesh & mesh)
     : mesh(mesh), nb_nodes_fem(mesh.getNbNodes()), nb_enriched_nodes(0),
       synchronizer(NULL) {}
 
 /* -------------------------------------------------------------------------- */
 template <Int dim> void MeshIgfemSphericalGrowingGel<dim>::init() {
   nb_nodes_fem = mesh.getNbNodes();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     GhostType ghost_type = *gt;
 
     Mesh::type_iterator tit = mesh.firstType(dim, ghost_type);
     Mesh::type_iterator tend = mesh.lastType(dim, ghost_type);
     for (; tit != tend;
          ++tit) { // loop to add corresponding IGFEM element types
       if (*tit == _triangle_3) {
         mesh.addConnectivityType(_igfem_triangle_4, ghost_type);
         mesh.addConnectivityType(_igfem_triangle_5, ghost_type);
       } else
         AKANTU_ERROR("Not ready for mesh type " << *tit);
     }
 
     tit = mesh.firstType(dim, ghost_type, _ek_not_defined);
     tend = mesh.lastType(dim, ghost_type, _ek_not_defined);
     for (; tit != tend; ++tit) {
       AKANTU_BOOST_LIST_SWITCH(INSTANTIATOR, ELEMENT_LIST, *tit);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int dim>
 void MeshIgfemSphericalGrowingGel<dim>::computeMeshQueryListIntersectionPoint(
     const std::list<SK::Sphere_3> & query_list) {
   /// store number of currently enriched nodes
   this->nb_enriched_nodes = mesh.getNbNodes() - nb_nodes_fem;
   UInt nb_old_nodes = mesh.getNbNodes();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     GhostType ghost_type = *gt;
 
     Mesh::type_iterator iit = mesh.firstType(dim, ghost_type, _ek_not_defined);
     Mesh::type_iterator iend = mesh.lastType(dim, ghost_type, _ek_not_defined);
     for (; iit != iend; ++iit) {
       MeshAbstractIntersector<SK::Sphere_3> & intersector =
           *intersectors(*iit, ghost_type);
       intersector.constructData(ghost_type);
       intersector.computeMeshQueryListIntersectionPoint(query_list,
                                                         nb_old_nodes);
       const Array<Real> intersection_points_current_type =
           *(intersector.getIntersectionPoints());
-      const Array<UInt> & new_node_per_elem = intersector.getNewNodePerElem();
+      const Array<Idx> & new_node_per_elem = intersector.getNewNodePerElem();
 
       /// Send the new node event
       UInt new_points = intersection_points_current_type.getSize();
       StaticCommunicator::getStaticCommunicator().allReduce(&new_points, 1,
                                                             _so_sum);
 
       if (new_points > 0) {
         Array<Real> & nodes = this->mesh.getNodes();
         UInt nb_node = nodes.getSize();
 
         Array<Real>::const_vector_iterator intersec_p_it =
             intersection_points_current_type.begin(dim);
 
         NewIGFEMNodesEvent new_nodes_event;
         for (UInt in = 0; in < intersection_points_current_type.getSize();
              ++in, ++intersec_p_it) {
           nodes.push_back(*intersec_p_it);
           new_nodes_event.getList().push_back(nb_node + in);
         }
         new_nodes_event.setNewNodePerElem(new_node_per_elem);
         new_nodes_event.setType(*iit);
         new_nodes_event.setGhostType(ghost_type);
         this->mesh.sendEvent(new_nodes_event);
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int dim>
 void MeshIgfemSphericalGrowingGel<dim>::removeAdditionalNodes() {
   AKANTU_DEBUG_IN();
 
   UInt total_nodes = this->mesh.getNbNodes();
   UInt nb_new_enriched_nodes =
       total_nodes - this->nb_enriched_nodes - this->nb_nodes_fem;
   UInt old_total_nodes = this->nb_nodes_fem + this->nb_enriched_nodes;
 
   UInt total_new_nodes = nb_new_enriched_nodes;
   StaticCommunicator::getStaticCommunicator().allReduce(&total_new_nodes, 1,
                                                         _so_sum);
   if (total_new_nodes == 0)
     return;
 
   RemovedNodesEvent remove_nodes(this->mesh);
-  Array<UInt> & nodes_removed = remove_nodes.getList();
-  Array<UInt> & new_numbering = remove_nodes.getNewNumbering();
+  Array<Idx> & nodes_removed = remove_nodes.getList();
+  Array<Idx> & new_numbering = remove_nodes.getNewNumbering();
 
   for (UInt nnod = 0; nnod < this->nb_nodes_fem; ++nnod) {
     new_numbering(nnod) = nnod;
   }
 
   for (UInt nnod = nb_nodes_fem; nnod < old_total_nodes; ++nnod) {
     new_numbering(nnod) = UInt(-1);
     nodes_removed.push_back(nnod);
   }
 
   for (UInt nnod = 0; nnod < nb_new_enriched_nodes; ++nnod) {
     new_numbering(nnod + old_total_nodes) = this->nb_nodes_fem + nnod;
   }
 
   if (nb_new_enriched_nodes > 0) {
     for (UInt gt = _not_ghost; gt <= _ghost; ++gt) {
       GhostType ghost_type = (GhostType)gt;
 
       Mesh::type_iterator it =
           mesh.firstType(_all_dimensions, ghost_type, _ek_not_defined);
       Mesh::type_iterator end =
           mesh.lastType(_all_dimensions, ghost_type, _ek_not_defined);
       for (; it != end; ++it) {
         ElementType type = *it;
-        Array<UInt> & connectivity_array =
+        Array<Idx> & connectivity_array =
             mesh.getConnectivity(type, ghost_type);
         UInt nb_nodes_per_element = connectivity_array.getNbComponent();
 
-        Array<UInt>::vector_iterator conn_it =
+        Array<Idx>::vector_iterator conn_it =
             connectivity_array.begin(nb_nodes_per_element);
-        Array<UInt>::vector_iterator conn_end =
+        Array<Idx>::vector_iterator conn_end =
             connectivity_array.end(nb_nodes_per_element);
 
         for (; conn_it != conn_end; ++conn_it) {
           for (UInt n = 0; n < nb_nodes_per_element; ++n) {
             (*conn_it)(n) = new_numbering((*conn_it)(n));
           }
         }
       }
     }
   }
 
   this->mesh.sendEvent(remove_nodes);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int dim> void MeshIgfemSphericalGrowingGel<dim>::buildIGFEMMesh() {
   AKANTU_DEBUG_IN();
 
   NewIGFEMElementsEvent new_elements_event;
   UInt total_new_elements = 0;
   Array<Element> & new_elements_list = new_elements_event.getList();
   Array<Element> & old_elements_list = new_elements_event.getOldElementsList();
   RemovedElementsEvent removed_elements_event(this->mesh);
   ChangedElementsEvent changed_elements_event(this->mesh);
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     GhostType ghost_type = *gt;
 
     mesh.initElementTypeMapArray(removed_elements_event.getNewNumbering(), 1,
                                  dim, ghost_type, false, _ek_not_defined);
     mesh.initElementTypeMapArray(changed_elements_event.getNewNumbering(), 1,
                                  dim, ghost_type, false, _ek_not_defined);
 
     /// loop over all types in the mesh for a given ghost type
     Mesh::type_iterator iit = mesh.firstType(dim, ghost_type, _ek_not_defined);
     Mesh::type_iterator iend = mesh.lastType(dim, ghost_type, _ek_not_defined);
     for (; iit != iend; ++iit) {
       ElementType type = *iit;
 
       MeshAbstractIntersector<SK::Sphere_3> & intersector =
           *intersectors(type, ghost_type);
-      const Array<UInt> & new_node_per_elem = intersector.getNewNodePerElem();
+      const Array<Idx> & new_node_per_elem = intersector.getNewNodePerElem();
 
       UInt n_new_el = 0;
-      Array<UInt> & connectivity = this->mesh.getConnectivity(type, ghost_type);
+      Array<Idx> & connectivity = this->mesh.getConnectivity(type, ghost_type);
 
       /// get the connectivities of all types that that may transform
-      Array<UInt> & connec_igfem_tri_4 =
+      Array<Idx> & connec_igfem_tri_4 =
           this->mesh.getConnectivity(_igfem_triangle_4, ghost_type);
-      Array<UInt> & connec_igfem_tri_5 =
+      Array<Idx> & connec_igfem_tri_5 =
           this->mesh.getConnectivity(_igfem_triangle_5, ghost_type);
-      Array<UInt> & connec_tri_3 =
+      Array<Idx> & connec_tri_3 =
           this->mesh.getConnectivity(_triangle_3, ghost_type);
 
       /// create elements to store the newly generated elements
       Element el_tri_3(_triangle_3, 0, ghost_type, _ek_regular);
       Element el_igfem_tri_4(_igfem_triangle_4, 0, ghost_type, _ek_igfem);
       Element el_igfem_tri5(_igfem_triangle_5, 0, ghost_type, _ek_igfem);
 
-      Array<UInt> & new_numbering =
+      Array<Idx> & new_numbering =
           removed_elements_event.getNewNumbering(type, ghost_type);
       new_numbering.resize(connectivity.getSize());
       /// container for element to be removed
       Element old_element(type, 0, ghost_type, Mesh::getKind(type));
 
       for (UInt nel = 0; nel != new_node_per_elem.getSize(); ++nel) {
         /// a former IGFEM triangle is transformed into a regular triangle
         if ((type != _triangle_3) && (new_node_per_elem(nel, 0) == 0)) {
 
           Vector<UInt> connec_new_elem(3);
           connec_new_elem(0) = connectivity(nel, 0);
           connec_new_elem(1) = connectivity(nel, 1);
           connec_new_elem(2) = connectivity(nel, 2);
           /// add the new element in the mesh
           UInt nb_triangles_3 = connec_tri_3.getSize();
           connec_tri_3.push_back(connec_new_elem);
           el_tri_3.element = nb_triangles_3;
           new_elements_list.push_back(el_tri_3);
           /// the number of the old element in the mesh
           old_element.element = nel;
           old_elements_list.push_back(old_element);
           new_numbering(nel) = UInt(-1);
           ++n_new_el;
         }
 
         /// element is enriched
         else if (new_node_per_elem(nel, 0) != 0) {
           switch (new_node_per_elem(nel, 0)) {
           /// new element is of type igfem_triangle_4
           case 1: {
             Vector<UInt> connec_new_elem(4);
             switch (new_node_per_elem(nel, 2)) {
             case 0:
               connec_new_elem(0) = connectivity(nel, 2);
               connec_new_elem(1) = connectivity(nel, 0);
               connec_new_elem(2) = connectivity(nel, 1);
               break;
             case 1:
               connec_new_elem(0) = connectivity(nel, 0);
               connec_new_elem(1) = connectivity(nel, 1);
               connec_new_elem(2) = connectivity(nel, 2);
               break;
             case 2:
               connec_new_elem(0) = connectivity(nel, 1);
               connec_new_elem(1) = connectivity(nel, 2);
               connec_new_elem(2) = connectivity(nel, 0);
               break;
             default:
               AKANTU_ERROR("A triangle has only 3 segments not "
                            << new_node_per_elem(nel, 2));
               break;
             }
             connec_new_elem(3) = new_node_per_elem(nel, 1);
             UInt nb_igfem_triangles_4 = connec_igfem_tri_4.getSize();
             connec_igfem_tri_4.push_back(connec_new_elem);
             el_igfem_tri_4.element = nb_igfem_triangles_4;
             new_elements_list.push_back(el_igfem_tri_4);
             break;
           }
           /// new element is of type igfem_triangle_5
           case 2: {
             Vector<UInt> connec_new_elem(5);
             if ((new_node_per_elem(nel, 2) == 0) &&
                 (new_node_per_elem(nel, 4) == 1)) {
               connec_new_elem(0) = connectivity(nel, 1);
               connec_new_elem(1) = connectivity(nel, 2);
               connec_new_elem(2) = connectivity(nel, 0);
               connec_new_elem(3) = new_node_per_elem(nel, 3);
               connec_new_elem(4) = new_node_per_elem(nel, 1);
             } else if ((new_node_per_elem(nel, 2) == 0) &&
                        (new_node_per_elem(nel, 4) == 2)) {
               connec_new_elem(0) = connectivity(nel, 0);
               connec_new_elem(1) = connectivity(nel, 1);
               connec_new_elem(2) = connectivity(nel, 2);
               connec_new_elem(3) = new_node_per_elem(nel, 1);
               connec_new_elem(4) = new_node_per_elem(nel, 3);
             } else if ((new_node_per_elem(nel, 2) == 1) &&
                        (new_node_per_elem(nel, 4) == 2)) {
               connec_new_elem(0) = connectivity(nel, 2);
               connec_new_elem(1) = connectivity(nel, 0);
               connec_new_elem(2) = connectivity(nel, 1);
               connec_new_elem(3) = new_node_per_elem(nel, 3);
               connec_new_elem(4) = new_node_per_elem(nel, 1);
             } else if ((new_node_per_elem(nel, 2) == 1) &&
                        (new_node_per_elem(nel, 4) == 0)) {
               connec_new_elem(0) = connectivity(nel, 1);
               connec_new_elem(1) = connectivity(nel, 2);
               connec_new_elem(2) = connectivity(nel, 0);
               connec_new_elem(3) = new_node_per_elem(nel, 1);
               connec_new_elem(4) = new_node_per_elem(nel, 3);
             } else if ((new_node_per_elem(nel, 2) == 2) &&
                        (new_node_per_elem(nel, 4) == 0)) {
               connec_new_elem(0) = connectivity(nel, 0);
               connec_new_elem(1) = connectivity(nel, 1);
               connec_new_elem(2) = connectivity(nel, 2);
               connec_new_elem(3) = new_node_per_elem(nel, 3);
               connec_new_elem(4) = new_node_per_elem(nel, 1);
             } else if ((new_node_per_elem(nel, 2) == 2) &&
                        (new_node_per_elem(nel, 4) == 1)) {
               connec_new_elem(0) = connectivity(nel, 2);
               connec_new_elem(1) = connectivity(nel, 0);
               connec_new_elem(2) = connectivity(nel, 1);
               connec_new_elem(3) = new_node_per_elem(nel, 1);
               connec_new_elem(4) = new_node_per_elem(nel, 3);
             } else
               AKANTU_ERROR("A triangle has only 3 segments (0 to 2) not "
                            << new_node_per_elem(nel, 2) << "and"
                            << new_node_per_elem(nel, 4));
 
             UInt nb_igfem_triangles_5 = connec_igfem_tri_5.getSize();
             connec_igfem_tri_5.push_back(connec_new_elem);
             el_igfem_tri5.element = nb_igfem_triangles_5;
             new_elements_list.push_back(el_igfem_tri5);
             break;
           }
           default:
             AKANTU_ERROR("IGFEM cannot add " << new_node_per_elem(nel, 0)
                                              << " nodes to triangles");
             break;
           }
           old_element.element = nel;
           old_elements_list.push_back(old_element);
           new_numbering(nel) = UInt(-1);
           ++n_new_el;
         }
       }
       total_new_elements += n_new_el;
     }
   }
 
   /// update new numbering
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     GhostType ghost_type = *gt;
     /// loop over all types in the mesh for a given ghost type
     Mesh::type_iterator iit = mesh.firstType(dim, ghost_type, _ek_not_defined);
     Mesh::type_iterator iend = mesh.lastType(dim, ghost_type, _ek_not_defined);
     for (; iit != iend; ++iit) {
       ElementType type = *iit;
-      Array<UInt> & new_numbering =
+      Array<Idx> & new_numbering =
           removed_elements_event.getNewNumbering(type, ghost_type);
       UInt el_index = 0;
       UInt nb_element = this->mesh.getNbElement(type, ghost_type);
       new_numbering.resize(nb_element);
       for (UInt e = 0; e < nb_element; ++e) {
         if (new_numbering(e) != UInt(-1)) {
           new_numbering(e) = el_index;
           ++el_index;
         }
       }
       changed_elements_event.getNewNumbering(type, ghost_type)
           .copy(new_numbering);
     }
   }
 
   StaticCommunicator::getStaticCommunicator().allReduce(&total_new_elements, 1,
                                                         _so_sum);
 
   if (total_new_elements > 0) {
     changed_elements_event.getListOld().copy(
         new_elements_event.getOldElementsList());
     changed_elements_event.getListNew().copy(new_elements_event.getList());
     this->mesh.sendEvent(changed_elements_event);
 
     this->mesh.sendEvent(new_elements_event);
 
     Array<Element> & removed_list = removed_elements_event.getList();
     removed_list.copy(new_elements_event.getOldElementsList());
     this->mesh.sendEvent(removed_elements_event);
   }
 
   removeAdditionalNodes();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int dim>
 void MeshIgfemSphericalGrowingGel<dim>::buildSegmentConnectivityToNodeType() {
   Mesh mesh_facets(mesh.initMeshFacets());
   MeshUtils::buildSegmentToNodeType(mesh, mesh_facets, synchronizer);
 
   // only the ghost elements are considered
   for (UInt g = _not_ghost; g <= _ghost; ++g) {
     GhostType ghost_type = (GhostType)g;
 
     Mesh::type_iterator it = mesh_facets.firstType(1, ghost_type);
     Mesh::type_iterator end = mesh_facets.lastType(1, ghost_type);
     for (; it != end; ++it) {
       ElementType type = *it;
 
       const Array<Int> & segment_to_nodetype =
           mesh_facets.getData<Int>("segment_to_nodetype", type, ghost_type);
 
-      const Array<UInt> & segment_connectivity =
+      const Array<Idx> & segment_connectivity =
           mesh_facets.getConnectivity(type, ghost_type);
 
       // looping over all the segments
       Array<UInt>::const_vector_iterator conn_it =
           segment_connectivity.begin(segment_connectivity.getNbComponent());
       Array<UInt>::const_vector_iterator conn_end =
           segment_connectivity.end(segment_connectivity.getNbComponent());
       UInt seg_index = 0;
 
       UInt n[2];
       for (; conn_it != conn_end; ++conn_it, ++seg_index) {
         Int seg_type = segment_to_nodetype(seg_index);
         n[0] = (*conn_it)(0);
         n[1] = (*conn_it)(1);
 
         if ((mesh.isMasterNode(n[0]) || mesh.isSlaveNode(n[0])) &&
             (mesh.isMasterNode(n[1]) || mesh.isSlaveNode(n[1]))) {
           std::sort(n, n + 2);
           segment_conn_to_node_type[std::make_pair(n[0], n[1])] = seg_type;
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int dim>
 void MeshIgfemSphericalGrowingGel<dim>::updateNodeType(
     const Array<UInt> & nodes_list, const Array<UInt> & new_node_per_elem,
     ElementType type, GhostType ghost_type) {
   Array<Int> & nodes_type = mesh.getNodesType();
   UInt old_nodes = nodes_type.getSize();
   UInt new_nodes = nodes_list.getSize();
 
   // exit this function if the simulation in run in serial
   if (old_nodes == 0 || new_nodes == 0)
     return;
 
   nodes_type.resize(old_nodes + new_nodes);
   Array<bool> checked_node(new_nodes, 1, false);
 
   UInt nb_prim_by_el = 0;
   if ((type == _triangle_3) || (type == _igfem_triangle_4) ||
       (type == _igfem_triangle_5)) {
     nb_prim_by_el = 3;
   } else {
     AKANTU_ERROR("Not ready for mesh type " << type);
   }
 
   // determine the node type for the local, master and slave nodes
   const Array<UInt> & connectivity = mesh.getConnectivity(type, ghost_type);
   unordered_map<std::pair<UInt, UInt>, Int>::type::iterator seg_type_it;
   unordered_map<std::pair<UInt, UInt>, Int>::type::iterator seg_type_end =
       segment_conn_to_node_type.end();
 
   for (UInt el = 0; el < new_node_per_elem.getSize(); ++el) {
     UInt nb_nodes = new_node_per_elem(el, 0);
 
     for (UInt n = 0; n < nb_nodes; ++n) {
       UInt node_index = new_node_per_elem(el, 2 * n + 1);
       if (node_index < old_nodes || checked_node(node_index - old_nodes))
         continue;
 
       // get the elemental connectivity of the segment associated to the node
       UInt segment_index = new_node_per_elem(el, 2 * n + 2);
 
       UInt extreme_nodes[2];
       extreme_nodes[0] = segment_index;
       extreme_nodes[1] = segment_index + 1;
       if (extreme_nodes[1] == nb_prim_by_el)
         extreme_nodes[1] = 0;
 
       // get the connectivity of the segment
       extreme_nodes[0] = connectivity(el, extreme_nodes[0]);
       extreme_nodes[1] = connectivity(el, extreme_nodes[1]);
 
       // if one extreme nodes is pure ghost, then also the new node is pure
       // ghost
       if (mesh.isPureGhostNode(extreme_nodes[0]) ||
           mesh.isPureGhostNode(extreme_nodes[1]))
         nodes_type(node_index) = -3;
       // if on of the two extreme nodes is local, then also the new node is
       // local
       else if (mesh.isLocalNode(extreme_nodes[0]) ||
                mesh.isLocalNode(extreme_nodes[1]))
         nodes_type(node_index) = -1;
 
       // otherwise use the value stored in the map
       else {
         std::sort(extreme_nodes, extreme_nodes + 2);
 
         seg_type_it = segment_conn_to_node_type.find(
             std::make_pair(extreme_nodes[0], extreme_nodes[1]));
 
         AKANTU_DEBUG_ASSERT(seg_type_it != seg_type_end, "Segment not found");
 
         nodes_type(node_index) = seg_type_it->second;
       }
 
       checked_node(node_index - old_nodes) = true;
     }
   }
 
   AKANTU_DEBUG_ASSERT(std::accumulate(checked_node.begin(), checked_node.end(),
                                       0) == Int(checked_node.getSize()),
                       "Not all new nodes were assigned a node type");
 }
 
 } // namespace akantu
diff --git a/packages/eigen.cmake b/packages/eigen.cmake
index 841c85a63..96d65c88a 100644
--- a/packages/eigen.cmake
+++ b/packages/eigen.cmake
@@ -1,8 +1,7 @@
 package_declare(Eigen3 EXTERNAL
   DESCRIPTION "Add Eigen3 dependency to akantu"
   EXTRA_PACKAGE_OPTIONS ARGS 3.3
   COMPILE_FLAGS CXX -DEIGEN_MAX_CPP_VER=14
-  COMPILE_FLAGS CXX -DEIGEN_DEFAULT_DENSE_INDEX_TYPE=akantu::Idx
   )
 
 mark_as_advanced(Eigen3_DIR)
diff --git a/src/common/aka_array_tmpl.hh b/src/common/aka_array_tmpl.hh
index a0f2de1a9..ef7835502 100644
--- a/src/common/aka_array_tmpl.hh
+++ b/src/common/aka_array_tmpl.hh
@@ -1,1041 +1,1044 @@
 /**
  * @file   aka_array_tmpl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Jul 15 2010
  * @date last modification: Fri Feb 26 2021
  *
  * @brief  Inline functions of the classes Array<T> and ArrayBase
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 /* Inline Functions Array<T>                                                  */
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh" // NOLINT
 /* -------------------------------------------------------------------------- */
 #include <memory>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_AKA_ARRAY_TMPL_HH_
 #define AKANTU_AKA_ARRAY_TMPL_HH_
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 namespace debug {
   struct ArrayException : public Exception {};
 } // namespace debug
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 template <typename T, ArrayAllocationType allocation_trait>
 ArrayDataLayer<T, allocation_trait>::ArrayDataLayer(Int size, Int nb_component,
                                                     const ID & id)
     : ArrayBase(id) {
   allocate(size, nb_component);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, ArrayAllocationType allocation_trait>
 ArrayDataLayer<T, allocation_trait>::ArrayDataLayer(Int size, Int nb_component,
                                                     const_reference value,
                                                     const ID & id)
     : ArrayBase(id) {
   allocate(size, nb_component, value);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, ArrayAllocationType allocation_trait>
 ArrayDataLayer<T, allocation_trait>::ArrayDataLayer(const ArrayDataLayer & vect,
                                                     const ID & id)
     : ArrayBase(vect, id) {
   this->data_storage = vect.data_storage;
   this->size_ = vect.size_;
   this->nb_component = vect.nb_component;
   this->values = this->data_storage.data();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, ArrayAllocationType allocation_trait>
 ArrayDataLayer<T, allocation_trait>::ArrayDataLayer(
     const std::vector<value_type> & vect) {
   this->data_storage = vect;
   this->size_ = vect.size();
   this->nb_component = 1;
   this->values = this->data_storage.data();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, ArrayAllocationType allocation_trait>
 ArrayDataLayer<T, allocation_trait> &
 ArrayDataLayer<T, allocation_trait>::operator=(const ArrayDataLayer & other) {
   if (this != &other) {
     this->data_storage = other.data_storage;
     this->nb_component = other.nb_component;
     this->size_ = other.size_;
     this->values = this->data_storage.data();
   }
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, ArrayAllocationType allocation_trait>
 void ArrayDataLayer<T, allocation_trait>::allocate(UInt new_size,
                                                    UInt nb_component) {
   this->nb_component = nb_component;
   this->resize(new_size);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, ArrayAllocationType allocation_trait>
 void ArrayDataLayer<T, allocation_trait>::allocate(Int new_size,
                                                    Int nb_component,
                                                    const T & val) {
   this->nb_component = nb_component;
   this->resize(new_size, val);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, ArrayAllocationType allocation_trait>
 void ArrayDataLayer<T, allocation_trait>::resize(Int new_size) {
   this->data_storage.resize(new_size * this->nb_component);
   this->values = this->data_storage.data();
   this->size_ = new_size;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, ArrayAllocationType allocation_trait>
 void ArrayDataLayer<T, allocation_trait>::resize(Int new_size,
                                                  const T & value) {
   this->data_storage.resize(new_size * this->nb_component, value);
   this->values = this->data_storage.data();
   this->size_ = new_size;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, ArrayAllocationType allocation_trait>
 void ArrayDataLayer<T, allocation_trait>::reserve(Int size, Int new_size) {
   if (new_size != -1) {
     this->data_storage.resize(new_size * this->nb_component);
   }
 
   this->data_storage.reserve(size * this->nb_component);
   this->values = this->data_storage.data();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * 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 <typename T, ArrayAllocationType allocation_trait>
 inline void ArrayDataLayer<T, allocation_trait>::push_back(const T & value) {
   this->data_storage.push_back(value);
   this->values = this->data_storage.data();
   this->size_ += 1;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * append a matrix or a vector to the array
  * @param new_elem a reference to a Matrix<T> or Vector<T> */
 template <typename T, ArrayAllocationType allocation_trait>
 template <typename Derived>
 inline void ArrayDataLayer<T, allocation_trait>::push_back(
     const Eigen::MatrixBase<Derived> & 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 << ").");
   for (Idx i = 0; i < new_elem.size(); ++i) {
     this->data_storage.push_back(new_elem.data()[i]);
   }
   this->values = this->data_storage.data();
   this->size_ += 1;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, ArrayAllocationType allocation_trait>
 inline Int ArrayDataLayer<T, allocation_trait>::getAllocatedSize() const {
   return this->data_storage.capacity() / this->nb_component;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, ArrayAllocationType allocation_trait>
 inline Int ArrayDataLayer<T, allocation_trait>::getMemorySize() const {
   return this->data_storage.capacity() * sizeof(T);
 }
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 class ArrayDataLayer<T, ArrayAllocationType::_pod> : public ArrayBase {
 public:
   using value_type = T;
   using reference = value_type &;
   using pointer_type = value_type *;
   using const_reference = const value_type &;
 
 public:
   ~ArrayDataLayer() override { deallocate(); }
 
   /// Allocation of a new vector
   ArrayDataLayer(Int size = 0, Int nb_component = 1, const ID & id = "")
       : ArrayBase(id) {
     allocate(size, nb_component);
   }
 
   /// Allocation of a new vector with a default value
   ArrayDataLayer(Int size, Int nb_component, const_reference value,
                  const ID & id = "")
       : ArrayBase(id) {
     allocate(size, nb_component, value);
   }
 
   /// Copy constructor (deep copy)
   ArrayDataLayer(const ArrayDataLayer & vect, const ID & id = "")
       : ArrayBase(vect, id) {
     allocate(vect.size(), vect.getNbComponent());
     std::copy_n(vect.data(), this->size_ * this->nb_component, values);
   }
 
   /// Copy constructor (deep copy)
   explicit ArrayDataLayer(const std::vector<value_type> & vect) {
     allocate(vect.size(), 1);
     std::copy_n(vect.data(), this->size_ * this->nb_component, values);
   }
 
   // copy operator
   inline ArrayDataLayer & operator=(const ArrayDataLayer & other) {
     if (this != &other) {
       allocate(other.size(), other.getNbComponent());
       std::copy_n(other.data(), this->size_ * this->nb_component, values);
     }
     return *this;
   }
 
   // move constructor
   inline ArrayDataLayer(ArrayDataLayer && other) noexcept = default;
 
   // move assign
   inline ArrayDataLayer & operator=(ArrayDataLayer && other) noexcept = default;
 
 protected:
   // deallocate the memory
   virtual void deallocate() {
     // NOLINTNEXTLINE(cppcoreguidelines-owning-memory,
     // cppcoreguidelines-no-malloc)
     free(this->values);
   }
 
   // allocate the memory
   virtual inline void allocate(Int size, Int nb_component) {
     if (size != 0) { // malloc can return a non NULL pointer in case size is 0
       this->values = static_cast<T *>(                   // NOLINT
           std::malloc(nb_component * size * sizeof(T))); // NOLINT
     }
 
     if (this->values == nullptr and size != 0) {
       throw std::bad_alloc();
     }
     this->nb_component = nb_component;
     this->allocated_size = this->size_ = size;
   }
 
   // allocate and initialize the memory
   virtual inline void allocate(Int size, Int nb_component, const T & value) {
     allocate(size, nb_component);
     std::fill_n(values, size * nb_component, value);
   }
 
 public:
   /// append a tuple of size nb_component containing value
   inline void push_back(const_reference value) {
     resize(this->size_ + 1, value);
   }
 
   /// append a Vector or a Matrix
   template <typename Derived>
   inline void push_back(const Eigen::MatrixBase<Derived> & 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 << ").");
     this->resize(this->size_ + 1);
-    std::copy_n(new_elem.data(), new_elem.size(),
+    std::copy_n(new_elem.derived().data(), new_elem.size(),
                 values + this->nb_component * (this->size_ - 1));
   }
 
   /// changes the allocated size but not the size
   virtual void reserve(Int size, Int new_size = Int(-1)) {
     auto tmp_size = this->size_;
     if (new_size != Int(-1))
       tmp_size = new_size;
     }
     this->resize(size);
     this->size_ = std::min(this->size_, tmp_size);
   }
 
   /// change the size of the Array
   virtual void resize(Int size) {
     if (size * this->nb_component == 0) {
       free(values); // NOLINT: cppcoreguidelines-no-malloc
       values = nullptr;
       this->allocated_size = 0;
     } else {
       if (this->values == nullptr) {
         this->allocate(size, this->nb_component);
         return;
       }
 
       Int diff = size - allocated_size;
       Int size_to_allocate = (std::abs(diff) > AKANTU_MIN_ALLOCATION)
                                  ? size
                                  : (diff > 0)
                                        ? allocated_size + AKANTU_MIN_ALLOCATION
                                        : allocated_size;
 
       if (size_to_allocate ==
           allocated_size) { // otherwhy the reserve + push_back might fail...
         this->size_ = size;
         return;
       }
 
       auto * tmp_ptr = reinterpret_cast<T *>( // NOLINT
           realloc(this->values,
                   size_to_allocate * this->nb_component * sizeof(T)));
 
       if (tmp_ptr == nullptr) {
         throw std::bad_alloc();
       }
 
       this->values = tmp_ptr;
       this->allocated_size = size_to_allocate;
     }
 
     this->size_ = size;
   }
 
   /// change the size of the Array and initialize the values
   virtual void resize(Int size, const T & val) {
     Int tmp_size = this->size_;
     this->resize(size);
     if (size > tmp_size) {
       // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
       std::fill_n(values + this->nb_component * tmp_size,
                   (size - tmp_size) * this->nb_component, val);
     }
   }
 
   /// get the amount of space allocated in bytes
   inline UInt getMemorySize() const final {
     return this->allocated_size * this->nb_component * sizeof(T);
   }
 
   /// Get the real size allocated in memory
   inline Int getAllocatedSize() const { return this->allocated_size; }
 
   /// give the address of the memory allocated for this vector
   [[deprecated("use data instead to be stl compatible")]] T * storage() const {
     return values;
   };
   T * data() const { return values; };
 
 protected:
   /// allocation type agnostic  data access
   T * values{nullptr};
 
   Int allocated_size{0};
 };
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline auto Array<T, is_scal>::operator()(Int i, Int j) -> reference {
   AKANTU_DEBUG_ASSERT(this->size_ > 0,
                       "The array \"" << this->id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < this->size_) && (j < this->nb_component),
                       "The value at position ["
                           << i << "," << j << "] is out of range in array \""
                           << this->id << "\"");
   return this->values[i * this->nb_component + j];
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline auto Array<T, is_scal>::operator()(Int i, Int j) const
     -> const_reference {
   AKANTU_DEBUG_ASSERT(this->size_ > 0,
                       "The array \"" << this->id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < this->size_) && (j < this->nb_component),
                       "The value at position ["
                           << i << "," << j << "] is out of range in array \""
                           << this->id << "\"");
   // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
   return this->values[i * this->nb_component + j];
 }
 
 template <class T, bool is_scal>
 inline auto Array<T, is_scal>::operator[](Int i) -> reference {
   AKANTU_DEBUG_ASSERT(this->size_ > 0,
                       "The array \"" << this->id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < this->size_ * this->nb_component),
                       "The value at position ["
                           << i << "] is out of range in array \"" << this->id
                           << "\"");
   return this->values[i];
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline auto Array<T, is_scal>::operator[](Int i) const -> const_reference {
   AKANTU_DEBUG_ASSERT(this->size_ > 0,
                       "The array \"" << this->id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < this->size_ * this->nb_component),
                       "The value at position ["
                           << i << "] is out of range in array \"" << this->id
                           << "\"");
   return this->values[i];
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * 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(Int i) {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG_ASSERT((this->size_ > 0), "The array is empty");
   AKANTU_DEBUG_ASSERT((i < this->size_), "The element at position ["
                                              << i << "] is out of range (" << i
                                              << ">=" << this->size_ << ")");
 
   if (i != (this->size_ - 1)) {
     for (Idx j = 0; j < this->nb_component; ++j) {
       this->values[i * this->nb_component + j] =
           this->values[(this->size_ - 1) * this->nb_component + j];
     }
   }
 
   this->resize(this->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> & other) {
   AKANTU_DEBUG_ASSERT((this->size_ == other.size_) &&
                           (this->nb_component == other.nb_component),
                       "The too array don't have the same sizes");
 
   T * a = this->values;
   T * b = vect.data();
   for (Idx i = 0; i < this->size_ * this->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> & other) {
   AKANTU_DEBUG_ASSERT((this->size_ == other.size()) &&
                           (this->nb_component == other.nb_component),
                       "The too array don't have the same sizes");
 
   T * a = this->values;
   T * b = vect.data();
   for (Idx i = 0; i < this->size_ * this->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
  */
 
 template <class T, bool is_scal>
 Array<T, is_scal> & Array<T, is_scal>::operator*=(const T & alpha) {
   T * a = this->values;
   for (Idx i = 0; i < this->size_ * this->nb_component; ++i) {
     *a++ *= alpha;
   }
 
   return *this;
 }
 
 /* --------------------------------------------------------------------------
  */
 /**
  * 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> & other) const {
   bool equal = this->nb_component == other.nb_component &&
                this->size_ == other.size_ && this->id == other.id;
   if (not equal) {
     return false;
 
   if (this->values == array.data()) {
     return true;
   }
   return std::equal(this->values,
                     this->values + this->size_ * this->nb_component,
                     array.data());
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 bool Array<T, is_scal>::operator!=(const Array<T, is_scal> & other) const {
   return !operator==(other);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * 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(this->nb_component == vm.size(),
                       "The size of the object does not "
                       "match the number of components");
   for (T * it = this->values;
        it < this->values + this->nb_component * this->size_;
        it += this->nb_component) {
     std::copy_n(vm.data(), this->nb_component, it);
   }
 }
 /* --------------------------------------------------------------------------
  */
 template <class T, bool is_scal>
 void Array<T, is_scal>::append(const Array<T> & other) {
   AKANTU_DEBUG_ASSERT(
       this->nb_component == other.nb_component,
       "Cannot append an array with a different number of component");
   Idx old_size = this->size_;
   this->resize(this->size_ + other.size());
 
   T * tmp = this->values + this->nb_component * old_size;
   std::copy_n(other.data(), other.size() * this->nb_component, tmp);
 }
 
 /* --------------------------------------------------------------------------
  */
 /* Functions Array<T, is_scal> */
 /* --------------------------------------------------------------------------
  */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(Int size, Int nb_component, const ID & id)
     : parent(size, nb_component, id) {}
 
 template <>
 inline Array<std::string, false>::Array(Int size, Int nb_component,
                                         const ID & id)
     : parent(size, nb_component, "", id) {}
 
 /* --------------------------------------------------------------------------
  */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(Int size, Int nb_component, const_reference value,
                          const ID & id)
     : parent(size, nb_component, value, id) {}
 
 /* --------------------------------------------------------------------------
  */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(const Array & vect, const ID & id)
     : parent(vect, id) {}
 
 /* --------------------------------------------------------------------------
  */
 template <class T, bool is_scal>
 Array<T, is_scal> &
 Array<T, is_scal>::operator=(const Array<T, is_scal> & other) {
   AKANTU_DEBUG_WARNING("You are copying the array "
                        << this->id << " are you sure it is on purpose");
 
   if (&other == this) {
     return *this;
   }
 
   parent::operator=(other);
   return *this;
 }
 
 /* --------------------------------------------------------------------------
  */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(const std::vector<T> & vect) : parent(vect) {}
 
 /* --------------------------------------------------------------------------
  */
 template <class T, bool is_scal> Array<T, is_scal>::~Array() = default;
 
 /* --------------------------------------------------------------------------
  */
 /**
  * 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>
 Idx Array<T, is_scal>::find(const_reference 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 : Idx(-1);
 }
 
 /* --------------------------------------------------------------------------
  */
 // template <class T, bool is_scal> UInt Array<T,
 // is_scal>::find(T elem[]) const
 // {
 //   AKANTU_DEBUG_IN();
 //   T * it = this->values;
 //   UInt i = 0;
 //   for (; i < this->size_; ++i) {
 //     if (*it == elem[0]) {
 //       T * cit = it;
 //       UInt c = 0;
 //       for (; (c < this->nb_component) && (*cit ==
 //       elem[c]); ++c, ++cit)
 //         ;
 //       if (c == this->nb_component) {
 //         AKANTU_DEBUG_OUT();
 //         return i;
 //       }
 //     }
 //     it += this->nb_component;
 //   }
 //   return UInt(-1);
 // }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <template <typename> class C, typename>
 inline Idx Array<T, is_scal>::find(const C<T> & elem) {
   AKANTU_DEBUG_ASSERT(elem.size() == this->nb_component,
                       "Cannot find an element with a wrong size ("
                           << elem.size() << ") != " << this->nb_component);
   return this->find(elem.data());
 }
 
 /* --------------------------------------------------------------------------
  */
 /**
  * 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.
  * @param no_sanity_check turns off all checkes
  */
 template <class T, bool is_scal>
 void Array<T, is_scal>::copy(const Array<T, is_scal> & other,
                              bool no_sanity_check) {
   AKANTU_DEBUG_IN();
 
   if (not no_sanity_check and (other.nb_component != this->nb_component)) {
     AKANTU_ERROR("The two arrays do not have the same "
                  "number of components");
   }
 
   this->resize((other.size_ * other.nb_component) / this->nb_component);
 
   std::copy_n(vect.data(), this->size_ * this->nb_component, this->values);
 
   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) {
     std::string space(indent, AKANTU_INDENT);
 
     stream << space << " + values         : {";
     for (Idx i = 0; i < vect.size(); ++i) {
       stream << "{";
       for (Idx 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(indent, 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->getAllocatedSize()
          << std::endl;
   stream << space
          << " + memory size    : " << printMemorySize<T>(this->getMemorySize())
          << std::endl;
   if (not AKANTU_DEBUG_LEVEL_IS_TEST()) {
     stream << space << " + address        : " << std::hex << this->values
            << std::dec << std::endl;
   }
 
   stream.precision(prec);
   stream.flags(ff);
 
   if (AKANTU_DEBUG_TEST(dblDump) || AKANTU_DEBUG_LEVEL_IS_TEST()) {
     ArrayPrintHelper<is_scal or std::is_enum<T>::value>::print_content(
         *this, stream, indent);
   }
 
   stream << space << "]" << std::endl;
 }
 
 /* --------------------------------------------------------------------------
  */
 /* Inline Functions ArrayBase */
 /* --------------------------------------------------------------------------
  */
 
 // inline bool ArrayBase::empty() { return (this->size_ ==
 // 0); }
 
 #ifndef SWIG
 /* -------------------------------------------------------------------------- */
 /* Begin/End functions implementation                                         */
 /* -------------------------------------------------------------------------- */
 namespace detail {
   template <class Tuple, size_t... Is>
   constexpr auto take_front_impl(Tuple && t,
                                  std::index_sequence<Is...> /*idxs*/) {
     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... 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) {
     const auto is_const_arr =
         std::is_const<std::remove_reference_t<Arr>>::value;
     using type = ViewIteratorHelper_t<sizeof...(Ns) - 1, T>;
     using iterator = std::conditional_t<is_const_arr, const_view_iterator<type>,
                                         view_iterator<type>>;
     static_assert(sizeof...(Ns), "You should provide a least one size");
 
     if (array.getNbComponent() * array.size() !=
         Int(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 && it =
         aka::apply([&](auto... n) { return iterator(data, n...); },
                    take_front<sizeof...(Ns) - 1>(std::make_tuple(ns...)));
 
     return it;
   }
 } // namespace detail
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <typename... Ns>
 inline auto Array<T, is_scal>::begin(Ns &&... ns) {
   return detail::get_iterator(*this, this->values, std::forward<Ns>(ns)...,
                               this->size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline auto Array<T, is_scal>::end(Ns &&... ns) {
   return detail::get_iterator(*this,
                               this->values + this->nb_component * this->size_,
                               std::forward<Ns>(ns)..., this->size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline auto Array<T, is_scal>::begin(Ns &&... ns) const {
   return detail::get_iterator(*this, this->values, std::forward<Ns>(ns)...,
                               this->size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline auto Array<T, is_scal>::end(Ns &&... ns) const {
   return detail::get_iterator(*this,
                               this->values + this->nb_component * this->size_,
                               std::forward<Ns>(ns)..., this->size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline auto Array<T, is_scal>::begin_reinterpret(Ns &&... ns) {
   return detail::get_iterator(*this, this->values, std::forward<Ns>(ns)...);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline auto Array<T, is_scal>::end_reinterpret(Ns &&... ns) {
   return detail::get_iterator(
       *this, this->values + detail::product_all(std::forward<Ns>(ns)...),
       std::forward<Ns>(ns)...);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline auto Array<T, is_scal>::begin_reinterpret(Ns &&... ns) const {
   return detail::get_iterator(*this, this->values, std::forward<Ns>(ns)...);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline auto Array<T, is_scal>::end_reinterpret(Ns &&... ns) const {
   return detail::get_iterator(
       *this, 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() = default;
     ArrayView(Array && array, Ns... ns) noexcept
         : array(array), sizes(std::move(ns)...) {}
 
     ArrayView(const ArrayView & array_view) = default;
     ArrayView & operator=(const ArrayView & array_view) = default;
 
     ArrayView(ArrayView && array_view) noexcept = default;
     ArrayView & operator=(ArrayView && array_view) noexcept = default;
 
     auto begin() {
       return aka::apply(
           [&](auto &&... ns) {
             return detail::get_iterator(array.get(), array.get().data(),
-                                        std::forward<Ns>(ns)...);
+                                        std::forward<decltype(ns)>(ns)...);
           },
           sizes);
     }
 
     auto begin() const {
       return aka::apply(
           [&](auto &&... ns) {
             return detail::get_iterator(array.get(), array.get().data(),
-                                        std::forward<Ns>(ns)...);
+                                        std::forward<decltype(ns)>(ns)...);
           },
           sizes);
     }
 
     auto end() {
       return aka::apply(
           [&](auto &&... ns) {
             return detail::get_iterator(
                 array.get(),
                 array.get().data() +
-                    detail::product_all(std::forward<Ns>(ns)...),
-                std::forward<Ns>(ns)...);
+                    detail::product_all(std::forward<decltype(ns)>(ns)...),
+                std::forward<decltype(ns)>(ns)...);
           },
           sizes);
     }
 
     auto end() const {
       return aka::apply(
           [&](auto &&... ns) {
             return detail::get_iterator(
                 array.get(),
                 array.get().data() +
-                    detail::product_all(std::forward<Ns>(ns)...),
-                std::forward<Ns>(ns)...);
+                    detail::product_all(std::forward<decltype(ns)>(ns)...),
+                std::forward<decltype(ns)>(ns)...);
           },
           sizes);
     }
 
+    auto cbegin() const { return this->begin(); }
+    auto cend() const { return this->end(); }
+
     auto size() const {
       return std::get<std::tuple_size<tuple>::value - 1>(sizes);
     }
 
     auto dims() const { return std::tuple_size<tuple>::value - 1; }
 
   private:
     std::reference_wrapper<std::remove_reference_t<Array>> array;
     tuple sizes;
   };
 } // namespace detail
 
 /* -------------------------------------------------------------------------- */
 template <typename Array, typename... Ns>
 decltype(auto) make_view(Array && array, const Ns... ns) {
   static_assert(aka::conjunction<std::is_integral<std::decay_t<Ns>>...>::value,
                 "Ns should be integral types");
   AKANTU_DEBUG_ASSERT((detail::product_all(ns...) != 0),
                       "You must specify non zero dimensions");
   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>
 inline auto Array<T, is_scal>::erase(const view_iterator<R> & it) {
   T * curr = it.data();
   Idx pos = (curr - this->values) / this->nb_component;
   erase(pos);
   view_iterator<R> rit = it;
   return --rit;
 }
 
 } // namespace akantu
 
 #endif /* AKANTU_AKA_ARRAY_TMPL_HH_ */
diff --git a/src/common/aka_math.hh b/src/common/aka_math.hh
index 8da259445..0092c3257 100644
--- a/src/common/aka_math.hh
+++ b/src/common/aka_math.hh
@@ -1,294 +1,298 @@
 /**
  * @file   aka_math.hh
  *
  * @author Ramin Aghababaei <ramin.aghababaei@epfl.ch>
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Marion Estelle Chambart <marion.chambart@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 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: Tue Feb 09 2021
  *
  * @brief  mathematical operations
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 /* -------------------------------------------------------------------------- */
 #include <utility>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_AKA_MATH_H_
 #define AKANTU_AKA_MATH_H_
 
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 
 namespace Math {
   /// tolerance for functions that need one
   extern Real tolerance; // NOLINT
 
   /* ------------------------------------------------------------------------ */
   /* Matrix algebra                                                           */
   /* ------------------------------------------------------------------------ */
   // /// @f$ y = A*x @f$
   // static void matrix_vector(UInt m, UInt n, const Array<Real, true> & A,
   //                           const Array<Real, true> & x, Array<Real, true> & y,
   //                           Real alpha = 1.);
 
   // /// @f$ y = A*x @f$
   // static inline void matrix_vector(UInt m, UInt n, Real * A, Real * x, Real * y,
   //                                  Real alpha = 1.);
 
   // /// @f$ y = A^t*x @f$
   // static inline void matrixt_vector(UInt m, UInt n, Real * A, Real * x,
   //                                   Real * y, Real alpha = 1.);
 
   // /// @f$ C = A*B @f$
   // static void matrix_matrix(UInt m, UInt n, UInt k, const Array<Real, true> & A,
   //                           const Array<Real, true> & B, Array<Real, true> & C,
   //                           Real alpha = 1.);
 
   // /// @f$ C = A*B^t @f$
   // static void matrix_matrixt(UInt m, UInt n, UInt k,
   //                            const Array<Real, true> & A,
   //                            const Array<Real, true> & B, Array<Real, true> & C,
   //                            Real alpha = 1.);
 
   // /// @f$ C = A*B @f$
   // static inline void matrix_matrix(UInt m, UInt n, UInt k, Real * A, Real * B,
   //                                  Real * C, Real alpha = 1.);
 
   // /// @f$ C = A^t*B @f$
   // static inline void matrixt_matrix(UInt m, UInt n, UInt k, Real * A, Real * B,
   //                                   Real * C, Real alpha = 1.);
 
   // /// @f$ C = A*B^t @f$
   // static inline void matrix_matrixt(UInt m, UInt n, UInt k, Real * A, Real * B,
   //                                   Real * C, Real alpha = 1.);
 
   // /// @f$ C = A^t*B^t @f$
   // static inline void matrixt_matrixt(UInt m, UInt n, UInt k, Real * A, Real * B,
   //                                    Real * C, Real alpha = 1.);
 
   // template <bool tr_A, bool tr_B>
   // static inline void matMul(UInt m, UInt n, UInt k, Real alpha, Real * A,
   //                           Real * B, Real beta, Real * C);
 
   // template <bool tr_A>
   // static inline void matVectMul(UInt m, UInt n, Real alpha, Real * A, Real * x,
   //                               Real beta, Real * y);
 
   // static inline void aXplusY(UInt n, Real alpha, Real * x, Real * y);
 
   // static inline void matrix33_eigenvalues(Real * A, Real * Adiag);
 
   // static inline void matrix22_eigenvalues(Real * A, Real * Adiag);
   // template <Int dim> static inline void eigenvalues(Real * A, Real * d);
 
   // /// solve @f$ A x = \Lambda x @f$ and return d and V such as @f$ A V[i:] =
   // /// d[i] V[i:]@f$
   // template <typename T>
   // static void matrixEig(UInt n, T * A, T * d, T * V = nullptr);
 
   // /// determinent of a 2x2 matrix
   // static inline Real det2(const Real * mat);
   /// determinent of a 3x3 matrix
   static inline Real det3(const Real * mat);
   
   // /// determinent of a nxn matrix
   // template <UInt n> static inline Real det(const Real * mat);
   // /// determinent of a nxn matrix
   // template <typename T> static inline T det(UInt n, const T * mat);
 
   // /// inverse a nxn matrix
   // template <UInt n> static inline void inv(const Real * mat, Real * inv);
   // /// inverse a nxn matrix
   // template <typename T> static inline void inv(UInt n, const T * mat, T * inv);
   // /// inverse a 3x3 matrix
   // static inline void inv3(const Real * mat, Real * inv);
   // /// inverse a 2x2 matrix
   // static inline void inv2(const Real * mat, Real * inv);
 
   /// solve A x = b using a LU factorization
   template <typename T>
   inline void solve(UInt n, const T * A, T * x, const T * b);
 
   // /// return the double dot product between 2 tensors in 2d
   // static inline Real matrixDoubleDot22(Real * A, Real * B);
 
   // /// return the double dot product between 2 tensors in 3d
   // static inline Real matrixDoubleDot33(Real * A, Real * B);
 
   // /// extension of the double dot product to two 2nd order tensor in dimension n
   // static inline Real matrixDoubleDot(UInt n, Real * A, Real * B);
 
   // /* ------------------------------------------------------------------------ */
   // /* Array algebra                                                            */
   // /* ------------------------------------------------------------------------ */
   /// vector cross product
   static inline void vectorProduct3(const Real * v1, const Real * v2,
                                     Real * res);
   
   /// normalize a vector
   inline void normalize2(Real * v);
 
   /// normalize a vector
   inline void normalize3(Real * v);
 
   /// return norm of a 2-vector
   inline Real norm2(const Real * v);
 
   /// return norm of a 3-vector
   inline Real norm3(const Real * v);
 
   // /// return norm of a vector
   // static inline Real norm(UInt n, const Real * v);
 
   // /// return the dot product between 2 vectors in 2d
   // static inline Real vectorDot2(const Real * v1, const Real * v2);
 
   // /// return the dot product between 2 vectors in 3d
   // static inline Real vectorDot3(const Real * v1, const Real * v2);
 
   // /// return the dot product between 2 vectors
   // static inline Real vectorDot(Real * v1, Real * v2, UInt n);
 
   /* ------------------------------------------------------------------------ */
   /* Geometry                                                                 */
   /* ------------------------------------------------------------------------ */
   /// compute normal a normal to a vector
   inline void normal2(const Real * vec, Real * normal);
 
   /// compute normal a normal to a vector
   inline void normal3(const Real * vec1, const Real * vec2, Real * normal);
 
   /// compute the tangents to an array of normal vectors
   void compute_tangents(const Array<Real> & normals, Array<Real> & tangents);
 
   /// distance in 2D between x and y
   inline Real distance_2d(const Real * x, const Real * y);
 
   /// distance in 3D between x and y
   inline Real distance_3d(const Real * x, const Real * y);
 
   /// radius of the in-circle of a triangle in 2d space
   static inline Real triangle_inradius(const Vector<Real> & coord1,
                                        const Vector<Real> & coord2,
                                        const Vector<Real> & coord3);
 
   /// radius of the in-circle of a tetrahedron
   inline Real tetrahedron_inradius(const Real * coord1, const Real * coord2,
                                    const Real * coord3, const Real * coord4);
 
   /// volume of a tetrahedron
   inline Real tetrahedron_volume(const Real * coord1, const Real * coord2,
                                  const Real * coord3, const Real * coord4);
 
   /// compute the barycenter of n points
   inline void barycenter(const Real * coord, UInt nb_points,
                          UInt spatial_dimension, Real * barycenter);
 
   /// vector between x and y
   inline void vector_2d(const Real * x, const Real * y, Real * res);
 
   /// vector pointing from x to y in 3 spatial dimension
   inline void vector_3d(const Real * x, const Real * y, Real * res);
 
   /// test if two scalar are equal within a given tolerance
   inline bool are_float_equal(Real x, Real y);
 
   /// test if two vectors are equal within a given tolerance
   inline bool are_vector_equal(UInt n, Real * x, Real * y);
 
 #ifdef isnan
 #error                                                                         \
     "You probably  included <math.h> which  is incompatible with aka_math  please use\
 <cmath> or add a \"#undef isnan\" before akantu includes"
 #endif
   /// test if a real is a NaN
   inline bool isnan(Real x);
 
   /// test if the line x and y intersects each other
   inline bool intersects(Real x_min, Real x_max, Real y_min, Real y_max);
 
   /// test if a is in the range [x_min, x_max]
   inline bool is_in_range(Real a, Real x_min, Real x_max);
 
   inline Real getTolerance() { return Math::tolerance; }
   inline void setTolerance(Real tol) { Math::tolerance = tol; }
 
   template <UInt p, typename T> inline T pow(T x);
 
   template <class T1, class T2,
             std::enable_if_t<std::is_integral<T1>::value and
                              std::is_integral<T2>::value> * = nullptr>
   inline Real kronecker(T1 i, T2 j) {
     return static_cast<Real>(i == j);
   }
+/* -------------------------------------------------------------------------- */
+  template <typename T> static inline constexpr T pow(T x, int p) {
+    return p == 0 ? T(1) : (pow(x, p-1) * x);
+  }
 
   /// reduce all the values of an array, the summation is done in place and the
   /// array is modified
   Real reduce(Array<Real> & array);
 
   class NewtonRaphson {
   public:
     NewtonRaphson(Real tolerance, Real max_iteration)
         : tolerance(tolerance), max_iteration(max_iteration) {}
 
     template <class Functor> Real solve(const Functor & funct, Real x_0);
 
   private:
     Real tolerance;
     Real max_iteration;
   };
 
   struct NewtonRaphsonFunctor {
     explicit NewtonRaphsonFunctor(const std::string & name) : name(name) {}
 
     virtual ~NewtonRaphsonFunctor() = default;
 
     NewtonRaphsonFunctor(const NewtonRaphsonFunctor & other) = default;
     NewtonRaphsonFunctor(NewtonRaphsonFunctor && other) noexcept = default;
     NewtonRaphsonFunctor &
     operator=(const NewtonRaphsonFunctor & other) = default;
     NewtonRaphsonFunctor &
     operator=(NewtonRaphsonFunctor && other) noexcept = default;
 
     virtual Real f(Real x) const = 0;
     virtual Real f_prime(Real x) const = 0;
     std::string name;
   };
 } // namespace Math
 } // namespace akantu
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 #include "aka_math_tmpl.hh"
 
 #endif /* AKANTU_AKA_MATH_H_ */
diff --git a/src/common/aka_types.hh b/src/common/aka_types.hh
index bddaaed8e..25499f352 100644
--- a/src/common/aka_types.hh
+++ b/src/common/aka_types.hh
@@ -1,804 +1,832 @@
 /**
  * @file   aka_types.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Feb 17 2011
  * @date last modification: Wed Dec 09 2020
  *
  * @brief  description of the "simple" types
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_compatibilty_with_cpp_standard.hh"
 #include "aka_error.hh"
 #include "aka_fwd.hh"
 #include "aka_math.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <array>
 #include <initializer_list>
 #include <numeric>
 #include <type_traits>
 
 #ifndef __AKANTU_AKA_TYPES_HH__
 #define __AKANTU_AKA_TYPES_HH__
 
 /* -------------------------------------------------------------------------- */
 namespace aka {
 template <typename T> struct is_eigen_map : public std::false_type {};
 } // namespace aka
 
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE akantu::Idx
+#define EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION Eigen::ColMajor
 /* -------------------------------------------------------------------------- */
 #define EIGEN_MATRIXBASE_PLUGIN "aka_types_eigen_matrix_base_plugin.hh"
 #define EIGEN_MATRIX_PLUGIN "aka_types_eigen_matrix_plugin.hh"
 #define EIGEN_PLAINOBJECTBASE_PLUGIN                                           \
   "aka_types_eigen_plain_object_base_plugin.hh"
 #include <Eigen/Dense>
 #include <Eigen/Eigenvalues>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 using Eigen::Ref;
 
 template <typename T, Eigen::Index n = Eigen::Dynamic>
 using Vector = Eigen::Matrix<T, n, 1>;
 
 template <typename T, Eigen::Index m = Eigen::Dynamic,
           Eigen::Index n = Eigen::Dynamic>
-using Matrix = Eigen::Matrix<T, m, n, Eigen::AutoAlign | Eigen::ColMajor>;
+using Matrix = Eigen::Matrix<T, m, n>;
 
 template <typename T, Eigen::Index n = Eigen::Dynamic>
 using VectorProxy =
     Eigen::Map<std::conditional_t<std::is_const<T>::value,
                                   const Vector<std::remove_const_t<T>, n>,
                                   Vector<std::remove_const_t<T>, n>>>;
 
 template <typename T, Eigen::Index m = Eigen::Dynamic,
           Eigen::Index n = Eigen::Dynamic>
 using MatrixProxy =
     Eigen::Map<std::conditional_t<std::is_const<T>::value,
                                   const Matrix<std::remove_const_t<T>, m, n>,
                                   Matrix<std::remove_const_t<T>, m, n>>>;
 
 using VectorXr = Vector<Real>;
 using MatrixXr = Matrix<Real>;
 
 enum NormType : int8_t { L_1 = 1, L_2 = 2, L_inf = -1 };
 
 struct TensorTraitBase {};
 template <size_t n> struct TensorTrait : public TensorTraitBase {};
 
 } // namespace akantu
 
 namespace aka {
 template <typename Derived>
 using is_matrice = aka::bool_constant<not Derived::IsVectorAtCompileTime>;
 
 template <typename Derived>
 using is_vector = aka::bool_constant<Derived::IsVectorAtCompileTime>;
 
 template <typename... Ds>
 using are_vectors = aka::conjunction<is_vector<Ds>...>;
 
 template <typename... Ds>
 using are_matrices = aka::conjunction<is_matrice<Ds>...>;
 
 template <typename... Ds>
 using enable_if_matrices_t = std::enable_if_t<are_matrices<Ds...>::value>;
 
 // template <typename T> struct is_eigen_map : public std::false_type {};
 
 template <typename PlainObjectType, int MapOptions, typename StrideType>
 struct is_eigen_map<Eigen::Map<PlainObjectType, MapOptions, StrideType>>
     : public std::true_type {};
 } // namespace aka
 
 /* -------------------------------------------------------------------------- */
 namespace aka {
 
 template <typename T>
 struct is_tensor : public std::is_base_of<akantu::TensorTraitBase, T> {};
 
 template <typename PlainObjectType, int MapOptions, typename StrideType>
 struct is_tensor<Eigen::Map<PlainObjectType, MapOptions, StrideType>>
     : public std::true_type {};
 
 template <typename T, size_t n>
 using is_tensor_n = std::is_base_of<akantu::TensorTrait<n>, T>;
 
 //   template <typename T> using is_vector = is_tensor_n<T, 1>;
 
 //   template <typename T> using is_matrix = is_tensor_n<T, 2>;
 
 template <std::size_t n, typename T = void, typename... Ts>
 using enable_if_tensors_n = std::enable_if<
     aka::conjunction<
         is_tensor_n<Ts, n>...,
         std::is_same<
             std::common_type_t<std::decay_t<typename Ts::value_type>...>,
             std::decay_t<typename Ts::value_type>>...>::value,
     T>;
 
 template <std::size_t n, typename T = void, typename... Ts>
 using enable_if_tensors_n_t = typename enable_if_tensors_n<n, T, Ts...>::type;
 
 //   template <typename T = void, typename... Ms>
 //   using enable_if_vectors_t = typename enable_if_tensors_n<1, T,
 //   Ms...>::type; template <typename T = void, typename... Ms>
 
 //   using enable_if_matricies_t = typename enable_if_tensors_n<2, T,
 //   Ms...>::type;
 } // namespace aka
 
 namespace akantu {
-template <typename T, std::size_t ndim> class TensorBase;
-template <typename T, size_t ndim> class TensorProxy;
-template <typename T, size_t ndim> class Tensor;
+template <typename T, Int ndim> class TensorBase;
+template <typename T, Int ndim> class TensorProxy;
+template <typename T, Int ndim> class Tensor;
 } // namespace akantu
 
 #include "aka_view_iterators.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
-template <typename T, std::size_t ndim>
-class TensorBase : public TensorTrait<ndim> {
+template <typename T, Int ndim> class TensorBase : public TensorTrait<ndim> {
   using RetType = TensorBase<T, ndim>;
   static_assert(ndim > 2, "TensorBase cannot by used for dimensions < 3");
 
 protected:
-  using idx_t = std::size_t;
+  using idx_t = Int;
 
   template <typename... Args>
   using valid_args_t = typename std::enable_if<
       aka::conjunction<aka::disjunction<std::is_integral<Args>,
                                         std::is_enum<Args>>...>::value and
           ndim == sizeof...(Args),
       int>::type;
 
 public:
   using proxy = TensorBase<T, ndim>;
 
-  template <size_t _ndim = ndim,
+  template <Int _ndim = ndim,
             std::enable_if_t<_ndim == 1 or _ndim == 2, int> = 0>
   TensorBase() {
     n.fill(0);
   }
 
   TensorBase() { n.fill(0); }
 
   template <typename... Args, valid_args_t<Args...> = 0>
   constexpr TensorBase(Args... args)
       : n{idx_t(args)...}, _size(detail::product_all(args...)) {}
 
   constexpr TensorBase(const TensorBase & other)
       : n(other.n), _size(other._size), values(other.values) {}
 
   constexpr TensorBase(TensorBase && other)
       : n(std::move(other.n)), _size(std::exchange(other._size, 0)),
         values(std::exchange(other.values, nullptr)) {}
 
 protected:
-  template <typename Array, std::size_t... I>
+  template <typename Array, Int... I>
   constexpr auto check_indices(const Array & idx,
                                std::index_sequence<I...>) const {
     bool result = true;
     (void)std::initializer_list<int>{(result &= idx[I] < n[I], 0)...};
     return result;
   }
 
   template <typename... Args> constexpr auto compute_index(Args... args) const {
     std::array<idx_t, sizeof...(Args)> idx{idx_t(args)...};
     AKANTU_DEBUG_ASSERT(
         check_indices(idx, std::make_index_sequence<sizeof...(Args)>{}),
         "The indexes are out of bound");
 
     idx_t index = 0, i = (sizeof...(Args)) - 1;
     for (; i > 0; i--) {
       index += idx[i];
       if (i > 0)
         index *= n[i - 1];
     }
     return index + idx[0];
   }
 
-  template <typename S, std::size_t... I>
+  template <typename S, int... I>
   constexpr auto get_slice(idx_t s, std::index_sequence<I...>) {
     return S(this->values + s * detail::product_all(n[I]...), n[I]...);
   }
 
   template <typename S, std::size_t... I>
   constexpr auto get_slice(idx_t s, std::index_sequence<I...>) const {
     return S(this->values + s * detail::product_all(n[I]...), n[I]...);
   }
 
 public:
   template <typename... Args, valid_args_t<Args...> = 0>
   inline T & operator()(Args... args) {
     return *(this->values + compute_index(std::move(args)...));
   }
 
   template <typename... Args, valid_args_t<Args...> = 0>
   inline const T & operator()(Args... args) const {
     return *(this->values + compute_index(std::move(args)...));
   }
 
   template <idx_t _ndim = ndim, std::enable_if_t<(_ndim > 3), int> = 0>
   inline auto operator()(idx_t s) {
     return get_slice<TensorProxy<T, ndim - 1>>(
         std::move(s), std::make_index_sequence<ndim - 1>());
   }
 
   template <idx_t _ndim = ndim, std::enable_if_t<(_ndim > 3), int> = 0>
   inline auto operator()(idx_t s) const {
     return get_slice<TensorProxy<T, ndim - 1>>(
         std::move(s), std::make_index_sequence<ndim - 1>());
   }
 
   template <idx_t _ndim = ndim, std::enable_if_t<_ndim == 3, int> = 0>
   inline auto operator()(idx_t s) {
     return get_slice<
         Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>>>(
         std::move(s), std::make_index_sequence<ndim - 1>());
   }
 
   template <idx_t _ndim = ndim, std::enable_if_t<_ndim == 3, int> = 0>
   inline auto operator()(idx_t s) const {
     return get_slice<
         Eigen::Map<const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>>>(
         std::move(s), std::make_index_sequence<ndim - 1>());
   }
 
 protected:
   template <class Operator> RetType & transform(Operator && op) {
     std::transform(this->values, this->values + this->_size, this->values,
                    std::forward<Operator>(op));
     return *(static_cast<RetType *>(this));
   }
 
   template <class Other, class Operator>
   RetType & transform(Other && other, Operator && op) {
     AKANTU_DEBUG_ASSERT(_size == other.size(),
                         "The two tensors do not have the same size "
                             << this->_size << " != " << other._size);
 
     std::transform(this->values, this->values + this->_size, other.values,
                    this->values, std::forward<Operator>(op));
     return *(static_cast<RetType *>(this));
   }
 
   template <class Operator> T accumulate(T init, Operator && op) {
     return std::accumulate(this->values, this->values + this->_size,
                            std::move(init), std::forward<Operator>(op));
   }
 
   template <class Other, class Init, class Accumulate, class Operator>
   T transform_reduce(Other && other, T init, Accumulate && acc,
                      Operator && op) {
     return std::inner_product(
         this->values, this->values + this->_size, other.data(), std::move(init),
         std::forward<Accumulate>(acc), std::forward<Operator>(op));
   }
 
   // arithmetic operators ------------------------------------------------------
   /* ------------------------------------------------------------------------ */
 public:
   inline decltype(auto) operator+=(const TensorBase & other) {
     return transform(other, [](auto && a, auto && b) { return a + b; });
   }
 
   /* ------------------------------------------------------------------------ */
   inline TensorBase & operator-=(const TensorBase & other) {
     return transform(other, [](auto && a, auto && b) { return a - b; });
   }
 
   /* ------------------------------------------------------------------------ */
   inline TensorBase & operator+=(const T & x) {
     return transform([&x](auto && a) { return a + x; });
   }
 
   /* ------------------------------------------------------------------------ */
   inline TensorBase & operator-=(const T & x) {
     return transform([&x](auto && a) { return a - x; });
   }
 
   /* ------------------------------------------------------------------------ */
   inline TensorBase & operator*=(const T & x) {
     return transform([&x](auto && a) { return a * x; });
   }
 
   /* ---------------------------------------------------------------------- */
   inline TensorBase & operator/=(const T & x) {
     return transform([&x](auto && a) { return a / x; });
   }
 
   /// Y = \alpha X + Y
   inline TensorBase & aXplusY(const TensorBase & other, const T alpha = 1.) {
     return transform(other,
                      [&alpha](auto && a, auto && b) { return alpha * a + b; });
   }
 
   /* ------------------------------------------------------------------------ */
 
   template <typename TO, std::size_t ndim_o, bool is_proxy_o>
   friend class TensorBase;
 
   T * data() { return values; }
   const T * data() const { return values; }
 
   // clang-format off
   [[deprecated("use data instead to be stl compatible")]]
   T * storage() {
     return values;
   }
 
   [[deprecated("use data instead to be stl compatible")]]
   const T * storage() const {
     return values;
   }
   // clang-format on
 
   auto size() const { return _size; }
   auto size(idx_t i) const {
     AKANTU_DEBUG_ASSERT(i < ndim, "This tensor has only " << ndim
                                                           << " dimensions, not "
                                                           << (i + 1));
     return n[i];
   };
 
   inline void set(const T & t) { std::fill_n(values, _size, t); };
   inline void clear() { set(T()); };
 
 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>
   auto norm() -> std::enable_if_t<norm_type == L_inf, T> const {
     return accumulate(
         T(), [](auto && init, auto && a) { return init + std::abs(a); });
   }
 
   template <NormType norm_type>
   auto norm() -> std::enable_if_t<norm_type == L_1, T> const {
     return accumulate(T(), [](auto && init, auto && a) {
       return std::max(init, std::abs(a));
     });
   }
 
   template <NormType norm_type>
   auto norm() -> std::enable_if_t<norm_type == L_2, T> const {
     return std::sqrt(
         accumulate(T(), [](auto && init, auto && a) { return init + a * a; }));
   }
 
   template <NormType norm_type>
   auto norm() -> std::enable_if_t<(norm_type > L_2), T> const {
     return std::pow(accumulate(T(),
                                [](auto && init, auto && a) {
                                  return init + std::pow(a, norm_type);
                                }),
                     1. / norm_type);
   }
 
   T norm() const { return norm<L_2>(); }
 
 protected:
-  template <std::size_t N, typename... Args,
+  template <Int N, typename... Args,
             std::enable_if_t<(sizeof...(Args) == ndim), int> = 0>
   void serialize(std::ostream & stream, Args... args) const {
     stream << this->operator()(std::move(args)...);
   }
 
-  template <std::size_t N, typename... Args,
+  template <Int N, typename... Args,
             std::enable_if_t<(sizeof...(Args) < ndim), int> = 0>
   void serialize(std::ostream & stream, Args... args) const {
     stream << "[";
     for (idx_t i = 0; i < n[N]; ++i) {
       if (i != 0)
         stream << ",";
       serialize<N + 1>(stream, std::move(args)..., i);
     }
     stream << "]";
   }
 
 public:
   void printself(std::ostream & stream) const { serialize<0>(stream); };
 
 protected:
   template <std::size_t... I>
   constexpr decltype(auto) begin(std::index_sequence<I...>) {
     return view_iterator<ViewIteratorHelper_t<sizeof...(I), T>>(values,
                                                                 n[I]...);
   }
 
   template <std::size_t... I>
   constexpr decltype(auto) end(std::index_sequence<I...>) {
     return view_iterator<ViewIteratorHelper_t<sizeof...(I), T>>(values + _size,
                                                                 n[I]...);
   }
 
+  template <std::size_t... I>
+  constexpr decltype(auto) begin(std::index_sequence<I...>) const {
+    return const_view_iterator<ViewIteratorHelper_t<sizeof...(I), T>>(values,
+                                                                      n[I]...);
+  }
+
+  template <std::size_t... I>
+  constexpr decltype(auto) end(std::index_sequence<I...>) const {
+    return const_view_iterator<ViewIteratorHelper_t<sizeof...(I), T>>(
+        values + _size, n[I]...);
+  }
+
 public:
   decltype(auto) begin() { return begin(std::make_index_sequence<ndim - 1>{}); }
   decltype(auto) end() { return end(std::make_index_sequence<ndim - 1>{}); }
 
+  decltype(auto) begin() const {
+    return begin(std::make_index_sequence<ndim - 1>{});
+  }
+  decltype(auto) end() const {
+    return end(std::make_index_sequence<ndim - 1>{});
+  }
+
 protected:
   // size per dimension
   std::array<idx_t, ndim> n;
 
   // total storage size
   idx_t _size{0};
 
   // actual data location
   T * values{nullptr};
 };
 
 /* -------------------------------------------------------------------------- */
-template <typename T, size_t ndim>
-class TensorProxy : public TensorBase<T, ndim> {
+template <typename T, Int ndim> class TensorProxy : public TensorBase<T, ndim> {
 private:
   using parent = TensorBase<T, ndim>;
 
 public:
   // proxy constructor
   template <typename... Args>
   constexpr TensorProxy(T * data, Args... args) : parent(args...) {
     this->values = data;
   }
 
   constexpr TensorProxy(const TensorProxy<T, ndim> & other) : parent(other) {
     this->values = other.values;
   }
 
   constexpr TensorProxy(const Tensor<T, ndim> & other) : parent(other) {
     this->values = other.values;
   }
 
   // move constructors ---------------------------------------------------------
   // proxy -> proxy
   TensorProxy(TensorProxy && other) : parent(other) {}
 
   TensorProxy & operator=(const TensorBase<T, ndim> & other) {
     AKANTU_DEBUG_ASSERT(
         other.size() == this->size(),
         "You are trying to copy too a tensors proxy with the wrong size "
             << this->_size << " != " << other._size);
 
     static_assert(std::is_trivially_copyable<T>{},
                   "Cannot copy a tensor on non trivial types");
 
     std::copy(other.values, other.values + this->_size, this->values);
     return *this;
   }
 };
 
 /* -------------------------------------------------------------------------- */
-template <typename T, size_t ndim> class Tensor : public TensorBase<T, ndim> {
+template <typename T, Int ndim> class Tensor : public TensorBase<T, ndim> {
 private:
   using parent = TensorBase<T, ndim>;
 
 public:
   template <typename... Args> constexpr Tensor(Args... args) : parent(args...) {
     static_assert(
         std::is_trivially_constructible<T>{},
         "Cannot create a tensor on non trivially constructible types");
     this->values = new T[this->_size];
   }
 
   /* ------------------------------------------------------------------------ */
   virtual ~Tensor() { delete[] this->values; }
 
   // copy constructors ---------------------------------------------------------
   constexpr Tensor(const Tensor & other) : parent(other) {
     this->values = new T[this->_size];
     std::copy(other.values, other.values + this->_size, this->values);
   }
 
   constexpr explicit Tensor(const TensorProxy<T, ndim> & other)
       : parent(other) {
     //    static_assert(false, "Copying data are you sure");
     this->values = new T[this->_size];
     std::copy(other.values, other.values + this->_size, this->values);
   }
 
   // move constructors ---------------------------------------------------------
   // proxy -> proxy, non proxy -> non proxy
   Tensor(Tensor && other) : parent(other) {}
 
   // copy operator -------------------------------------------------------------
   /// operator= copy-and-swap
   Tensor & operator=(const TensorBase<T, ndim> & other) {
     if (&other == this)
       return *this;
 
     std::cout << "Warning: operator= delete data" << std::endl;
     delete[] this->values;
     this->n = other.n;
     this->_size = other._size;
 
     static_assert(
         std::is_trivially_constructible<T>{},
         "Cannot create a tensor on non trivially constructible types");
 
     this->values = new T[this->_size];
 
     static_assert(std::is_trivially_copyable<T>{},
                   "Cannot copy a tensor on non trivial types");
 
     std::copy(other.values, other.values + this->_size, this->values);
 
     return *this;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename T> using Tensor3 = Tensor<T, 3>;
 template <typename T> using Tensor3Proxy = TensorProxy<T, 3>;
 template <typename T> using Tensor3Base = TensorBase<T, 3>;
 
 class ArrayBase;
 
 /* -------------------------------------------------------------------------- */
 namespace details {
   template <typename T> struct MapPlainObjectType { using type = T; };
 
   template <typename PlainObjectType, int MapOptions, typename StrideType>
   struct MapPlainObjectType<
       Eigen::Map<PlainObjectType, MapOptions, StrideType>> {
     using type = PlainObjectType;
   };
 
   template <typename T>
   using MapPlainObjectType_t = typename MapPlainObjectType<T>::type;
 
   template <typename Scalar, Idx...> struct EigenMatrixViewHelper {};
 
   template <typename Scalar, Idx RowsAtCompileTime>
   struct EigenMatrixViewHelper<Scalar, RowsAtCompileTime> {
     using type = Eigen::Matrix<Scalar, RowsAtCompileTime, 1>;
   };
 
   template <typename Scalar, Idx RowsAtCompileTime, Idx ColsAtCompileTime>
   struct EigenMatrixViewHelper<Scalar, RowsAtCompileTime, ColsAtCompileTime> {
     using type = Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime>;
   };
 
   template <typename Scalar, Idx... sizes>
   using EigenMatrixViewHelper_t =
       typename EigenMatrixViewHelper<Scalar, sizes...>::type;
 
   template <typename Array, Idx... sizes> class EigenView {
     static_assert(sizeof...(sizes) == 1 or sizeof...(sizes) == 2,
                   "Eigen only supports Vector and Matrices");
     using size_type = typename std::decay_t<Array>::size_type;
     using value_type = typename std::decay_t<Array>::value_type;
 
   public:
     EigenView(Array && array, decltype(sizes)... sizes_)
         : array(array), sizes_(sizes_...) {}
 
     EigenView(Array && array) : array(array), sizes_(sizes...) {}
 
     EigenView(const EigenView & other) = default;
     EigenView(EigenView && other) = default;
 
     template <typename T = std::remove_reference_t<
                   decltype(*std::declval<Array>().data())>,
               std::enable_if_t<not std::is_const<T>::value> * = nullptr>
     decltype(auto) begin() {
       return aka::make_from_tuple<::akantu::view_iterator<
           Eigen::Map<EigenMatrixViewHelper_t<value_type, sizes...>>>>(
           std::tuple_cat(std::make_tuple(array.get().data()), sizes_));
     }
 
     template <typename T = std::remove_reference_t<
                   decltype(*std::declval<Array>().data())>,
               std::enable_if_t<not std::is_const<T>::value> * = nullptr>
     decltype(auto) end() {
       return aka::make_from_tuple<::akantu::view_iterator<
           Eigen::Map<EigenMatrixViewHelper_t<value_type, sizes...>>>>(
           std::tuple_cat(std::make_tuple(array.get().data() + array_size()),
                          sizes_));
     }
 
     decltype(auto) begin() const {
       return aka::make_from_tuple<::akantu::view_iterator<
           Eigen::Map<const EigenMatrixViewHelper_t<value_type, sizes...>>>>(
           std::tuple_cat(std::make_tuple(array.get().data()), sizes_));
     }
     decltype(auto) end() const {
       return aka::make_from_tuple<::akantu::view_iterator<
           Eigen::Map<const EigenMatrixViewHelper_t<value_type, sizes...>>>>(
           std::tuple_cat(std::make_tuple(array.get().data() + array_size()),
                          sizes_));
     }
 
   private:
     template <
         class A = Array,
         std::enable_if_t<std::is_base_of<ArrayBase, std::decay_t<A>>::value> * =
             nullptr>
     size_type array_size() {
       return array.get().size() * array.get().getNbComponent();
     }
 
     template <class A = Array,
               std::enable_if_t<not std::is_base_of<
                   ArrayBase, std::decay_t<A>>::value> * = nullptr>
     size_type array_size() {
       return array.get().size();
     }
 
   private:
     std::reference_wrapper<std::remove_reference_t<Array>> array;
     std::tuple<decltype(sizes)...> sizes_;
   };
 
 } // namespace details
 
 template <Idx RowsAtCompileTime, typename Array>
 decltype(auto) make_view(Array && array) {
   return details::EigenView<Array, RowsAtCompileTime>(
       std::forward<Array>(array), RowsAtCompileTime);
 }
 
 template <Idx RowsAtCompileTime, Idx ColsAtCompileTime, typename Array>
 decltype(auto) make_view(Array && array) {
   return details::EigenView<Array, RowsAtCompileTime, ColsAtCompileTime>(
       std::forward<Array>(array), RowsAtCompileTime, ColsAtCompileTime);
 }
 
 } // namespace akantu
 
 namespace Eigen {
 /* -------------------------------------------------------------------------- */
 /* Vector                                                                     */
 /* -------------------------------------------------------------------------- */
 template <typename Derived>
 template <typename ED, typename T,
           std::enable_if_t<not std::is_const<T>::value and
                            ED::IsVectorAtCompileTime> *>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto)
 MatrixBase<Derived>::begin() {
   return ::akantu::view_iterator<typename Derived::Scalar>(
       this->derived().data());
 }
 
 template <typename Derived>
 template <typename ED, typename T,
           std::enable_if_t<not std::is_const<T>::value and
                            ED::IsVectorAtCompileTime> *>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto)
 MatrixBase<Derived>::end() {
   return ::akantu::view_iterator<typename Derived::Scalar>(
       this->derived().data() + this->size());
 }
 
 template <typename Derived>
 template <typename ED, std::enable_if_t<ED::IsVectorAtCompileTime> *>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto)
 MatrixBase<Derived>::begin() const {
   using Scalar = typename Derived::Scalar;
   return ::akantu::const_view_iterator<Scalar>(this->derived().data());
 }
 
 template <typename Derived>
 template <typename ED, std::enable_if_t<ED::IsVectorAtCompileTime> *>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto)
 MatrixBase<Derived>::end() const {
   using Scalar = typename Derived::Scalar;
   return ::akantu::const_view_iterator<Scalar>(this->derived().data() +
                                                this->size());
 }
 
 /* -------------------------------------------------------------------------- */
 /* Matrix                                                                     */
 /* -------------------------------------------------------------------------- */
 template <typename Derived>
 template <typename ED, typename T,
           std::enable_if_t<not std::is_const<T>::value and
                            not ED::IsVectorAtCompileTime> *>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto)
 MatrixBase<Derived>::begin() {
   return ::akantu::view_iterator<
       Map<Matrix<typename Derived::Scalar, Derived::RowsAtCompileTime, 1>>>(
       this->derived().data(), this->rows());
 }
 
 template <typename Derived>
 template <typename ED, typename T,
           std::enable_if_t<not std::is_const<T>::value and
                            not ED::IsVectorAtCompileTime> *>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto)
 MatrixBase<Derived>::end() {
   return ::akantu::view_iterator<
       Map<Matrix<typename Derived::Scalar, Derived::RowsAtCompileTime, 1>>>(
       this->derived().data() + this->size(), this->rows());
 }
 
 template <typename Derived>
 template <typename ED, std::enable_if_t<not ED::IsVectorAtCompileTime> *>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto)
 MatrixBase<Derived>::begin() const {
   using Scalar = typename Derived::Scalar;
   return ::akantu::const_view_iterator<
       Map<const Matrix<Scalar, Derived::RowsAtCompileTime, 1>>>(
       const_cast<Scalar *>(this->derived().data()), this->rows());
 }
 
 template <typename Derived>
 template <typename ED, std::enable_if_t<not ED::IsVectorAtCompileTime> *>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto)
 MatrixBase<Derived>::end() const {
   using Scalar = typename Derived::Scalar;
   return ::akantu::const_view_iterator<
       Map<const Matrix<Scalar, Derived::RowsAtCompileTime, 1>>>(
       const_cast<Scalar *>(this->derived().data()) + this->size(),
       this->rows());
 }
 
 template <typename Derived>
 template <typename OtherDerived>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
 MatrixBase<Derived>::eig(MatrixBase<OtherDerived> & values) {
   EigenSolver<akantu::details::MapPlainObjectType_t<std::decay_t<Derived>>>
       solver(*this, false);
   values = solver.eigenvalues();
 }
 
 template <typename Derived>
 template <typename D1, typename D2>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
 MatrixBase<Derived>::eig(MatrixBase<D1> & values, MatrixBase<D2> & vectors) {
   EigenSolver<akantu::details::MapPlainObjectType_t<std::decay_t<Derived>>>
       solver(*this, false);
   values = solver.eigenvalues();
   vectors = solver.eigenvectors();
 }
 
 template <typename Derived>
 template <typename OtherDerived>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
 MatrixBase<Derived>::eigh(MatrixBase<OtherDerived> & values) {
   SelfAdjointEigenSolver<
       akantu::details::MapPlainObjectType_t<std::decay_t<Derived>>>
       solver(*this, false);
   values = solver.eigenvalues();
 }
 
 template <typename Derived>
 template <typename D1, typename D2>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
 MatrixBase<Derived>::eigh(MatrixBase<D1> & values, MatrixBase<D2> & vectors) {
   SelfAdjointEigenSolver<
       akantu::details::MapPlainObjectType_t<std::decay_t<Derived>>>
       solver(*this, false);
   values = solver.eigenvalues();
   vectors = solver.eigenvectors();
 }
 
 } // namespace Eigen
 
-#endif /* AKANTU_AKA_TYPES_HH_ */
+namespace std {
+
+template <typename POT1, typename POT2, int MapOptions, typename StrideType>
+struct is_convertible<Eigen::Map<POT1, MapOptions, StrideType>,
+                      Eigen::Map<POT2, MapOptions, StrideType>>
+    : aka::bool_constant<is_convertible<POT1, POT2>::value> {};
+
+} // namespace std
+#endif /* __AKANTU_AKA_TYPES_HH__ */
diff --git a/src/common/aka_view_iterators.hh b/src/common/aka_view_iterators.hh
index 9c3c4c6f0..42daf6542 100644
--- a/src/common/aka_view_iterators.hh
+++ b/src/common/aka_view_iterators.hh
@@ -1,558 +1,585 @@
 /**
  * @file   aka_view_iterators.hh
  *
  * @author Nicolas Richart
  *
  * @date creation  Thu Nov 15 2018
  *
  * @brief View iterators
  *
  * @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_common.hh"
 //#include "aka_types.hh"
 /* -------------------------------------------------------------------------- */
 #include <memory>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_VIEW_ITERATORS_HH__
 #define __AKANTU_AKA_VIEW_ITERATORS_HH__
 
+namespace akantu {
+template <typename T, Int ndim> class TensorBase;
+}
+
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* Iterators                                                                  */
 /* -------------------------------------------------------------------------- */
 namespace detail {
   template <class R> struct IteratorHelper { static constexpr Int dim = 0; };
 
   template <class Derived> struct IteratorHelper<Eigen::MatrixBase<Derived>> {
   private:
     using T = typename Derived::Scalar;
     static constexpr Int m = Derived::RowsAtCompileTime;
     static constexpr Int n = Derived::ColsAtCompileTime;
 
   public:
     static constexpr Int dim =
         Eigen::MatrixBase<Derived>::IsVectorAtCompileTime ? 1 : 2;
     using pointer = T *;
     using proxy = Eigen::Map<Eigen::Matrix<T, m, n>>;
     using const_proxy = Eigen::Map<const Eigen::Matrix<T, m, n>>;
   };
 
   template <class Derived> struct IteratorHelper<Eigen::Map<Derived>> {
   private:
     using T = typename Derived::Scalar;
     static constexpr Int m = Derived::RowsAtCompileTime;
     static constexpr Int n = Derived::ColsAtCompileTime;
 
   public:
     static constexpr Int dim =
         Derived::IsVectorAtCompileTime and m != 1 ? 1 : 2;
     using pointer = T *;
     using proxy = Eigen::Map<Derived>;
     using const_proxy = Eigen::Map<const Derived>;
   };
 
-  template <typename T, std::size_t _dim>
-  struct IteratorHelper<Tensor<T, _dim>> {
+  template <typename T, Int _dim>
+  struct IteratorHelper<TensorBase<T, _dim>> {
     static constexpr Int dim = _dim;
     using pointer = T *;
     using proxy = TensorProxy<T, _dim>;
     using const_proxy = TensorProxy<const T, _dim>;
   };
 
-  template <typename T, std::size_t _dim>
+  template <typename T, Int _dim>
   struct IteratorHelper<TensorProxy<T, _dim>> {
     static constexpr Int dim = _dim;
     using pointer = T *;
     using proxy = TensorProxy<T, _dim>;
     using const_proxy = TensorProxy<const T, _dim>;
   };
 
   /* --------------------------------------------------------------------------
    */
   template <class R, class daughter, class IR = R,
             Int dim = IteratorHelper<std::decay_t<R>>::dim>
   class internal_view_iterator {
   protected:
     using helper = IteratorHelper<std::decay_t<R>>;
     using internal_value_type = IR;
     using internal_pointer = IR *;
     using scalar_pointer = typename helper::pointer;
     using proxy_t = typename helper::proxy;
     using const_proxy_t = typename helper::const_proxy;
+    static constexpr int dim_ = dim;
 
   public:
     using pointer = proxy_t *;
     using value_type = proxy_t;
     using reference = proxy_t &;
     using const_reference = const_proxy_t &;
     using difference_type = Int;
     using iterator_category = std::random_access_iterator_tag;
 
   private:
     template <std::size_t... I>
     constexpr auto get_new_const_proxy(scalar_pointer data,
                                        std::index_sequence<I...>) const {
       return const_proxy_t(data, dims[I]...);
     }
 
     constexpr auto get_new_const_proxy(scalar_pointer data) const {
       return get_new_const_proxy(data, std::make_index_sequence<dim>());
     }
     template <std::size_t... I>
     constexpr auto get_new_proxy(scalar_pointer data,
                                  std::index_sequence<I...>) {
       return proxy_t(data, dims[I]...);
     }
 
     constexpr auto get_new_proxy(scalar_pointer data) {
       return get_new_proxy(data, std::make_index_sequence<dim>());
     }
 
     template <typename T, std::size_t... I>
     constexpr void reset_proxy(T & t, scalar_pointer data,
                                std::index_sequence<I...>) const {
       new (&t) T(data, dims[I]...);
     }
 
     template <typename T> constexpr auto reset_proxy(T & t) const {
       return reset_proxy(t, this->ret_ptr, std::make_index_sequence<dim>());
     }
 
   protected:
     template <typename OR, typename OD, typename OIR,
               std::enable_if_t<std::is_convertible<
                   decltype(std::declval<OIR>().data()),
                   decltype(std::declval<IR>().data())>::value> * = nullptr>
     explicit internal_view_iterator(
         internal_view_iterator<OR, OD, OIR, dim> & it)
         : dims(it.dims), _offset(it._offset), initial(it.initial),
           ret_ptr(it.ret_ptr), proxy(get_new_proxy(it.ret_ptr)),
           const_proxy(get_new_const_proxy(it.ret_ptr)) {}
 
     template <typename OR, typename OD, typename OIR, Int _dim>
     friend class internal_view_iterator;
 
     template <typename... Args>
     using valid_args_t = std::enable_if_t<
         aka::conjunction<aka::disjunction<std::is_integral<Args>,
                                           std::is_enum<Args>>...>::value and
             dim == sizeof...(Args),
         int>;
 
   public:
     template <typename... Ns, valid_args_t<Ns...> = 0>
     internal_view_iterator(scalar_pointer data, Ns... ns)
         : dims({Int(ns)...}),
           _offset(detail::product_all(std::forward<Ns>(ns)...)), initial(data),
           ret_ptr(data), proxy(data, ns...), const_proxy(data, ns...) {}
 
     // Static 1x1 matrix cannot be differenciated from vector in eigen
     template <typename RD = std::decay_t<R>,
               std::enable_if_t<RD::RowsAtCompileTime == 1 and
                                RD::ColsAtCompileTime == 1> * = nullptr>
     constexpr internal_view_iterator(scalar_pointer data, Idx rows)
         : dims({rows, 1}), _offset(rows), initial(data), ret_ptr(data),
           proxy(data, rows, 1), const_proxy(data, rows, 1) {
       AKANTU_DEBUG_ASSERT(rows == 1, "1x1 Matrix");
     }
 
     // Static matrix again hard to distinguish from vectors
     template <typename RD = std::decay_t<R>,
               std::enable_if_t<(RD::RowsAtCompileTime > 1) and
                                RD::ColsAtCompileTime == 1> * = nullptr>
     constexpr internal_view_iterator(scalar_pointer data, Idx rows, Idx cols)
         : dims({rows}), _offset(rows), initial(data), ret_ptr(data),
           proxy(data, rows, 1), const_proxy(data, rows, 1) {
       AKANTU_DEBUG_ASSERT(cols == 1, "nx1 Matrix");
     }
 
     template <Int _dim = dim, std::enable_if_t<_dim == 1> * = nullptr>
     internal_view_iterator() : proxy(nullptr, 0), const_proxy(nullptr, 0) {}
 
     template <Int _dim = dim, std::enable_if_t<_dim == 2> * = nullptr>
     internal_view_iterator()
         : proxy(nullptr, 0, 0), const_proxy(nullptr, 0, 0) {}
 
     internal_view_iterator(const internal_view_iterator & it)
         : proxy(get_new_proxy(it.ret_ptr)),
           const_proxy(get_new_const_proxy(it.ret_ptr)) {
       if (this != &it) {
         this->dims = it.dims;
         this->_offset = it._offset;
         this->initial = it.initial;
         this->ret_ptr = it.ret_ptr;
       }
     }
 
     internal_view_iterator(internal_view_iterator && it) = default;
 
     virtual ~internal_view_iterator() = default;
 
     template <typename OR, typename OD, typename OIR,
               std::enable_if_t<std::is_convertible<
                   decltype(std::declval<OIR>().data()),
                   decltype(std::declval<IR>().data())>::value> * = nullptr>
     inline internal_view_iterator &
     operator=(const internal_view_iterator<OR, OD, OIR, dim> & it) {
       this->_offset = it._offset;
       this->initial = it.initial;
       this->ret_ptr = it.ret_ptr;
       reset_proxy(this->proxy);
       reset_proxy(this->const_proxy);
       return *this;
     }
 
     inline internal_view_iterator &
     operator=(const internal_view_iterator & it) {
       if (this != &it) {
         this->_offset = it._offset;
         this->initial = it.initial;
         this->ret_ptr = it.ret_ptr;
         reset_proxy(this->proxy);
         reset_proxy(this->const_proxy);
       }
       return *this;
     }
 
   public:
     UInt getCurrentIndex() {
       return (this->ret_ptr - this->initial) / this->_offset;
     }
 
     inline reference operator*() {
       reset_proxy(proxy);
       return proxy;
     }
 
     inline const_reference operator*() const {
       reset_proxy(const_proxy);
       return proxy;
     }
 
     inline pointer operator->() {
       reset_proxy(proxy);
       return &proxy;
     }
 
     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+=(UInt n) {
       ret_ptr += _offset * n;
       return static_cast<daughter &>(*this);
     }
 
     inline daughter & operator-=(UInt n) {
       ret_ptr -= _offset * n;
       return static_cast<daughter &>(*this);
     }
 
     inline auto operator[](UInt n) {
       return get_new_proxy(ret_ptr + n * _offset);
     }
 
     inline auto operator[](UInt n) const {
       return get_new_const_proxy(ret_ptr + n * _offset);
     }
 
     inline bool operator==(const internal_view_iterator & other) const {
       return this->ret_ptr == other.ret_ptr;
     }
 
     inline bool operator!=(const internal_view_iterator & other) const {
       return this->ret_ptr != other.ret_ptr;
     }
 
     inline bool operator<(const internal_view_iterator & other) const {
       return this->ret_ptr < other.ret_ptr;
     }
 
     inline bool operator<=(const internal_view_iterator & other) const {
       return this->ret_ptr <= other.ret_ptr;
     }
 
     inline bool operator>(const internal_view_iterator & other) const {
       return this->ret_ptr > other.ret_ptr;
     }
 
     inline bool operator>=(const internal_view_iterator & 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 internal_view_iterator & b) {
       return (this->ret_ptr - b.ret_ptr) / _offset;
     }
 
     inline scalar_pointer data() const { return ret_ptr; }
     inline difference_type offset() const { return _offset; }
     inline decltype(auto) getDims() const { return dims; }
 
   protected:
     std::array<Int, dim> dims;
     difference_type _offset{0};
     scalar_pointer initial{nullptr};
     scalar_pointer ret_ptr{nullptr};
     proxy_t proxy;
     const_proxy_t const_proxy;
   };
 
   /* ------------------------------------------------------------------------ */
   /**
    * Specialization for scalar types
    */
   template <class R, class daughter, class IR>
   class internal_view_iterator<R, daughter, IR, 0> {
   public:
     using value_type = R;
     using pointer = R *;
     using reference = R &;
     using const_reference = const R &;
     using difference_type = std::ptrdiff_t;
     using iterator_category = std::random_access_iterator_tag;
+    static constexpr int dim_ = 0;
 
   protected:
     using internal_value_type = IR;
     using internal_pointer = IR *;
 
   public:
     internal_view_iterator(pointer data = nullptr) : ret(data), initial(data){};
     internal_view_iterator(const internal_view_iterator & it) = default;
     internal_view_iterator(internal_view_iterator && it) = default;
 
     virtual ~internal_view_iterator() = default;
 
     inline internal_view_iterator &
     operator=(const internal_view_iterator & 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 internal_view_iterator & other) const {
       return ret == other.ret;
     }
     inline bool operator!=(const internal_view_iterator & other) const {
       return ret != other.ret;
     }
     inline bool operator<(const internal_view_iterator & other) const {
       return ret < other.ret;
     }
     inline bool operator<=(const internal_view_iterator & other) const {
       return ret <= other.ret;
     }
     inline bool operator>(const internal_view_iterator & other) const {
       return ret > other.ret;
     }
     inline bool operator>=(const internal_view_iterator & 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 internal_view_iterator & b) {
       return ret - b.ret;
     }
 
     inline pointer data() const { return ret; }
+    inline decltype(auto) getDims() const { return dims; }
 
   protected:
+    std::array<int, 0> dims;
     pointer ret{nullptr};
     pointer initial{nullptr};
   };
 } // namespace detail
 
 /* -------------------------------------------------------------------------- */
 template <typename R> class view_iterator;
 
 template <typename R>
 class const_view_iterator
     : public detail::internal_view_iterator<const R, const_view_iterator<R>,
                                             R> {
 public:
   using parent =
       detail::internal_view_iterator<const R, const_view_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;
 
+protected:
+  template <typename OR, std::size_t... I>
+  static inline auto convert_helper(const view_iterator<OR> & it,
+                                    std::index_sequence<I...>) {
+    return const_view_iterator(it.data(), it.getDims()[I]...);
+  }
+
+  template <typename OR>
+  static inline auto convert(const view_iterator<OR> & it) {
+    return convert_helper(it, std::make_index_sequence<parent::dim_>());
+  }
+
 public:
   const_view_iterator() : parent(){};
   const_view_iterator(const const_view_iterator & it) = default;
   const_view_iterator(const_view_iterator && it) = default;
 
   template <typename P, typename... Ns>
   const_view_iterator(P * data, Ns... ns) : parent(data, ns...) {}
 
   const_view_iterator & operator=(const const_view_iterator & it) = default;
 
   template <typename OR,
             std::enable_if_t<not std::is_same<R, OR>::value> * = nullptr>
-  const_view_iterator(const_view_iterator<OR> & it) : parent(it) {}
+  const_view_iterator(const const_view_iterator<OR> & it) : parent(it) {}
 
   template <typename OR,
-            std::enable_if_t<not std::is_same<R, OR>::value> * = nullptr>
+            std::enable_if_t<not std::is_same<R, OR>::value and
+                             std::is_convertible<R, OR>::value> * = nullptr>
   const_view_iterator & operator=(const const_view_iterator<OR> & it) {
     return dynamic_cast<const_view_iterator &>(parent::operator=(it));
   }
+
+  template <typename OR,
+            std::enable_if_t<std::is_convertible<R, OR>::value> * = nullptr>
+  const_view_iterator operator=(const view_iterator<OR> & it) {
+    return convert(it);
+  }
 };
 
 template <class R, bool is_tensor_ = aka::is_tensor<R>::value>
 struct ConstConverterIteratorHelper {
 protected:
   template <std::size_t... I>
   static inline auto convert_helper(const view_iterator<R> & it,
                                     std::index_sequence<I...>) {
     return const_view_iterator<R>(it.data(), it.getDims()[I]...);
   }
 
 public:
   static inline auto convert(const view_iterator<R> & it) {
     return convert_helper(
         it, std::make_index_sequence<
                 std::tuple_size<decltype(it.getDims())>::value>());
   }
 };
 
 template <class R> struct ConstConverterIteratorHelper<R, false> {
   static inline auto convert(const view_iterator<R> & it) {
     return const_view_iterator<R>(it.data());
   }
 };
 
 template <typename R>
 class view_iterator
     : public detail::internal_view_iterator<R, view_iterator<R>> {
 public:
   using parent = detail::internal_view_iterator<R, view_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:
   view_iterator() : parent(){};
   view_iterator(const view_iterator & it) = default;
   view_iterator(view_iterator && it) = default;
 
   template <typename P, typename... Ns>
   view_iterator(P * data, Ns... ns) : parent(data, ns...) {}
 
   view_iterator & operator=(const view_iterator & it) = default;
 
   operator const_view_iterator<R>() {
     return ConstConverterIteratorHelper<R>::convert(*this);
   }
 };
 
 namespace {
   template <std::size_t dim, typename T> struct ViewIteratorHelper {
     using type = TensorProxy<T, dim>;
   };
 
   template <typename T> struct ViewIteratorHelper<0, T> { using type = T; };
   template <typename T> struct ViewIteratorHelper<1, T> {
     using type = Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, 1>>;
   };
   template <typename T> struct ViewIteratorHelper<1, const T> {
     using type = Eigen::Map<const Eigen::Matrix<T, Eigen::Dynamic, 1>>;
   };
 
   template <typename T> struct ViewIteratorHelper<2, T> {
     using type = Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>>;
   };
 
   template <typename T> struct ViewIteratorHelper<2, const T> {
     using type =
         Eigen::Map<const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>>;
   };
 
   template <std::size_t dim, typename T>
   using ViewIteratorHelper_t = typename ViewIteratorHelper<dim, T>::type;
 } // namespace
 
 // #include <iterator>
 
 // namespace std {
 // template <typename R>
 // struct iterator_traits<::akantu::types::details::vector_iterator<R>> {
 // protected:
 //   using iterator = ::akantu::types::details::vector_iterator<R>;
 
 // public:
 //   using iterator_category = typename iterator::iterator_category;
 //   using value_type = typename iterator::value_type;
 //   using difference_type = typename iterator::difference_type;
 //   using pointer = typename iterator::pointer;
 //   using reference = typename iterator::reference;
 // };
 // } // namespace std
 
 } // namespace akantu
 
 #endif /* !__AKANTU_AKA_VIEW_ITERATORS_HH__ */
diff --git a/src/fe_engine/element.hh b/src/fe_engine/element.hh
index 0c1975355..95173d49c 100644
--- a/src/fe_engine/element.hh
+++ b/src/fe_engine/element.hh
@@ -1,129 +1,108 @@
 /**
  * @file   element.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Tue Sep 29 2020
  *
  * @brief  Element helper class
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2014-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_ELEMENT_HH_
 #define AKANTU_ELEMENT_HH_
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* Element                                                                    */
 /* -------------------------------------------------------------------------- */
 class Element {
 public:
   ElementType type;
   Idx element;
   GhostType ghost_type;
 
-  // ElementKind kind;
-  // ElementType type{_not_defined};
-  // UInt element{0};
-  // GhostType ghost_type{_not_ghost};
-  // ElementKind kind{_ek_regular};
-
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   inline ElementKind kind() const;
 
   inline bool operator==(const Element & elem) const {
     return std::tie(type, element, ghost_type) ==
            std::tie(elem.type, elem.element, elem.ghost_type);
   }
 
   inline bool operator!=(const Element & elem) const {
     return std::tie(type, element, ghost_type) !=
            std::tie(elem.type, elem.element, elem.ghost_type);
   }
 
-  // inline bool operator==(const Element & elem) const {
-  //   return ((element == elem.element) && (type == elem.type) &&
-  //           (ghost_type == elem.ghost_type) && (kind == elem.kind));
-  // }
-
-  // inline bool operator!=(const Element & elem) const {
-  //   return ((element != elem.element) || (type != elem.type) ||
-  //           (ghost_type != elem.ghost_type) || (kind != elem.kind));
-  // }
-
   inline bool operator<(const Element & rhs) const;
 };
 
+#if __cplusplus < 201703L
 namespace {
   const Element ElementNull{_not_defined, Idx(-1), _casper};
-  //      Element{_not_defined, 0, _casper, _ek_not_defined};
 } // namespace
+#else
+  inline constexpr Element ElementNull{_not_defined, Idx(-1), _casper};
+#endif
 
 /* -------------------------------------------------------------------------- */
 inline bool Element::operator<(const Element & rhs) const {
-  // bool res =
-  //     (rhs == ElementNull) ||
-  //     ((this->kind < rhs.kind) ||
-  //      ((this->kind == rhs.kind) &&
-  //       ((this->ghost_type < rhs.ghost_type) ||
-  //        ((this->ghost_type == rhs.ghost_type) &&
-  //         ((this->type < rhs.type) ||
-  //          ((this->type == rhs.type) && (this->element < rhs.element)))))));
   return ((rhs == ElementNull) ||
           std::tie(ghost_type, type, element) <
               std::tie(rhs.ghost_type, rhs.type, rhs.element));
 }
 
 } // namespace akantu
 
 namespace std {
 inline string to_string(const akantu::Element & _this) {
   if (_this == akantu::ElementNull) {
     return "ElementNull";
   }
 
   string str = "Element [" + to_string(_this.type) + ", " +
                to_string(_this.element) + ", " + to_string(_this.ghost_type) +
                "]";
   return str;
 }
 } // namespace std
 
 namespace akantu {
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream, const Element & _this) {
   stream << std::to_string(_this);
   return stream;
 }
 } // namespace akantu
 
 #endif /* AKANTU_ELEMENT_HH_ */
diff --git a/src/fe_engine/element_class.hh b/src/fe_engine/element_class.hh
index c32a08992..b3049a04f 100644
--- a/src/fe_engine/element_class.hh
+++ b/src/fe_engine/element_class.hh
@@ -1,465 +1,472 @@
 /**
  * @file   element_class.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri Dec 11 2020
  *
  * @brief  Declaration of the ElementClass main class and the
  * Integration and Interpolation elements
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "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 Int spatial_dimension{0};
-  static const GaussIntegrationType gauss_integration_type{_git_not_defined};
+  static const GaussIntegrationType gauss_itegration_type{_git_not_defined};
   static const Int polynomial_degree{0};
 };
 
 #if !defined(DOXYGEN)
 /// 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 Int spatial_dimension{sp};                                    \
     static const GaussIntegrationType gauss_integration_type{gauss_int_type};  \
     static const Int polynomial_degree{min_int_order};                         \
   }
 #else
 #define AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(elem_type, geom_type,             \
                                              interp_type, elem_kind, sp,       \
                                              gauss_int_type, min_int_order)
 #endif
 
 /* -------------------------------------------------------------------------- */
 /* 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 coord
   template <class D>
   static inline bool contains(const Eigen::MatrixBase<D> & coord);
 };
 
 #if !defined(DOXYGEN)
 /// 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);
 #endif
 /* -------------------------------------------------------------------------- */
 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: \todo should be renamed for characteristic length
   template <class D>
   static inline Real getInradius(const Eigen::MatrixBase<D> & /*X*/) {
     AKANTU_TO_IMPLEMENT();
   }
 
   /// compute the normal to the element
   template <class D1, class D2>
   static inline void getNormal(const Eigen::MatrixBase<D1> & /*X*/,
                                Eigen::MatrixBase<D2> & /*n*/) {
     AKANTU_TO_IMPLEMENT();
   }
 
   /// true if the natural coordinates are in the element
   template <class D>
   static inline bool contains(const Eigen::MatrixBase<D> & coord);
 
 public:
   static constexpr auto getSpatialDimension() {
     return geometrical_property::spatial_dimension;
   }
   static constexpr auto getNbNodesPerElement() {
     return geometrical_property::nb_nodes_per_element;
   }
   static inline constexpr auto getNbFacetTypes() {
     return geometrical_property::nb_facet_types;
   };
   static inline constexpr Int getNbFacetsPerElement(Idx t);
   static inline constexpr Int getNbFacetsPerElement();
   static inline constexpr decltype(auto)
   getFacetLocalConnectivityPerElement(Idx t = 0);
 };
 
 /* -------------------------------------------------------------------------- */
 /* Interpolation                                                              */
 /* -------------------------------------------------------------------------- */
 /// default InterpolationProperty structure
 template <InterpolationType interpolation_type> struct InterpolationProperty {};
 
 #if !defined(DOXYGEN)
 /// 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 Int nb_nodes_per_element{nb_nodes};                       \
     static constexpr Int natural_space_dimension{ndim};                        \
   }
 #else
 #define AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(itp_type, itp_kind,          \
                                                   nb_nodes, ndim)
 #endif
 /* -------------------------------------------------------------------------- */
 /// 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
   template <class D1, class D2,
             aka::enable_if_t<aka::are_matrices<D1, D2>::value> * = nullptr>
   static inline void computeShapes(const Eigen::MatrixBase<D1> & natural_coord,
                                    const Eigen::MatrixBase<D2> & shapes);
 
   /// compute the shape values for a given point in natural coordinates
   template <class D1, class D2,
             aka::enable_if_t<aka::are_vectors<D1, D2>::value> * = nullptr>
   static inline void computeShapes(const Eigen::MatrixBase<D1> &,
                                    Eigen::MatrixBase<D2> &) {
     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
    */
   template <class D>
   static inline void computeDNDS(const Eigen::MatrixBase<D> & Xs,
                                  Tensor3Base<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 D1, class D2>
   static inline void computeDNDS(const Eigen::MatrixBase<D1> & /*Xs*/,
                                  Eigen::MatrixBase<D2> & /*dNdS*/) {
     AKANTU_TO_IMPLEMENT();
   }
 
   /**
    * compute @f$ @f$
    
    **/
   static inline void computeD2NDS2(const Matrix<Real> & natural_coord,
 				   Tensor3<Real> & d2nds2);
 
   /**
    * compute @f$ B_{ij} = \frac{\partial N_j}{\partial S_i} @f$ the
    * second 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 computeD2NDS2(const vector_type &, matrix_type &) {
     AKANTU_TO_IMPLEMENT();
   }
 
 
   /// compute jacobian (or integration variable change factor) for a given point
   /// in the case of spatial_dimension != natural_space_dimension
   template <class D>
   static inline Real computeSpecialJacobian(const Eigen::MatrixBase<D> &) {
     AKANTU_TO_IMPLEMENT();
   }
 
   /// interpolate a field given (arbitrary) natural coordinates
   template <class Derived1, class Derived2>
   static inline decltype(auto) interpolateOnNaturalCoordinates(
       const Eigen::MatrixBase<Derived1> & natural_coords,
       const Eigen::MatrixBase<Derived2> & nodal_values) {
     using interpolation = InterpolationProperty<interpolation_type>;
     Eigen::Matrix<Real, interpolation::nb_nodes_per_element, 1> shapes;
     computeShapes(natural_coords, shapes);
 
     return interpolate(nodal_values, shapes);
   }
 
   /// interpolate a field given the shape functions on the interpolation point
   template <class Derived1, class Derived2>
   static inline auto
   interpolate(const Eigen::MatrixBase<Derived1> & nodal_values,
-              const Eigen::MatrixBase<Derived2> & shapes) {
-    return nodal_values * shapes;
-  }
+              const Eigen::MatrixBase<Derived2> & shapes);
 
   /// interpolate a field given the shape functions on the interpolations points
-  template <class Derived1, class Derived2, class Derived3,
-            aka::enable_if_matrices_t<Derived1, Derived2, Derived3> * = nullptr>
+  template <class Derived1, class Derived2, class Derived3>
   static inline void
   interpolate(const Eigen::MatrixBase<Derived1> & nodal_values,
               const Eigen::MatrixBase<Derived2> & Ns,
               const Eigen::MatrixBase<Derived3> & interpolated);
 
   /// compute the gradient of a given field on the given natural coordinates
-  template <class Derived1, class Derived2>
-  static inline decltype(auto) gradientOnNaturalCoordinates(
-      const Eigen::MatrixBase<Derived1> & natural_coords,
-      const Eigen::MatrixBase<Derived2> & f);
+  template <class D1, class D2, class D3>
+  static inline void
+  gradientOnNaturalCoordinates(const Eigen::MatrixBase<D1> & natural_coords,
+                               const Eigen::MatrixBase<D2> & f,
+                               const Eigen::MatrixBase<D3> & dfds);
 
 public:
   static constexpr auto getShapeSize() {
     return InterpolationProperty<interpolation_type>::nb_nodes_per_element;
   }
   static constexpr auto getShapeDerivativesSize() {
     return (InterpolationProperty<interpolation_type>::nb_nodes_per_element *
             InterpolationProperty<interpolation_type>::natural_space_dimension);
   }
   static constexpr auto getNaturalSpaceDimension() {
     return InterpolationProperty<interpolation_type>::natural_space_dimension;
   }
   static constexpr auto getNbNodesPerInterpolationElement() {
     return InterpolationProperty<interpolation_type>::nb_nodes_per_element;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 /* Integration                                                                */
 /* -------------------------------------------------------------------------- */
 template <GaussIntegrationType git_class, Int 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,
           Int n = ElementClassProperty<type>::polynomial_degree>
 class GaussIntegrationElement {
 public:
   static constexpr Int getNbQuadraturePoints();
   static constexpr decltype(auto) getQuadraturePoints();
   static constexpr decltype(auto) 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 Ref<const MatrixXr> & dnds,
-                                 const Ref<const MatrixXr> & node_coords,
-                                 Ref<MatrixXr> J);
+  template <class D1, class D2>
+  static inline decltype(auto)
+  computeJMat(const Eigen::MatrixBase<D1> & dnds,
+              const Eigen::MatrixBase<D2> & node_coords);
 
   /**
    * 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 Ref<const MatrixXr> & node_coords,
-                                 Tensor3<Real> & J);
+  template <class D>
+  static inline void computeJMat(const Tensor3Base<Real> & dnds,
+                                 const Eigen::MatrixBase<D> & node_coords,
+                                 Tensor3Base<Real> & J);
 
   /// compute the jacobians of a serie of natural coordinates
-  static inline void computeJacobian(const Ref<const MatrixXr> & natural_coords,
-                                     const Ref<const MatrixXr> & node_coords,
-                                     Ref<VectorXr> jacobians);
+  template <class D1, class D2, class D3>
+  static inline void
+  computeJacobian(const Eigen::MatrixBase<D1> & natural_coords,
+                  const Eigen::MatrixBase<D2> & node_coords,
+                  Eigen::MatrixBase<D3> & jacobians);
 
   /// compute jacobian (or integration variable change factor) for a set of
   /// points
-  static inline void computeJacobian(const Tensor3<Real> & J,
-                                     Ref<VectorXr> jacobians);
+  template <class D>
+  static inline void computeJacobian(const Tensor3Base<Real> & J,
+                                     Eigen::MatrixBase<D> & jacobians);
 
   /// compute jacobian (or integration variable change factor) for a given point
-  static inline void computeJacobian(const Ref<const MatrixXr> & J,
-                                     Real & jacobians);
+  template <class D>
+  static inline Real computeJacobian(const Eigen::MatrixBase<D> & J);
 
   /// 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);
+  static inline void computeShapeDerivatives(const Tensor3Base<Real> & J,
+                                             const Tensor3Base<Real> & dnds,
+                                             Tensor3Base<Real> & shape_deriv);
 
   /// compute shape derivatives (input is dxds) for a given point
-  static inline void computeShapeDerivatives(const Ref<const MatrixXr> & J,
-                                             const Ref<const MatrixXr> & dnds,
-                                             Ref<MatrixXr> shape_deriv);
+  template <class D1, class D2, class D3>
+  static inline void
+  computeShapeDerivatives(const Eigen::MatrixBase<D1> & J,
+                          const Eigen::MatrixBase<D2> & dnds,
+                          Eigen::MatrixBase<D3> & shape_deriv);
 
   /// compute the normal of a surface defined by the function f
+  template <class D1, class D2, class D3>
   static inline void
-  computeNormalsOnNaturalCoordinates(const Ref<const MatrixXr> & coord,
-                                     const Ref<const MatrixXr> & f,
-                                     Ref<MatrixXr> normals);
+  computeNormalsOnNaturalCoordinates(const Eigen::MatrixBase<D1> & coord,
+                                     const Eigen::MatrixBase<D2> & f,
+                                     Eigen::MatrixBase<D3> & normals);
 
   /// get natural coordinates from real coordinates
-  static inline void inverseMap(const Ref<const VectorXr> & real_coords,
-                                const Ref<const MatrixXr> & node_coords,
-                                Ref<VectorXr> natural_coords,
+  template <class D1, class D2, class D3>
+  static inline void inverseMap(const Eigen::MatrixBase<D1> & real_coords,
+                                const Eigen::MatrixBase<D2> & node_coords,
+                                Eigen::MatrixBase<D3> & natural_coords,
                                 Real tolerance = 1e-10);
 
   /// get natural coordinates from real coordinates
   template <class Derived1, class Derived2, class Derived3,
             aka::enable_if_matrices_t<Derived1, Derived2, Derived3> * = nullptr>
   static inline void
   inverseMap(const Eigen::MatrixBase<Derived1> & real_coords,
              const Eigen::MatrixBase<Derived2> & node_coords,
              const Eigen::MatrixBase<Derived3> & natural_coords_,
              UInt max_iterations = 100,
              Real tolerance = 1e-10);
 
 public:
   static constexpr auto getKind() { return element_kind; }
   static constexpr auto getSpatialDimension() {
     return ElementClassProperty<element_type>::spatial_dimension;
   }
 
   using element_class_extra_geom_property =
       ElementClassExtraGeometryProperties<element_type>;
 
   static constexpr decltype(auto) getP1ElementType() {
     return element_class_extra_geom_property::p1_type;
   }
   static constexpr decltype(auto) getFacetType(UInt t = 0) {
     return element_class_extra_geom_property::facet_type[t];
   }
   static constexpr decltype(auto) getFacetTypes();
 };
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 #include "geometrical_element_property.hh"
 #include "interpolation_element_tmpl.hh"
 /* -------------------------------------------------------------------------- */
 #include "element_class_tmpl.hh"
 /* -------------------------------------------------------------------------- */
 #include "element_class_hexahedron_8_inline_impl.cc"
 #include "element_class_pentahedron_6_inline_impl.cc"
 /* keep order */
 #include "element_class_hexahedron_20_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"
 
 /* -------------------------------------------------------------------------- */
 #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 d6173996c..fad4bdad5 100644
--- a/src/fe_engine/element_class_structural.hh
+++ b/src/fe_engine/element_class_structural.hh
@@ -1,278 +1,278 @@
 /**
  * @file   element_class_structural.hh
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@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: Mon Feb 01 2021
  *
  * @brief  Specialization of the element classes for structural elements
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2014-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_iterators.hh"
 //#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
   template <typename D1, typename D2>
   static inline void computeShapes(const Eigen::MatrixBase<D1> & Xs,
                                    const Eigen::MatrixBase<D2> & x,
                                    TensorBase<Real, 3> & Ns) {
     for(auto && data : zip(Xs, Ns)) {
       computeShapes(std::get<0>(data), x, std::get<1>(data));
     }
   }
 
   /// compute the shape values for a given point in natural coordinates
   template <typename D1, typename D2, typename D3>
   static inline void computeShapes(const Eigen::MatrixBase<D1> & natural_coord,
                                    const Eigen::MatrixBase<D2> & real_coord,
                                    Eigen::MatrixBase<D3> & N);
 
   static inline void computeShapesMass(const Matrix<Real> & natural_coords,
                                        const Matrix<Real> & xs,
                                        const Matrix<Real> & T,
                                        Tensor3<Real> & Ns) {
     for (UInt i = 0; i < natural_coords.cols(); ++i) {
       Matrix<Real> N_T = Ns(i);
       Vector<Real> X = natural_coords(i);
       Matrix<Real> N(interpolation_property::nb_degree_of_freedom, N_T.cols());
 
       computeShapes(X, xs, N);
       N_T.mul<false, false>(N.block(0, 0, N_T.rows(), N_T.cols()), T);
     }
   }
 
   /// compute shape derivatives (input is dxds) for a set of points
   static inline void computeShapeDerivatives(const TensorBase<Real, 3> & Js,
                                              const TensorBase<Real, 3> & DNDSs,
                                              const Matrix<Real> & R,
                                              TensorBase<Real, 3> & Bs) {
-    for (UInt i = 0; i < Js.size(2); ++i) {
+    for (Int i = 0; i < Js.size(2); ++i) {
       auto && DNDX = Js(i).inverse() * DNDSs(i);
       auto && B_R = Bs(i);
       Matrix<Real> B(B_R.rows(), B_R.cols());
       arrangeInVoigt(DNDX, B);
       B_R = 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
    */
   template <typename D1, typename D2>
   static inline void computeDNDS(const Eigen::MatrixBase<D1> & Xs,
                                  const Eigen::MatrixBase<D2> & xs,
                                  TensorBase<Real, 3> & dnds) {
     for (auto && data : zip(Xs, dnds))
       computeDNDS(std::get<0>(data), xs, std::get<1>(data));
   }
 
   /**
    * 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 <typename D1, typename D2, typename D3>
   static inline void computeDNDS(const Eigen::MatrixBase<D1> & Xs,
                                  const Eigen::MatrixBase<D2> & xs,
                                  Eigen::MatrixBase<D3> & dnds);
 
   /**
    * arrange B in Voigt notation from DNDS
    */
   template <class D1, class D2>
   static inline void arrangeInVoigt(const Eigen::MatrixBase<D1> & dnds,
                                     Eigen::MatrixBase<D2> & B) {
     // Default implementation assumes dnds is already in Voigt notation
     B = dnds;
   }
 
 public:
   static inline constexpr auto getNbNodesPerInterpolationElement() {
     return interpolation_property::nb_nodes_per_element;
   }
 
   static inline constexpr auto getShapeSize() {
     return interpolation_property::nb_nodes_per_element *
            interpolation_property::nb_degree_of_freedom *
            interpolation_property::nb_degree_of_freedom;
   }
   static inline constexpr auto getShapeIndependantSize() {
     return interpolation_property::nb_nodes_per_element *
            interpolation_property::nb_degree_of_freedom *
            interpolation_property::nb_stress_components;
   }
   static inline constexpr auto getShapeDerivativesSize() {
     return interpolation_property::nb_nodes_per_element *
            interpolation_property::nb_degree_of_freedom *
            interpolation_property::nb_stress_components;
   }
   static inline constexpr auto getNaturalSpaceDimension() {
     return interpolation_property::natural_space_dimension;
   }
   static inline constexpr auto getNbDegreeOfFreedom() {
     return interpolation_property::nb_degree_of_freedom;
   }
   static inline constexpr auto getNbStressComponents() {
     return interpolation_property::nb_stress_components;
   }
 };
 
 /// 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:
   template <class D1, class D2, class D3>
   static inline void
   computeRotationMatrix(Eigen::MatrixBase<D1> & /*R*/,
                         const Eigen::MatrixBase<D2> & /*X*/,
                         const Eigen::MatrixBase<D3> & /*extra_normal*/) {
     AKANTU_TO_IMPLEMENT();
   }
 
   /// compute jacobian (or integration variable change factor) for a given point
   template <typename D1, typename D2, typename D3>
   static inline void computeJMat(const Eigen::MatrixBase<D1> & natural_coords,
                                  const Eigen::MatrixBase<D2> & Xs,
                                  Eigen::MatrixBase<D3> & J) {
     Matrix<Real> dnds(Xs.rows(), Xs.cols());
     parent_element::computeDNDS(natural_coords, dnds);
     J = dnds * Xs.transpose();
   }
 
   template <typename D1, typename D2>
   static inline void computeJMat(const Eigen::MatrixBase<D1> & Xs,
                                  const Eigen::MatrixBase<D2> & xs,
                                  Tensor3<Real> & Js) {
     for (auto && data : zip(Xs, Js)) {
       computeJMat(std::get<0>(data), xs, std::get<1>(data));
     }
   }
 
   template <typename D1, typename D2>
   static inline void computeJacobian(const Eigen::MatrixBase<D1> & Xs,
                                      const Eigen::MatrixBase<D2> & xs,
                                      Vector<Real> & jacobians) {
     using itp = typename interpolation_element::interpolation_property;
     Tensor3<Real> Js(itp::natural_space_dimension, itp::natural_space_dimension,
                      Xs.cols());
     computeJMat(Xs, xs, Js);
     for (auto && data : zip(jacobians, Js)) {
       std::get<0>(data) = std::get<1>(data).determinant();
     }
   }
 
   template <typename D1, typename D2>
   static inline void computeRotation(const Eigen::MatrixBase<D1> & xs,
                                      Eigen::MatrixBase<D2> & R);
 
 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_class_hermite_inline_impl.hh"
 /* keep order */
 #include "element_class_bernoulli_beam_inline_impl.hh"
 #include "element_class_kirchhoff_shell_inline_impl.hh"
 /* -------------------------------------------------------------------------- */
 
 #endif /* AKANTU_ELEMENT_CLASS_STRUCTURAL_HH_ */
diff --git a/src/fe_engine/element_class_tmpl.hh b/src/fe_engine/element_class_tmpl.hh
index 17594c117..c6716192a 100644
--- a/src/fe_engine/element_class_tmpl.hh
+++ b/src/fe_engine/element_class_tmpl.hh
@@ -1,552 +1,567 @@
 /**
  * @file   element_class_tmpl.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Thomas Menouillard <tmenouillard@stucky.ch>
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Feb 21 2013
  * @date last modification: Fri Dec 11 2020
  *
  * @brief  Implementation of the inline templated function of the element class
  * descriptions
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2014-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 //#include "element_class.hh"
-#include "gauss_integration_tmpl.hh"
 #include "aka_iterators.hh"
+#include "gauss_integration_tmpl.hh"
 /* -------------------------------------------------------------------------- */
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_ELEMENT_CLASS_TMPL_HH_
 #define AKANTU_ELEMENT_CLASS_TMPL_HH_
 
 namespace akantu {
 
 template <ElementType element_type, ElementKind element_kind>
 inline constexpr decltype(auto)
 ElementClass<element_type, element_kind>::getFacetTypes() {
   return Eigen::Map<const Eigen::Matrix<
       ElementType, geometrical_element::getNbFacetTypes(), 1>>(
       element_class_extra_geom_property::facet_type.data());
 }
 
 /* -------------------------------------------------------------------------- */
 /* GeometricalElement                                                         */
 /* -------------------------------------------------------------------------- */
 template <GeometricalType geometrical_type, GeometricalShapeType shape>
 inline constexpr decltype(auto)
 GeometricalElement<geometrical_type,
                    shape>::getFacetLocalConnectivityPerElement(Idx t) {
   Int pos = 0;
   for (Int i = 0; i < t; ++i) {
     pos += geometrical_property::nb_facets[i] *
            geometrical_property::nb_nodes_per_facet[i];
   }
 
   return Eigen::Map<const Eigen::Matrix<Int, Eigen::Dynamic, Eigen::Dynamic>>(
       geometrical_property::facet_connectivity_vect.data() + pos,
       geometrical_property::nb_facets[t],
       geometrical_property::nb_nodes_per_facet[t]);
 }
 
 /* -------------------------------------------------------------------------- */
 template <GeometricalType geometrical_type, GeometricalShapeType shape>
 inline constexpr Int
 GeometricalElement<geometrical_type, shape>::getNbFacetsPerElement() {
   Int total_nb_facets = 0;
   for (Int n = 0; n < geometrical_property::nb_facet_types; ++n) {
     total_nb_facets += geometrical_property::nb_facets[n];
   }
 
   return total_nb_facets;
 }
 
 /* -------------------------------------------------------------------------- */
 template <GeometricalType geometrical_type, GeometricalShapeType shape>
 inline constexpr Int
 GeometricalElement<geometrical_type, shape>::getNbFacetsPerElement(Idx t) {
   return geometrical_property::nb_facets[t];
 }
 
 /* -------------------------------------------------------------------------- */
 template <GeometricalType geometrical_type, GeometricalShapeType shape>
 template <class D>
 inline bool GeometricalElement<geometrical_type, shape>::contains(
     const Eigen::MatrixBase<D> & coords) {
   return GeometricalShapeContains<shape>::contains(coords);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D>
 inline bool GeometricalShapeContains<_gst_point>::contains(
     const Eigen::MatrixBase<D> & coords) {
   return (coords(0) < std::numeric_limits<Real>::epsilon());
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D>
 inline bool GeometricalShapeContains<_gst_square>::contains(
     const Eigen::MatrixBase<D> & coords) {
   bool in = true;
   for (UInt i = 0; i < coords.size() && in; ++i) {
     in &= ((coords(i) >= -(1. + std::numeric_limits<Real>::epsilon())) &&
            (coords(i) <= (1. + std::numeric_limits<Real>::epsilon())));
   }
   return in;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D>
 inline bool GeometricalShapeContains<_gst_triangle>::contains(
     const Eigen::MatrixBase<D> & coords) {
   bool in = true;
   Real sum = 0;
   for (Int i = 0; (i < coords.size()) && in; ++i) {
     in &= ((coords(i) >= -(Math::getTolerance())) &&
            (coords(i) <= (1. + Math::getTolerance())));
     sum += coords(i);
   }
   if (in) {
     return (in && (sum <= (1. + Math::getTolerance())));
   }
   return in;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D>
 inline bool GeometricalShapeContains<_gst_prism>::contains(
     const Eigen::MatrixBase<D> & coords) {
   bool in = ((coords(0) >= -1.) && (coords(0) <= 1.)); // x in segment [-1, 1]
 
   // y and z in triangle
   in &= ((coords(1) >= 0) && (coords(1) <= 1.));
   in &= ((coords(2) >= 0) && (coords(2) <= 1.));
   Real sum = coords(1) + coords(2);
 
   return (in && (sum <= 1));
 }
 
 /* -------------------------------------------------------------------------- */
 /* InterpolationElement                                                       */
 /* -------------------------------------------------------------------------- */
 template <InterpolationType interpolation_type, InterpolationKind kind>
 template <typename D1, typename D2,
           aka::enable_if_t<aka::are_matrices<D1, D2>::value> *>
 inline void InterpolationElement<interpolation_type, kind>::computeShapes(
     const Eigen::MatrixBase<D1> & Xs, const Eigen::MatrixBase<D2> & N_) {
 
   Eigen::MatrixBase<D2> & N = const_cast<Eigen::MatrixBase<D2> &>(
       N_); // as advised by the Eigen developers
 
   for (auto && data : zip(Xs, N)) {
     computeShapes(std::get<0>(data), std::get<1>(data));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <InterpolationType interpolation_type, InterpolationKind kind>
 template <class D>
 inline void InterpolationElement<interpolation_type, kind>::computeDNDS(
     const Eigen::MatrixBase<D> & Xs, Tensor3Base<Real> & dNdS) {
   for (auto && data : zip(Xs, dNdS)) {
     computeDNDS(std::get<0>(data), std::get<1>(data));
   }
 }
 
-// /* --------------------------------------------------------------------------
-// */
-// /**
-//  * interpolate on a point a field for which values are given on the
-//  * node of the element using the shape functions at this interpolation point
-//  *
-//  * @param nodal_values values of the function per node @f$ f_{ij} = f_{n_i j}
-//  *@f$ so it should be a matrix of size nb_nodes_per_element @f$\times@f$
-//  *nb_degree_of_freedom
-//  * @param shapes value of shape functions at the interpolation point
-//  * @param interpolated interpolated value of f @f$ f_j(\xi) = \sum_i f_{n_i
-//  j} *N_i @f$
-//  */
-// template <InterpolationType interpolation_type, InterpolationKind kind>
-// template <typename Derived1, typename Derived2, typename Derived3,
-//           aka::enable_if_t<aka::conjunction<
-//               aka::is_matrice<Derived1>, aka::is_vector<Derived2>>::value> *
-//               = nullptr>
-// inline auto
-// InterpolationElement<interpolation_type, kind>::interpolate(
-//     const Eigen::MatrixBase<Derived1> & nodal_values,
-//     const Eigen::MatrixBase<Derived2> & shapes) {
-//   return nodal_values * shapes;
-// }
+/* -------------------------------------------------------------------------- */
+/**
+ * interpolate on a point a field for which values are given on the
+ * node of the element using the shape functions at this interpolation point
+ *
+ * @param nodal_values values of the function per node @f$ f_{ij} = f_{n_i j}
+ *@f$ so it should be a matrix of size nb_nodes_per_element @f$\times@f$
+ *nb_degree_of_freedom
+ * @param shapes value of shape functions at the interpolation point
+ * @param interpolated interpolated value of f @f$ f_j(\xi) = \sum_i f_{n_i
+ j} *N_i @f$
+ */
+template <InterpolationType interpolation_type, InterpolationKind kind>
+template <typename Derived1, typename Derived2>
+inline auto InterpolationElement<interpolation_type, kind>::interpolate(
+    const Eigen::MatrixBase<Derived1> & nodal_values,
+    const Eigen::MatrixBase<Derived2> & shapes) {
+  return nodal_values * shapes;
+}
 
 /* -------------------------------------------------------------------------- */
 /**
  * interpolate on several points a field  for which values are given on the
  * node of the element using the shape functions at the interpolation point
  *
  * @param nodal_values values of the function per node @f$ f_{ij} = f_{n_i j}
  *@f$ so it should be a matrix of size nb_nodes_per_element @f$\times@f$
  *nb_degree_of_freedom
  * @param shapes value of shape functions at the interpolation point
  * @param interpolated interpolated values of f @f$ f_j(\xi) = \sum_i f_{n_i j}
  *N_i @f$
  */
 template <InterpolationType interpolation_type, InterpolationKind kind>
-template <typename Derived1, typename Derived2, typename Derived3,
-          aka::enable_if_matrices_t<Derived1, Derived2, Derived3> *>
+template <typename Derived1, typename Derived2, typename Derived3>
 inline void InterpolationElement<interpolation_type, kind>::interpolate(
     const Eigen::MatrixBase<Derived1> & nodal_values,
     const Eigen::MatrixBase<Derived2> & Ns,
     const Eigen::MatrixBase<Derived3> & interpolated_) {
 
   auto && interpolated = const_cast<Eigen::MatrixBase<Derived3> &>(
       interpolated_); // as advised by the Eigen developers
 
   auto nb_points = Ns.cols();
   for (auto p = 0; p < nb_points; ++p) {
-    interpolated(p) = interpolate(nodal_values, Ns(p));
+    interpolate(interpolated.col(p), nodal_values, Ns.col(p));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * interpolate the field on a point given in natural coordinates the field which
  * values are given on the node of the element
  *
  * @param natural_coords natural coordinates of point where to interpolate \xi
  * @param nodal_values values of the function per node @f$ f_{ij} = f_{n_i j}
  *@f$ so it should be a matrix of size nb_nodes_per_element @f$\times@f$
  *nb_degree_of_freedom
  * @param interpolated interpolated value of f @f$ f_j(\xi) = \sum_i f_{n_i j}
  *N_i @f$
  */
 // template <InterpolationType interpolation_type, InterpolationKind kind>
 // inline decltype(auto)
 // InterpolationElement<interpolation_type,
 // kind>::interpolateOnNaturalCoordinates(
 //     const Ref<const VectorXr> & natural_coords,
 //     const Ref<const MatrixXr> & nodal_values, Ref<VectorXr> interpolated) {
 //   using interpolation = InterpolationProperty<interpolation_type>;
 //   Eigen::Matrix<Real, interpolation::nb_nodes_per_element, 1> shapes;
 //   computeShapes(natural_coords, shapes);
 
 //   return interpolate(nodal_values, shapes);
 // }
 
 /* -------------------------------------------------------------------------- */
 /// @f$ gradient_{ij} = \frac{\partial f_j}{\partial s_i} = \sum_k
 /// \frac{\partial N_k}{\partial s_i}f_{j n_k} @f$
 template <InterpolationType interpolation_type, InterpolationKind kind>
-template <typename Derived1, typename Derived2>
-inline decltype(auto)
+template <typename D1, typename D2, typename D3>
+inline void
 InterpolationElement<interpolation_type, kind>::gradientOnNaturalCoordinates(
-    const Eigen::MatrixBase<Derived1> & natural_coords,
-    const Eigen::MatrixBase<Derived2> & f) {
+    const Eigen::MatrixBase<D1> & natural_coords,
+    const Eigen::MatrixBase<D2> & f, const Eigen::MatrixBase<D3> & dfds_) {
   Eigen::Matrix<
       Real, InterpolationProperty<interpolation_type>::natural_space_dimension,
       InterpolationProperty<interpolation_type>::nb_nodes_per_element>
       dnds;
   computeDNDS(natural_coords, dnds);
-  return f * dnds.transpose();
+
+  auto & dfds = const_cast<Eigen::MatrixBase<D3> &>(dfds_);
+  dfds = f * dnds.transpose();
 }
 
 /* -------------------------------------------------------------------------- */
 /* ElementClass                                                               */
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
-inline void
-ElementClass<type, kind>::computeJMat(const Tensor3<Real> & dnds,
-                                      const Ref<const MatrixXr> & node_coords,
-                                      Tensor3<Real> & J) {
-  UInt nb_points = dnds.size(2);
-  for (UInt p = 0; p < nb_points; ++p) {
-    computeJMat(dnds(p), node_coords, J(p));
-  }
+template <class D1, class D2>
+inline decltype(auto) ElementClass<type, kind>::computeJMat(
+    const Eigen::MatrixBase<D1> & dnds,
+    const Eigen::MatrixBase<D2> & node_coords) {
+  /// @f$ J = dxds = dnds * x @f$
+  return dnds * node_coords.transpose();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
+template <class D>
 inline void
-ElementClass<type, kind>::computeJMat(const Ref<const MatrixXr> & dnds,
-                                      const Ref<const MatrixXr> & node_coords,
-                                      Ref<MatrixXr> J) {
-  /// @f$ J = dxds = dnds * x @f$
-  J = dnds * node_coords.transpose();
+ElementClass<type, kind>::computeJMat(const Tensor3Base<Real> & dnds,
+                                      const Eigen::MatrixBase<D> & node_coords,
+                                      Tensor3Base<Real> & J) {
+  for (auto && data : zip(J, dnds)) {
+    std::get<0>(data) = computeJMat(std::get<1>(data), node_coords);
+  }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
+template <class D1, class D2, class D3>
 inline void ElementClass<type, kind>::computeJacobian(
-    const Ref<const MatrixXr> & natural_coords,
-    const Ref<const MatrixXr> & node_coords, Ref<VectorXr> jacobians) {
-  UInt nb_points = natural_coords.cols();
+    const Eigen::MatrixBase<D1> & natural_coords,
+    const Eigen::MatrixBase<D2> & node_coords,
+    Eigen::MatrixBase<D3> & jacobians) {
+  auto nb_points = natural_coords.cols();
   Matrix<Real, interpolation_property::natural_space_dimension,
          interpolation_property::nb_nodes_per_element>
       dnds;
-  Ref<MatrixXr> J(natural_coords.rows(), node_coords.rows());
+  Matrix<Real> J(natural_coords.rows(), node_coords.rows());
 
-  for (UInt p = 0; p < nb_points; ++p) {
-    interpolation_element::computeDNDS(natural_coords(p), dnds);
-    computeJMat(dnds, node_coords, J);
-    computeJacobian(J, jacobians(p));
+  for (Int p = 0; p < nb_points; ++p) {
+    interpolation_element::computeDNDS(natural_coords.col(p), dnds);
+    J = computeJMat(dnds, node_coords);
+    jacobians(p) = computeJacobian(J);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
-inline void ElementClass<type, kind>::computeJacobian(const Tensor3<Real> & J,
-                                                      Ref<VectorXr> jacobians) {
-  UInt nb_points = J.size(2);
-  for (UInt p = 0; p < nb_points; ++p) {
-    computeJacobian(J(p), jacobians(p));
+template <class D>
+inline void
+ElementClass<type, kind>::computeJacobian(const Tensor3Base<Real> & J,
+                                          Eigen::MatrixBase<D> & jacobians) {
+  auto nb_points = J.size(2);
+  for (Int p = 0; p < nb_points; ++p) {
+    computeJacobian(J(p), jacobians.col(p));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
-inline void
-ElementClass<type, kind>::computeJacobian(const Ref<const MatrixXr> & J,
-                                          Real & jacobians) {
+template <class D>
+inline Real
+ElementClass<type, kind>::computeJacobian(const Eigen::MatrixBase<D> & J) {
   if (J.rows() == J.cols()) {
-    jacobians = J.determinant();
+    return J.determinant();
   } else {
-    interpolation_element::computeSpecialJacobian(J, jacobians);
+    switch (interpolation_property::natural_space_dimension) {
+    case 1: {
+      return J.norm();
+      break;
+    }
+    case 2: {
+      auto Jstatic =
+          Eigen::Map<const Eigen::Matrix<Real, 2, 3>>(J.derived().data());
+      return (Jstatic.row(0)).cross(Jstatic.row(1)).norm();
+    }
+    }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
-inline void
-ElementClass<type, kind>::computeShapeDerivatives(const Tensor3<Real> & J,
-                                                  const Tensor3<Real> & dnds,
-                                                  Tensor3<Real> & shape_deriv) {
-  UInt nb_points = J.size(2);
-  for (UInt p = 0; p < nb_points; ++p) {
-    computeShapeDerivatives(J(p), dnds(p), shape_deriv(p));
-  }
+template <class D1, class D2, class D3>
+inline void ElementClass<type, kind>::computeShapeDerivatives(
+    const Eigen::MatrixBase<D1> & J, const Eigen::MatrixBase<D2> & dnds,
+    Eigen::MatrixBase<D3> & shape_deriv) {
+  shape_deriv = J.inverse() * dnds;
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void ElementClass<type, kind>::computeShapeDerivatives(
-    const Ref<const MatrixXr> & J, const Ref<const MatrixXr> & dnds,
-    Ref<MatrixXr> shape_deriv) {
-  shape_deriv = J.inverse() * dnds;
+    const Tensor3Base<Real> & J, const Tensor3Base<Real> & dnds,
+    Tensor3Base<Real> & shape_deriv) {
+  auto nb_points = J.size(2);
+  for (Int p = 0; p < nb_points; ++p) {
+    auto && J_ = J(p);
+    auto && dnds_ = dnds(p);
+    auto && dndx_ = shape_deriv(p);
+    dndx_ = J_.inverse() * dnds_;
+    //    computeShapeDerivatives(J_, dnds_, dndx_);
+  }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
+template <class D1, class D2, class D3>
 inline void ElementClass<type, kind>::computeNormalsOnNaturalCoordinates(
-    const Ref<const MatrixXr> & coord, const Ref<const MatrixXr> & f,
-    Ref<MatrixXr> normals) {
-  UInt dimension = normals.rows();
-  UInt nb_points = coord.cols();
+    const Eigen::MatrixBase<D1> & coord, const Eigen::MatrixBase<D2> & f,
+    Eigen::MatrixBase<D3> & normals) {
+  auto dimension = normals.rows();
+  auto nb_points = coord.cols();
 
-  AKANTU_DEBUG_ASSERT((dimension - 1) ==
-                          interpolation_property::natural_space_dimension,
+  constexpr auto ndim = interpolation_property::natural_space_dimension;
+  AKANTU_DEBUG_ASSERT((dimension - 1) == ndim,
                       "cannot extract a normal because of dimension mismatch "
-                          << dimension - 1 << " "
-                          << interpolation_property::natural_space_dimension);
+                          << dimension - 1 << " " << ndim);
 
-  Matrix<Real> J(dimension, interpolation_property::natural_space_dimension);
-  for (UInt p = 0; p < nb_points; ++p) {
-    J = interpolation_element::gradientOnNaturalCoordinates(coord.col(p), f);
+  Matrix<Real, Eigen::Dynamic, ndim> J(dimension, ndim);
+  for (Int p = 0; p < nb_points; ++p) {
+    interpolation_element::gradientOnNaturalCoordinates(coord.col(p), f, J);
     if (dimension == 2) {
       Math::normal2(J.data(), normals.col(p).data());
     }
     if (dimension == 3) {
+
       Math::normal3(J.col(0).data(), J.col(1).data(), normals.col(p).data());
     }
   }
 }
 
 /* ------------------------------------------------------------------------- */
 /**
  * In the non linear cases we need to iterate to find the natural coordinates
  *@f$\xi@f$
  * provided real coordinates @f$x@f$.
  *
  * We want to solve: @f$ x- \phi(\xi) = 0@f$ with @f$\phi(\xi) = \sum_I N_I(\xi)
  *x_I@f$
  * the mapping function which uses the nodal coordinates @f$x_I@f$.
  *
  * To that end we use the Newton method and the following series:
  *
  * @f$ \frac{\partial \phi(x_k)}{\partial \xi} \left( \xi_{k+1} - \xi_k \right)
  *= x - \phi(x_k)@f$
  *
  * When we consider elements embedded in a dimension higher than them (2D
  *triangle in a 3D space for example)
  * @f$ J = \frac{\partial \phi(\xi_k)}{\partial \xi}@f$ is of dimension
  *@f$dim_{space} \times dim_{elem}@f$ which
  * is not invertible in most cases. Rather we can solve the problem:
  *
  * @f$ J^T J \left( \xi_{k+1} - \xi_k \right) = J^T \left( x - \phi(\xi_k)
  *\right) @f$
  *
  * So that
  *
  * @f$ d\xi = \xi_{k+1} - \xi_k = (J^T J)^{-1} J^T \left( x - \phi(\xi_k)
  *\right) @f$
  *
  * So that if the series converges we have:
  *
  * @f$ 0 = J^T \left( \phi(\xi_\infty) - x \right) @f$
  *
  * And we see that this is ill-posed only if @f$ J^T x = 0@f$ which means that
  *the vector provided
  * is normal to any tangent which means it is outside of the element itself.
  *
  * @param real_coords: the real coordinates the natural coordinates are sought
  *for
  * @param node_coords: the coordinates of the nodes forming the element
  * @param natural_coords: output->the sought natural coordinates
  * @param spatial_dimension: spatial dimension of the problem
  *
  **/
 template <ElementType type, ElementKind kind>
+template <class D1, class D2, class D3>
 inline void
-ElementClass<type, kind>::inverseMap(const Ref<const VectorXr> & real_coords,
-                                     const Ref<const MatrixXr> & node_coords,
-                                     Ref<VectorXr> natural_coords,
-                                     UInt max_iterations,
+ElementClass<type, kind>::inverseMap(const Eigen::MatrixBase<D1> & real_coords,
+                                     const Eigen::MatrixBase<D2> & node_coords,
+                                     Eigen::MatrixBase<D3> & natural_coords,
+                                     Int max_iterations,
                                      Real tolerance) {
-  UInt spatial_dimension = real_coords.size();
-  UInt dimension = natural_coords.size();
+  auto spatial_dimension = real_coords.size();
+  auto dimension = natural_coords.size();
 
   // matrix copy of the real_coords
-  Matrix<Real> mreal_coords(real_coords.data(), spatial_dimension, 1);
+  //  MatrixProxy<const Real> mreal_coords(real_coords.data(),
+  //  spatial_dimension,
+  // 1);
 
   // initial guess
   natural_coords.zero();
 
   // real space coordinates provided by initial guess
   Matrix<Real> physical_guess(spatial_dimension, 1);
 
   // objective function f = real_coords - physical_guess
   Matrix<Real> f(spatial_dimension, 1);
 
   // J Jacobian matrix computed on the natural_guess
   Matrix<Real> J(dimension, spatial_dimension);
 
   // J^t
   Matrix<Real> Jt(spatial_dimension, dimension);
 
   // G = J^t * J
   Matrix<Real> G(dimension, dimension);
 
   // Ginv = G^{-1}
   Matrix<Real> Ginv(dimension, dimension);
 
   // J = Ginv * J^t
   Matrix<Real> F(spatial_dimension, dimension);
 
   // dxi = \xi_{k+1} - \xi in the iterative process
   Matrix<Real> dxi(dimension, 1);
 
   Matrix<Real> dxit(1, dimension);
 
   /* --------------------------- */
   /* init before iteration loop  */
   /* --------------------------- */
   // do interpolation
   auto update_f = [&f, &physical_guess, &natural_coords, &node_coords,
                    &mreal_coords, spatial_dimension]() {
     Vector<Real> physical_guess_v(physical_guess.data(), spatial_dimension);
     interpolation_element::interpolateOnNaturalCoordinates(
         natural_coords, node_coords, physical_guess_v);
 
-    // compute initial objective function value f = real_coords - physical_guess
-    f = mreal_coords;
-    f -= physical_guess;
+    // compute initial objective function value f = real_coords -
+    // physical_guess
+    f = real_coords - physical_guess;
 
     // compute initial error
     auto error = f.norm();
     return error;
   };
 
   auto inverse_map_error = update_f();
   /* --------------------------- */
   /* iteration loop              */
   /* --------------------------- */
   UInt iterations{0};
   while (tolerance < inverse_map_error and iterations < max_iterations) {
     // compute J^t
     interpolation_element::gradientOnNaturalCoordinates(natural_coords,
                                                         node_coords, Jt);
     J = Jt.transpose();
 
     // compute G
     auto && G = J.transpose() * J;
 
     // compute F
     auto && F = G.inverse() * J.transpose();
 
     // compute increment
     auto && dxi = F * f;
 
     // update our guess
     natural_coords += dxi;
 
     inverse_map_error = update_f();
     iterations++;
   }
 
   if(iterations >= max_iterations) {
     AKANTU_EXCEPTION("The solver in inverse map did not converge");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 template <typename Derived1, typename Derived2, typename Derived3,
           aka::enable_if_matrices_t<Derived1, Derived2, Derived3> *>
 inline void ElementClass<type, kind>::inverseMap(
     const Eigen::MatrixBase<Derived1> & real_coords,
     const Eigen::MatrixBase<Derived2> & node_coords,
-    const Eigen::MatrixBase<Derived3> & natural_coords_, UInt max_iterations,
+    const Eigen::MatrixBase<Derived3> & natural_coords_, Int max_iterations,
     Real tolerance) {
-  Eigen::MatrixBase<Derived2> & natural_coords =
-      const_cast<Eigen::MatrixBase<Derived2> &>(
-          natural_coords_); // as advised by the Eigen developers
-
-  UInt nb_points = real_coords.cols();
-  for (UInt p = 0; p < nb_points; ++p) {
-    Vector<Real> X(real_coords(p));
-    Vector<Real> ncoord_p(natural_coords(p));
-    inverseMap(X, node_coords, ncoord_p, max_iterations, tolerance);
+  auto & natural_coords = const_cast<Eigen::MatrixBase<Derived2> &>(
+      natural_coords_); // as advised by the Eigen developers
+
+  auto nb_points = real_coords.cols();
+  for (Int p = 0; p < nb_points; ++p) {
+      inverseMap(real_coords(p), node_coords, natural_coords(p), max_iterations, tolerance);
   }
 }
 
 } // namespace akantu
 
 #endif /* AKANTU_ELEMENT_CLASS_TMPL_HH_ */
diff --git a/src/fe_engine/element_classes/element_class_hermite_inline_impl.hh b/src/fe_engine/element_classes/element_class_hermite_inline_impl.hh
index 6c838a960..51e72e745 100644
--- a/src/fe_engine/element_classes/element_class_hermite_inline_impl.hh
+++ b/src/fe_engine/element_classes/element_class_hermite_inline_impl.hh
@@ -1,185 +1,184 @@
 /**
  * @file   element_class_hermite_inline_impl.hh
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Nov 10 2017
  * @date last modification: Tue Feb 09 2021
  *
  * @brief  Specialization of the element_class class for the type
  * _hermite
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2016-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /**
  * @verbatim
    --x-----q1----|----q2-----x---> x
     -1          0            1
  @endverbatim
  *
  * @f[
  *   \begin{array}{ll}
  *     M_1(\xi) &= 1/4(\xi^{3}/-3\xi+2)\\
  *     M_2(\xi) &= -1/4(\xi^{3}-3\xi-2)
  *   \end{array}
  *
  *   \begin{array}{ll}
  *     L_1(\xi) &= 1/4(\xi^{3}-\xi^{2}-\xi+1)\\
  *     L_2(\xi) &= 1/4(\xi^{3}+\xi^{2}-\xi-1)
  *   \end{array}
  *
  *   \begin{array}{ll}
  *     M'_1(\xi) &= 3/4(\xi^{2}-1)\\
  *     M'_2(\xi) &= -3/4(\xi^{2}-1)
  *   \end{array}
  *
  *   \begin{array}{ll}
  *     L'_1(\xi) &= 1/4(3\xi^{2}-2\xi-1)\\
  *     L'_2(\xi) &= 1/4(3\xi^{2}+2\xi-1)
  *   \end{array}
  *@f]
  *
  *
  *@f[
  * \begin{array}{ll}
  *   N'_1(\xi) &= -1/2\\
  *   N'_2(\xi) &= 1/2
  * \end{array}]
  *
  * \begin{array}{ll}
  *   -M''_1(\xi) &= -3\xi/2\\
  *   -M''_2(\xi) &= 3\xi/2\\
  * \end{array}
  *
  * \begin{array}{ll}
  *   -L''_1(\xi) &= -1/2a(3\xi/a-1)\\
  *   -L''_2(\xi) &= -1/2a(3\xi/a+1)
  * \end{array}
  *@f]
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_static_if.hh"
 //#include "element_class_structural.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_ELEMENT_CLASS_HERMITE_INLINE_IMPL_HH_
 #define AKANTU_ELEMENT_CLASS_HERMITE_INLINE_IMPL_HH_
 
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 
 AKANTU_DEFINE_STRUCTURAL_INTERPOLATION_TYPE_PROPERTY(_itp_hermite_2,
                                                      _itp_lagrange_segment_2, 2,
                                                      1, 4);
 
 /* -------------------------------------------------------------------------- */
-
 namespace {
-  namespace details {
-    inline Real computeLength(const Matrix<Real> & real_coord) {
-      Vector<Real> x1 = real_coord(0);
-      Vector<Real> x2 = real_coord(1);
-      return x1.distance(x2);
-    }
+namespace details {
+  template <class D1>
+  inline Real computeLength(const Eigen::MatrixBase<D1> & real_coord) {
+    auto && x1 = real_coord(0);
+    auto && x2 = real_coord(1);
+    return x1.distance(x2);
+  }
 
     inline void computeShapes(const Vector<Real> & natural_coords, Real a,
                               Matrix<Real> & N) {
       /// natural coordinate
       Real xi = natural_coords(0);
       auto xi2 = xi * xi;
       auto xi3 = xi * xi * xi;
       // Cubic Hermite splines interpolating displacement
       auto M1 = 1. / 4. * (2. - 3. * xi + xi3);
       auto M2 = 1. / 4. * (2. + 3. * xi - xi3);
       auto L1 = a / 4. * (1 - xi - xi2 + xi3);
       auto L2 = a / 4. * (-1 - xi + xi2 + xi3);
-      ;
 
 #if 1 // Version where we also interpolate the rotations
       // Derivatives (with respect to x) of previous functions interpolating
       // rotations
       auto M1_ = 3. / (4. * a) * (xi2 - 1);
       auto M2_ = 3. / (4. * a) * (1 - xi2);
       auto L1_ = 1 / 4. * (3 * xi2 - 2 * xi - 1);
       auto L2_ = 1 / 4. * (3 * xi2 + 2 * xi - 1);
 
       // clang-format off
       //    v1   t1   v2   t2
       N << M1 , L1 , M2 , L2,   // displacement interpolation
            M1_, L1_, M2_, L2_; // rotation interpolation
       // clang-format on
 
 #else // Version where we only interpolate displacements
       // clang-format off
       //    v1  t1  v2  t2
       N = {{M1, L1, M2, L2}};
 // clang-format on
 #endif
     }
 
     /* ---------------------------------------------------------------------- */
     template <class D1, class D2>
     inline void computeDNDS(const Eigen::MatrixBase<D1> & natural_coords,
                             Real a, Eigen::MatrixBase<D2> & B) {
       // natural coordinate
       Real xi = natural_coords(0);
       // Derivatives with respect to xi for rotations
       auto M1 = 3. / 2. * xi;
       auto M2 = 3. / 2. * (-xi);
       auto L1 = 1. * a / 2. * (3 * xi - 1);
       auto L2 = 1. * a / 2. * (3 * xi + 1);
 
       //   v1  t1  v2  t2
       B << M1, L1, M2, L2; // computing curvature : {chi} = [B]{d}
       B /= a;              // to account for first order deriv w/r to x
     }
   } // namespace details
 } // namespace
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <typename Derived1, typename Derived2, typename Derived3>
 inline void
 InterpolationElement<_itp_hermite_2, _itk_structural>::computeShapes(
     const Eigen::MatrixBase<Derived1> & natural_coords,
     const Eigen::MatrixBase<Derived2> & real_coord,
     Eigen::MatrixBase<Derived3> & N) {
   auto L = details::computeLength(real_coord);
   details::computeShapes(natural_coords, L / 2, N);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <typename D1, typename D2, typename D3>
 inline void InterpolationElement<_itp_hermite_2, _itk_structural>::computeDNDS(
     const Eigen::MatrixBase<D1> & Xs, const Eigen::MatrixBase<D2> & xs,
     Eigen::MatrixBase<D3> & B) {
   auto L = details::computeLength(xs);
   details::computeDNDS(Xs, L / 2, B);
 }
 
 } // namespace akantu
 #endif /* AKANTU_ELEMENT_CLASS_HERMITE_INLINE_IMPL_HH_ */
diff --git a/src/fe_engine/element_classes/element_class_point_1_inline_impl.hh b/src/fe_engine/element_classes/element_class_point_1_inline_impl.hh
index fe75a4d69..b01c77d9d 100644
--- a/src/fe_engine/element_classes/element_class_point_1_inline_impl.hh
+++ b/src/fe_engine/element_classes/element_class_point_1_inline_impl.hh
@@ -1,89 +1,95 @@
 /**
  * @file   element_class_point_1_inline_impl.hh
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri Feb 28 2020
  *
  * @brief  Specialization of the element_class class for the type _point_1
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /**
  * @verbatim
       x
     (0)
  @endverbatim
  *
  * @f{eqnarray*}{
  * N1 &=& 1
  * @f}
  *
  * @f{eqnarray*}{
  * q_0 &=& 0
  * @f}
  */
 
 /* -------------------------------------------------------------------------- */
 #include "element_class.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_point_1, _gt_point, _itp_lagrange_point_1,
                                      _ek_regular, 0, _git_point, 1);
 
+template<>
+template <class D1, class D2, class D3>
+inline void ElementClass<_point_1, _ek_regular>::computeNormalsOnNaturalCoordinates(
+const Eigen::MatrixBase<D1> & /*coord*/, const Eigen::MatrixBase<D2> & /*f*/,
+Eigen::MatrixBase<D3> & /*normals*/) { }
+
 /* --------------r------------------------------------------------------------
  */
 template <>
 template <class D1, class D2,
           aka::enable_if_t<aka::are_vectors<D1, D2>::value> *>
 inline void InterpolationElement<_itp_lagrange_point_1>::computeShapes(
     const Eigen::MatrixBase<D1> & /*natural_coords*/,
     Eigen::MatrixBase<D2> & N) {
   N(0) = 1; /// N1(q_0)
 }
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2>
 inline void InterpolationElement<_itp_lagrange_point_1>::computeDNDS(
     const Eigen::MatrixBase<D1> & /*natural_coords*/,
     Eigen::MatrixBase<D2> & /*dnds*/) {}
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D>
 inline Real InterpolationElement<_itp_lagrange_point_1>::computeSpecialJacobian(
     const Eigen::MatrixBase<D> & /*J*/) {
   return 0.;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D>
 inline Real GeometricalElement<_gt_point>::getInradius(
     const Eigen::MatrixBase<D> & /*coord*/) {
   return 0.;
 }
 } // namespace akantu
diff --git a/src/fe_engine/element_classes/element_class_quadrangle_4_inline_impl.hh b/src/fe_engine/element_classes/element_class_quadrangle_4_inline_impl.hh
index 33d3c377e..d5f8a8958 100644
--- a/src/fe_engine/element_classes/element_class_quadrangle_4_inline_impl.hh
+++ b/src/fe_engine/element_classes/element_class_quadrangle_4_inline_impl.hh
@@ -1,180 +1,170 @@
 /**
  * @file   element_class_quadrangle_4_inline_impl.hh
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Dec 13 2010
  * @date last modification: Fri Dec 11 2020
  *
  * @brief  Specialization of the element_class class for the type _quadrangle_4
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /**
  * @verbatim
          \eta
       ^
  (-1,1)   |   (1,1)
      x---------x
      |    |    |
      |    |    |
    --|---------|----->  \xi
      |    |    |
      |    |    |
      x---------x
  (-1,-1)  |   (1,-1)
  @endverbatim
  *
  * @f[
  * \begin{array}{lll}
  * N1 = (1 - \xi) (1 - \eta) / 4
  *       & \frac{\partial N1}{\partial \xi}  = - (1 - \eta) / 4
  *       & \frac{\partial N1}{\partial \eta} = - (1 - \xi) / 4 \\
  * N2 = (1 + \xi) (1 - \eta) / 4 \\
  *       & \frac{\partial N2}{\partial \xi}  = (1 - \eta) / 4
  *       & \frac{\partial N2}{\partial \eta} = - (1 + \xi) / 4 \\
  * N3 = (1 + \xi) (1 + \eta) / 4 \\
  *       & \frac{\partial N3}{\partial \xi}  = (1 + \eta) / 4
  *       & \frac{\partial N3}{\partial \eta} = (1 + \xi) / 4 \\
  * N4 = (1 - \xi) (1 + \eta) / 4
  *       & \frac{\partial N4}{\partial \xi}  = - (1 + \eta) / 4
  *       & \frac{\partial N4}{\partial \eta} = (1 - \xi) / 4 \\
  * \end{array}
  * @f]
  *
  * @f{eqnarray*}{
  * \xi_{q0}  &=& 0 \qquad  \eta_{q0} = 0
  * @f}
  */
 
 /* -------------------------------------------------------------------------- */
 #include "element_class.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_quadrangle_4, _gt_quadrangle_4,
                                      _itp_lagrange_quadrangle_4, _ek_regular, 2,
                                      _git_segment, 2);
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2,
           aka::enable_if_t<aka::are_vectors<D1, D2>::value> *>
 inline void InterpolationElement<_itp_lagrange_quadrangle_4>::computeShapes(
     const Eigen::MatrixBase<D1> & c, Eigen::MatrixBase<D2> & N) {
   N(0) = 1. / 4. * (1. - c(0)) * (1. - c(1)); /// N1(q_0)
   N(1) = 1. / 4. * (1. + c(0)) * (1. - c(1)); /// N2(q_0)
   N(2) = 1. / 4. * (1. + c(0)) * (1. + c(1)); /// N3(q_0)
   N(3) = 1. / 4. * (1. - c(0)) * (1. + c(1)); /// N4(q_0)
 }
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2>
 inline void InterpolationElement<_itp_lagrange_quadrangle_4>::computeDNDS(
     const Eigen::MatrixBase<D1> & c, Eigen::MatrixBase<D2> & dnds) {
   /**
    * @f[
    * dnds = \left(
    *          \begin{array}{cccc}
    *            \frac{\partial N1}{\partial \xi}  & \frac{\partial N2}{\partial
    * \xi}
    *               & \frac{\partial N3}{\partial \xi}  & \frac{\partial
    * N4}{\partial \xi}\\
    *            \frac{\partial N1}{\partial \eta} & \frac{\partial N2}{\partial
    * \eta}
    *               & \frac{\partial N3}{\partial \eta} & \frac{\partial
    * N4}{\partial \eta}
    *          \end{array}
    *        \right)
    * @f]
    */
 
   dnds(0, 0) = -1. / 4. * (1. - c(1));
   dnds(0, 1) = 1. / 4. * (1. - c(1));
   dnds(0, 2) = 1. / 4. * (1. + c(1));
   dnds(0, 3) = -1. / 4. * (1. + c(1));
 
   dnds(1, 0) = -1. / 4. * (1. - c(0));
   dnds(1, 1) = -1. / 4. * (1. + c(0));
   dnds(1, 2) = 1. / 4. * (1. + c(0));
   dnds(1, 3) = 1. / 4. * (1. - c(0));
 }
 
 /* -------------------------------------------------------------------------- */
 template<>
 template <class vector_type, class matrix_type>
 inline void InterpolationElement<_itp_lagrange_quadrangle_4>::computeD2NDS2(
     const vector_type & /*c*/, matrix_type & d2nds2) {
   d2nds2.zero();
 
   d2nds2(1, 0) = 1./4.;
   d2nds2(1, 1) = -1./4.;
   d2nds2(1, 2) = 1./4.;
   d2nds2(1, 3) = -1./4.;
 
   d2nds2(2, 0) = 1./4.;
   d2nds2(2, 1) = -1./4.;
   d2nds2(2, 2) = 1./4.;
   d2nds2(2, 3) = -1./4.;
 }
 
-/* -------------------------------------------------------------------------- */
-template <>
-template <class D>
-inline Real
-InterpolationElement<_itp_lagrange_quadrangle_4>::computeSpecialJacobian(
-    const Eigen::MatrixBase<D> & J) {
-  auto Jstatic = Eigen::Map<const Eigen::Matrix<Real, 2, 3>>(J.data());
-  return (Jstatic.row(0).cross(Jstatic.row(1))).norm();
-}
-
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D>
 inline Real GeometricalElement<_gt_quadrangle_4>::getInradius(
     const Eigen::MatrixBase<D> & coord) {
   auto && u0 = coord.col(0);
   auto && u1 = coord.col(1);
   auto && u2 = coord.col(2);
   auto && u3 = coord.col(3);
   Real a = (u0 - u1).norm();
   Real b = (u1 - u2).norm();
   Real c = (u2 - u3).norm();
   Real d = (u3 - u0).norm();
 
   // Real septimetre = (a + b + c + d) / 2.;
 
   // Real p = Math::distance_2d(coord + 0, coord + 4);
   // Real q = Math::distance_2d(coord + 2, coord + 6);
 
   // Real area = sqrt(4*(p*p * q*q) - (a*a + b*b + c*c + d*d)*(a*a + c*c - b*b -
   // d*d)) / 4.;
   // Real h = sqrt(area);  // to get a length
   // Real h = area / septimetre;  // formula of inradius for circumscritable
   // quadrelateral
   Real h = std::min({a, b, c, d});
 
   return h;
 }
 } // namespace akantu
diff --git a/src/fe_engine/element_classes/element_class_quadrangle_8_inline_impl.hh b/src/fe_engine/element_classes/element_class_quadrangle_8_inline_impl.hh
index 0fd60e7b1..0d038d6f1 100644
--- a/src/fe_engine/element_classes/element_class_quadrangle_8_inline_impl.hh
+++ b/src/fe_engine/element_classes/element_class_quadrangle_8_inline_impl.hh
@@ -1,191 +1,180 @@
 /**
  * @file   element_class_quadrangle_8_inline_impl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed May 18 2011
  * @date last modification: Tue Sep 29 2020
  *
  * @brief  Specialization of the ElementClass for the _quadrangle_8
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /**
  * @verbatim
               \eta
                ^
                |
    (-1,1)    (0,1)   (1,1)
        x-------x-------x
        |       |       |
        |       |       |
        |       |       |
  (-1,0)|       |       |(1,0)
    ----x---------------X----->  \xi
        |       |       |
        |       |       |
        |       |       |
        |       |       |
        x-------x-------x
    (-1,-1)   (0,-1)  (1,-1)
                |
  @endverbatim
  *
  * @f[
  * \begin{array}{lll}
  * N1 = (1 - \xi) (1 - \eta)(- 1 - \xi - \eta) / 4
  *       & \frac{\partial N1}{\partial \xi}  = (1 - \eta)(2 \xi + \eta) / 4
  *       & \frac{\partial N1}{\partial \eta} = (1 - \xi)(\xi + 2 \eta) / 4 \\
  * N2 = (1 + \xi) (1 - \eta)(- 1 + \xi - \eta) / 4 \\
  *       & \frac{\partial N2}{\partial \xi}  = (1 - \eta)(2 \xi - \eta) / 4
  *       & \frac{\partial N2}{\partial \eta} = - (1 + \xi)(\xi - 2 \eta) / 4 \\
  * N3 = (1 + \xi) (1 + \eta)(- 1 + \xi + \eta) / 4 \\
  *       & \frac{\partial N3}{\partial \xi}  = (1 + \eta)(2 \xi + \eta) / 4
  *       & \frac{\partial N3}{\partial \eta} = (1 + \xi)(\xi + 2 \eta) / 4 \\
  * N4 = (1 - \xi) (1 + \eta)(- 1 - \xi + \eta) / 4
  *       & \frac{\partial N4}{\partial \xi}  = (1 + \eta)(2 \xi - \eta) / 4
  *       & \frac{\partial N4}{\partial \eta} = - (1 - \xi)(\xi - 2 \eta) / 4 \\
  * N5 = (1 - \xi^2) (1 - \eta) / 2
  *       & \frac{\partial N1}{\partial \xi}  = - \xi (1 - \eta)
  *       & \frac{\partial N1}{\partial \eta} = - (1 - \xi^2) / 2  \\
  * N6 = (1 + \xi) (1 - \eta^2) / 2 \\
  *       & \frac{\partial N2}{\partial \xi}  = (1 - \eta^2) / 2
  *       & \frac{\partial N2}{\partial \eta} = - \eta (1 + \xi) \\
  * N7 = (1 - \xi^2) (1 + \eta) / 2 \\
  *       & \frac{\partial N3}{\partial \xi}  = - \xi (1 + \eta)
  *       & \frac{\partial N3}{\partial \eta} = (1 - \xi^2) / 2 \\
  * N8 = (1 - \xi) (1 - \eta^2) / 2
  *       & \frac{\partial N4}{\partial \xi}  = - (1 - \eta^2) / 2
  *       & \frac{\partial N4}{\partial \eta} = - \eta (1 - \xi) \\
  * \end{array}
  * @f]
  *
  * @f{eqnarray*}{
  * \xi_{q0}  &=& 0 \qquad  \eta_{q0} = 0
  * @f}
  */
 
 /* -------------------------------------------------------------------------- */
 #include "element_class.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_quadrangle_8, _gt_quadrangle_8,
                                      _itp_serendip_quadrangle_8, _ek_regular, 2,
                                      _git_segment, 3);
 
 /* -------------------------------------------------------------------------- */
 template <>
 template<class D1, class D2, aka::enable_if_t<aka::are_vectors<D1, D2>::value> *>
 inline void InterpolationElement<_itp_serendip_quadrangle_8>::computeShapes(
     const Eigen::MatrixBase<D1> & c, Eigen::MatrixBase<D2> & N) {
 
   /// Natural coordinates
   const Real xi = c(0);
   const Real eta = c(1);
 
   N(0) = .25 * (1 - xi) * (1 - eta) * (-1 - xi - eta);
   N(1) = .25 * (1 + xi) * (1 - eta) * (-1 + xi - eta);
   N(2) = .25 * (1 + xi) * (1 + eta) * (-1 + xi + eta);
   N(3) = .25 * (1 - xi) * (1 + eta) * (-1 - xi + eta);
   N(4) = .5 * (1 - xi * xi) * (1 - eta);
   N(5) = .5 * (1 + xi) * (1 - eta * eta);
   N(6) = .5 * (1 - xi * xi) * (1 + eta);
   N(7) = .5 * (1 - xi) * (1 - eta * eta);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template<class D1, class D2>
 inline void InterpolationElement<_itp_serendip_quadrangle_8>::computeDNDS(
     const Eigen::MatrixBase<D1> & c, Eigen::MatrixBase<D2> & dnds) {
 
   const Real xi = c(0);
   const Real eta = c(1);
 
   /// dN/dxi
   dnds(0, 0) = .25 * (1 - eta) * (2 * xi + eta);
   dnds(0, 1) = .25 * (1 - eta) * (2 * xi - eta);
   dnds(0, 2) = .25 * (1 + eta) * (2 * xi + eta);
   dnds(0, 3) = .25 * (1 + eta) * (2 * xi - eta);
   dnds(0, 4) = -xi * (1 - eta);
   dnds(0, 5) = .5 * (1 - eta * eta);
   dnds(0, 6) = -xi * (1 + eta);
   dnds(0, 7) = -.5 * (1 - eta * eta);
 
   /// dN/deta
   dnds(1, 0) = .25 * (1 - xi) * (2 * eta + xi);
   dnds(1, 1) = .25 * (1 + xi) * (2 * eta - xi);
   dnds(1, 2) = .25 * (1 + xi) * (2 * eta + xi);
   dnds(1, 3) = .25 * (1 - xi) * (2 * eta - xi);
   dnds(1, 4) = -.5 * (1 - xi * xi);
   dnds(1, 5) = -eta * (1 + xi);
   dnds(1, 6) = .5 * (1 - xi * xi);
   dnds(1, 7) = -eta * (1 - xi);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template<class D>
 inline Real
 GeometricalElement<_gt_quadrangle_8>::getInradius(const Eigen::MatrixBase<D> & coord) {
   Real a, b, h;
 
   auto && u0 = coord.col(0);
   auto && u1 = coord.col(1);
   auto && u2 = coord.col(2);
   auto && u3 = coord.col(3);
   auto && u4 = coord.col(4);
   auto && u5 = coord.col(5);
   auto && u6 = coord.col(6);
   auto && u7 = coord.col(7);
 
   a = (u0 - u4).norm();
   b = (u4 - u1).norm();
   h = std::min(a, b);
 
   a = (u1 - u5).norm();
   b = (u5 - u2).norm();
   h = std::min(h, std::min(a, b));
 
   a = (u2 - u6).norm();
   b = (u6 - u3).norm();
   h = std::min(h, std::min(a, b));
 
   a = (u3 - u7).norm();
   b = (u7 - u0).norm();
   h = std::min(h, std::min(a, b));
 
   return h;
 }
-
-/* -------------------------------------------------------------------------- */
-template <>
-template<class D>
-inline Real
-InterpolationElement<_itp_serendip_quadrangle_8>::computeSpecialJacobian(
-    const Eigen::MatrixBase<D> & J) {
-  auto Jstatic = Eigen::Map<const Eigen::Matrix<Real, 2, 3>>(J.data());
-  return Jstatic.row(0).cross(Jstatic.row(1)).norm();
-}
-} // namespace akantu
diff --git a/src/fe_engine/element_classes/element_class_segment_2_inline_impl.hh b/src/fe_engine/element_classes/element_class_segment_2_inline_impl.hh
index f3cdfafea..4910e0154 100644
--- a/src/fe_engine/element_classes/element_class_segment_2_inline_impl.hh
+++ b/src/fe_engine/element_classes/element_class_segment_2_inline_impl.hh
@@ -1,127 +1,119 @@
 /**
  * @file   element_class_segment_2_inline_impl.hh
  *
  * @author Emil Gallyamov <emil.gallyamov@epfl.ch>
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jul 16 2010
  * @date last modification: Fri Dec 11 2020
  *
  * @brief  Specialization of the element_class class for the type _segment_2
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /**
  * @verbatim
               q
    --x--------|--------x---> x
     -1        0        1
  @endverbatim
  *
  * @f{eqnarray*}{
  * w_1(x) &=& 1/2(1 - x) \\
  * w_2(x) &=& 1/2(1 + x)
  * @f}
  *
  * @f{eqnarray*}{
  * x_{q}  &=& 0
  * @f}
  */
 
 /* -------------------------------------------------------------------------- */
 #include "element_class.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_segment_2, _gt_segment_2,
                                      _itp_lagrange_segment_2, _ek_regular, 1,
                                      _git_segment, 1);
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2,
           aka::enable_if_t<aka::are_vectors<D1, D2>::value> *>
 inline void InterpolationElement<_itp_lagrange_segment_2>::computeShapes(
     const Eigen::MatrixBase<D1> & natural_coords, Eigen::MatrixBase<D2> & N) {
 
   /// natural coordinate
   Real c = natural_coords(0);
   /// shape functions
   N(0) = 0.5 * (1 - c);
   N(1) = 0.5 * (1 + c);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2>
 inline void InterpolationElement<_itp_lagrange_segment_2>::computeDNDS(
     const Eigen::MatrixBase<D1> & /*natural_coords*/,
     Eigen::MatrixBase<D2> & dnds) {
 
   /// dN1/de
   dnds(0, 0) = -.5;
   /// dN2/de
   dnds(0, 1) = .5;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type, class matrix_type>
 inline void InterpolationElement<_itp_lagrange_segment_2>::computeD2NDS2(
     const vector_type & /*natural_coords*/, matrix_type & d2nds2) {
   d2nds2.zero();
 }
 
-/* -------------------------------------------------------------------------- */
-template <D>
-inline void
-InterpolationElement<_itp_lagrange_segment_2>::computeSpecialJacobian(
-    const Eigen::MatrixBase<D> & dxds) {
-  return dxds.norm();
-}
-
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D>
 inline Real GeometricalElement<_gt_segment_2>::getInradius(
     const Eigen::MatrixBase<D> & coord) {
   auto a{coord(0)};
   auto b{coord(1)};
 
   return (b - a).norm();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2>
 inline void GeometricalElement<_gt_segment_2>::getNormal(
     const Eigen::MatrixBase<D1> & coord, Eigen::MatrixBase<D2> & normal) {
   AKANTU_DEBUG_ASSERT(normal.size() == 2,
                       "The normal is only uniquely defined in 2D");
   Vector<Real> tmp = coord.col(0) - coord.col(1);
   Math::normal2(tmp.data(), normal.data());
 }
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
diff --git a/src/fe_engine/element_classes/element_class_segment_3_inline_impl.hh b/src/fe_engine/element_classes/element_class_segment_3_inline_impl.hh
index d29e5c5a5..0886a93d5 100644
--- a/src/fe_engine/element_classes/element_class_segment_3_inline_impl.hh
+++ b/src/fe_engine/element_classes/element_class_segment_3_inline_impl.hh
@@ -1,124 +1,115 @@
 /**
  * @file   element_class_segment_3_inline_impl.hh
  *
  * @author Emil Gallyamov <emil.gallyamov@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jul 16 2010
  * @date last modification: Wed Dec 09 2020
  *
  * @brief  Specialization of the element_class class for the type _segment_3
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /**
  * @verbatim
          -1         0         1
      -----x---------x---------x-----> x
           1         3         2
  @endverbatim
  *
  *
  * @f[
  * \begin{array}{lll}
  *   x_{1}  = -1   &  x_{2} = 1 & x_{3} = 0
  * \end{array}
  * @f]
  *
  * @f[
  * \begin{array}{ll}
  *   w_1(x) = \frac{x}{2}(x - 1) & w'_1(x) = x - \frac{1}{2}\\
  *   w_2(x) = \frac{x}{2}(x + 1) & w'_2(x) = x + \frac{1}{2}\\
  *   w_3(x) =  1-x^2 & w'_3(x) = -2x
  * \end{array}
  * @f]
  *
  * @f[
  * \begin{array}{ll}
  * x_{q1}  = -1/\sqrt{3} & x_{q2} = 1/\sqrt{3}
  * \end{array}
  * @f]
  */
 
 /* -------------------------------------------------------------------------- */
 #include "element_class.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_segment_3, _gt_segment_3,
                                      _itp_lagrange_segment_3, _ek_regular, 1,
                                      _git_segment, 2);
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2,
           aka::enable_if_t<aka::are_vectors<D1, D2>::value> *>
 inline void InterpolationElement<_itp_lagrange_segment_3>::computeShapes(
     const Eigen::MatrixBase<D1> & natural_coords, Eigen::MatrixBase<D2> & N) {
   Real c = natural_coords(0);
   N(0) = (c - 1) * c / 2;
   N(1) = (c + 1) * c / 2;
   N(2) = 1 - c * c;
 }
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2>
 inline void InterpolationElement<_itp_lagrange_segment_3>::computeDNDS(
     const Eigen::MatrixBase<D1> & natural_coords,
     Eigen::MatrixBase<D2> & dnds) {
 
   Real c = natural_coords(0);
   dnds(0, 0) = c - .5;
   dnds(0, 1) = c + .5;
   dnds(0, 2) = -2 * c;
 }
 
-/* -------------------------------------------------------------------------- */
-template <>
-template <class D>
-inline Real
-InterpolationElement<_itp_lagrange_segment_3>::computeSpecialJacobian(
-    const Eigen::MatrixBase<D> & dxds) {
-  return Math::norm2(dxds.data());
-}
-
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D>
 inline Real GeometricalElement<_gt_segment_3>::getInradius(
     const Eigen::MatrixBase<D> & coord) {
   auto dist1 = (coord(1) - coord(0)).norm();
   auto dist2 = (coord(2) - coord(1)).norm();
   return std::min(dist1, dist2);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2>
 inline void GeometricalElement<_gt_segment_3>::getNormal(
     const Eigen::MatrixBase<D1> & coord, Eigen::MatrixBase<D2> & normal) {
   Eigen::Matrix<Real, 1, 1> natural_coords;
   natural_coords << .5;
   ElementClass<_segment_3>::computeNormalsOnNaturalCoordinates(natural_coords,
                                                                coord, normal);
 }
diff --git a/src/fe_engine/element_classes/element_class_triangle_3_inline_impl.hh b/src/fe_engine/element_classes/element_class_triangle_3_inline_impl.hh
index cca37b1b8..b49a45b75 100644
--- a/src/fe_engine/element_classes/element_class_triangle_3_inline_impl.hh
+++ b/src/fe_engine/element_classes/element_class_triangle_3_inline_impl.hh
@@ -1,132 +1,122 @@
 /**
  * @file   element_class_triangle_3_inline_impl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jul 16 2010
  * @date last modification: Fri Dec 11 2020
  *
  * @brief  Specialization of the element_class class for the type _triangle_3
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /**
  * @verbatim
        \eta
      ^
      |
      x (0,0,1)
      |`
      |  `
      |  q `
      |  °   `
      x--------x----->  \xi
     (1,0,0)      (0,1,0)
  @endverbatim
  *
  * @f{eqnarray*}{
  * N1 &=& 1 - \xi - \eta \\
  * N2 &=& \xi \\
  * N3 &=& \eta
  * @f}
  *
  * @f{eqnarray*}{
  * \xi_{q0}  &=& 1/3 \qquad  \eta_{q0} = 1/3
  * @f}
  */
 
 /* -------------------------------------------------------------------------- */
 #include "element_class.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_triangle_3, _gt_triangle_3,
                                      _itp_lagrange_triangle_3, _ek_regular, 2,
                                      _git_triangle, 1);
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2, aka::enable_if_t<aka::are_vectors<D1, D2>::value> *>
 inline void InterpolationElement<_itp_lagrange_triangle_3>::computeShapes(
     const Eigen::MatrixBase<D1> & X, Eigen::MatrixBase<D2> & N) {
   N(0) = 1 - X(0) - X(1); /// @f$ c0 = 1 - \xi - \eta @f$
   N(1) = X(0);              /// @f$ c1 = \xi @f$
   N(2) = X(1);              /// @f$ c2 = \eta @f$
 }
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2>
 inline void InterpolationElement<_itp_lagrange_triangle_3>::computeDNDS(
     const Eigen::MatrixBase<D1> & /*natural_coords*/,
     Eigen::MatrixBase<D2> & dnds) {
   /**
    * @f[
    * dnds = \left(
    *          \begin{array}{cccccc}
    *            \frac{\partial N1}{\partial \xi}  & \frac{\partial N2}{\partial
    * \xi}  & \frac{\partial N3}{\partial \xi} \\
    *            \frac{\partial N1}{\partial \eta} & \frac{\partial N2}{\partial
    * \eta} & \frac{\partial N3}{\partial \eta}
    *          \end{array}
    *        \right)
    * @f]
    */
   dnds(0, 0) = -1.;
   dnds(0, 1) = 1.;
   dnds(0, 2) = 0.;
   dnds(1, 0) = -1.;
   dnds(1, 1) = 0.;
   dnds(1, 2) = 1.;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type, class matrix_type>
 inline void InterpolationElement<_itp_lagrange_triangle_3>::computeD2NDS2(
     const vector_type & /*natural_coords*/, matrix_type & d2nds2) {
   d2nds2.zero();
 }
 
-/* -------------------------------------------------------------------------- */
-template <>
-template <class D>
-inline void
-InterpolationElement<_itp_lagrange_triangle_3>::computeSpecialJacobian(
-    const Eigen::MatrixBase<D> & J) {
-  const auto & Jt = J.transpose();
-  return Jt(0).cross(Jt(1)).norm();
-}
-
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D>
 inline Real GeometricalElement<_gt_triangle_3>::getInradius(
     const Eigen::MatrixBase<D> & coord) {
   return 2. * Math::triangle_inradius(coord.col(0), coord.col(1),
                                       coord.col(2));
 }
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
diff --git a/src/fe_engine/element_classes/element_class_triangle_6_inline_impl.hh b/src/fe_engine/element_classes/element_class_triangle_6_inline_impl.hh
index 4cc12dcad..0ee193593 100644
--- a/src/fe_engine/element_classes/element_class_triangle_6_inline_impl.hh
+++ b/src/fe_engine/element_classes/element_class_triangle_6_inline_impl.hh
@@ -1,203 +1,193 @@
 /**
  * @file   element_class_triangle_6_inline_impl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jul 16 2010
  * @date last modification: Fri Feb 28 2020
  *
  * @brief  Specialization of the element_class class for the type _triangle_6
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /**
  * @verbatim
         \eta
           ^
           |
           x 2
           | `
           |   `
           |  .  `
           |   q2  `
         5 x          x 4
           |           `
           |             `
           |  .q0     q1.  `
           |                 `
           x---------x---------x-----> \xi
           0         3         1
  @endverbatim
  *
  *
  * @f[
  * \begin{array}{ll}
  *   \xi_{0}  = 0   &  \eta_{0} = 0   \\
  *   \xi_{1}  = 1   &  \eta_{1} = 0   \\
  *   \xi_{2}  = 0   &  \eta_{2} = 1   \\
  *   \xi_{3}  = 1/2 &  \eta_{3} = 0   \\
  *   \xi_{4}  = 1/2 &  \eta_{4} = 1/2 \\
  *   \xi_{5}  = 0   &  \eta_{5} = 1/2
  * \end{array}
  * @f]
  *
  * @f[
  * \begin{array}{lll}
  * N1 = -(1 - \xi - \eta) (1 - 2 (1 - \xi - \eta))
  *       & \frac{\partial N1}{\partial \xi}  = 1 - 4(1 - \xi - \eta)
  *       & \frac{\partial N1}{\partial \eta} = 1 - 4(1 - \xi - \eta) \\
  * N2 = - \xi (1 - 2 \xi)
  *       & \frac{\partial N2}{\partial \xi}  = - 1 + 4 \xi
  *       & \frac{\partial N2}{\partial \eta} = 0 \\
  * N3 = - \eta (1 - 2 \eta)
  *       & \frac{\partial N3}{\partial \xi}  = 0
  *       & \frac{\partial N3}{\partial \eta} = - 1 + 4 \eta \\
  * N4 = 4 \xi (1 - \xi - \eta)
  *       & \frac{\partial N4}{\partial \xi}  = 4 (1 - 2 \xi - \eta)
  *       & \frac{\partial N4}{\partial \eta} = - 4 \xi \\
  * N5 = 4 \xi \eta
  *       & \frac{\partial N5}{\partial \xi}  = 4 \eta
  *       & \frac{\partial N5}{\partial \eta} = 4 \xi \\
  * N6 = 4 \eta (1 - \xi - \eta)
  *       & \frac{\partial N6}{\partial \xi}  = - 4 \eta
  *       & \frac{\partial N6}{\partial \eta} = 4 (1 - \xi - 2 \eta)
  * \end{array}
  * @f]
  *
  * @f{eqnarray*}{
  * \xi_{q0}  &=& 1/6 \qquad  \eta_{q0} = 1/6 \\
  * \xi_{q1}  &=& 2/3 \qquad  \eta_{q1} = 1/6 \\
  * \xi_{q2}  &=& 1/6 \qquad  \eta_{q2} = 2/3
  * @f}
  */
 
 /* -------------------------------------------------------------------------- */
 #include "element_class.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_triangle_6, _gt_triangle_6,
                                      _itp_lagrange_triangle_6, _ek_regular, 2,
                                      _git_triangle, 2);
 
 /* -------------------------------------------------------------------------- */
 
 template <>
 template <class D1, class D2,
           aka::enable_if_t<aka::are_vectors<D1, D2>::value> *>
 inline void InterpolationElement<_itp_lagrange_triangle_6>::computeShapes(
     const Eigen::MatrixBase<D1> & natural_coords, Eigen::MatrixBase<D2> & N) {
   /// Natural coordinates
   Real c0 =
       1 - natural_coords(0) - natural_coords(1); /// @f$ c0 = 1 - \xi - \eta @f$
   Real c1 = natural_coords(0);                   /// @f$ c1 = \xi @f$
   Real c2 = natural_coords(1);                   /// @f$ c2 = \eta @f$
 
   N(0) = c0 * (2 * c0 - 1.);
   N(1) = c1 * (2 * c1 - 1.);
   N(2) = c2 * (2 * c2 - 1.);
   N(3) = 4 * c0 * c1;
   N(4) = 4 * c1 * c2;
   N(5) = 4 * c2 * c0;
 }
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2>
 inline void InterpolationElement<_itp_lagrange_triangle_6>::computeDNDS(
     const Eigen::MatrixBase<D1> & natural_coords,
     Eigen::MatrixBase<D2> & dnds) {
 
   /**
    * @f[
    * dnds =  \left(
    *   \begin{array}{cccccc}
    *       \frac{\partial N1}{\partial \xi}
    *     & \frac{\partial N2}{\partial \xi}
    *     & \frac{\partial N3}{\partial \xi}
    *     & \frac{\partial N4}{\partial \xi}
    *     & \frac{\partial N5}{\partial \xi}
    *     & \frac{\partial N6}{\partial \xi} \\
    *
    *       \frac{\partial N1}{\partial \eta}
    *     & \frac{\partial N2}{\partial \eta}
    *     & \frac{\partial N3}{\partial \eta}
    *     & \frac{\partial N4}{\partial \eta}
    *     & \frac{\partial N5}{\partial \eta}
    *     & \frac{\partial N6}{\partial \eta}
    *   \end{array}
    * \right)
    * @f]
    */
 
   /// Natural coordinates
   Real c0 =
       1 - natural_coords(0) - natural_coords(1); /// @f$ c0 = 1 - \xi - \eta @f$
   Real c1 = natural_coords(0);                   /// @f$ c1 = \xi @f$
   Real c2 = natural_coords(1);                   /// @f$ c2 = \eta @f$
 
   dnds(0, 0) = 1 - 4 * c0;
   dnds(0, 1) = 4 * c1 - 1.;
   dnds(0, 2) = 0.;
   dnds(0, 3) = 4 * (c0 - c1);
   dnds(0, 4) = 4 * c2;
   dnds(0, 5) = -4 * c2;
 
   dnds(1, 0) = 1 - 4 * c0;
   dnds(1, 1) = 0.;
   dnds(1, 2) = 4 * c2 - 1.;
   dnds(1, 3) = -4 * c1;
   dnds(1, 4) = 4 * c1;
   dnds(1, 5) = 4 * (c0 - c2);
 }
 
-/* -------------------------------------------------------------------------- */
-template <>
-template <class D>
-inline Real
-InterpolationElement<_itp_lagrange_triangle_6>::computeSpecialJacobian(
-    const Eigen::MatrixBase<D> & J) {
-  Eigen::Map<const Eigen::Matrix<Real, 2, 3>> Jstatic(J.data());
-  return Jstatic.row(0).cross(Jstatic.row(1)).norm();
-}
-
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D>
 inline Real GeometricalElement<_gt_triangle_6>::getInradius(
     const Eigen::MatrixBase<D> & coord) {
   UInt triangles[4][3] = {{0, 3, 5}, {3, 1, 4}, {3, 4, 5}, {5, 4, 2}};
 
   Real inradius = std::numeric_limits<Real>::max();
   for (UInt t = 0; t < 4; t++) {
     auto ir = Math::triangle_inradius(coord(triangles[t][0]),
 					  coord(triangles[t][1]),
 					  coord(triangles[t][2]));
     inradius = std::min(ir, inradius);
   }
 
   return 2. * inradius;
 }
 
 } // namespace akantu
diff --git a/src/fe_engine/fe_engine.cc b/src/fe_engine/fe_engine.cc
index cb8ed6117..9ed9b5708 100644
--- a/src/fe_engine/fe_engine.cc
+++ b/src/fe_engine/fe_engine.cc
@@ -1,91 +1,92 @@
 /**
  * @file   fe_engine.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Jul 20 2010
  * @date last modification: Fri Feb 28 2020
  *
  * @brief  Implementation of the FEEngine class
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "fe_engine.hh"
 #include "mesh.hh"
+#include "integrator.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
-FEEngine::FEEngine(Mesh & mesh, UInt element_dimension, const ID & id)
+FEEngine::FEEngine(Mesh & mesh, Int element_dimension, const ID & id)
     : mesh(mesh),
       normals_on_integration_points("normals_on_quad_points", id) {
   AKANTU_DEBUG_IN();
   this->element_dimension = (element_dimension != _all_dimensions)
                                 ? element_dimension
                                 : mesh.getSpatialDimension();
 
   this->mesh.registerEventHandler(*this, _ehp_fe_engine);
 
   init();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void FEEngine::init() {}
 
 /* -------------------------------------------------------------------------- */
 FEEngine::~FEEngine() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 typename FEEngine::ElementTypesIteratorHelper
-FEEngine::elementTypes(UInt dim, GhostType ghost_type, ElementKind kind) const {
+FEEngine::elementTypes(Int dim, GhostType ghost_type, ElementKind kind) const {
   return this->getIntegratorInterface().getJacobians().elementTypes(
       dim, ghost_type, kind);
 }
 
 /* -------------------------------------------------------------------------- */
 void FEEngine::printself(std::ostream & stream, int indent) const {
   std::string space(indent, AKANTU_INDENT);
 
   stream << space << "FEEngine [" << std::endl;
   stream << space << " + id                : " << id << std::endl;
   stream << space << " + element dimension : " << element_dimension
          << std::endl;
 
   stream << space << " + mesh [" << std::endl;
   mesh.printself(stream, indent + 2);
   stream << space << AKANTU_INDENT << "]" << std::endl;
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/fe_engine/fe_engine.hh b/src/fe_engine/fe_engine.hh
index 9ac013c37..16358471d 100644
--- a/src/fe_engine/fe_engine.hh
+++ b/src/fe_engine/fe_engine.hh
@@ -1,391 +1,390 @@
 /**
  * @file   fe_engine.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Emil Gallyamov <emil.gallyamov@epfl.ch>
  * @author Sébastien Hartmann <sebastien.hartmann@epfl.ch>
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri May 14 2021
  *
  * @brief  FEM class
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "element_type_map.hh"
 #include "mesh_events.hh"
 /* -------------------------------------------------------------------------- */
 #include <functional>
 /* -------------------------------------------------------------------------- */
 
 #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 : public MeshEventHandler {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-  FEEngine(Mesh & mesh, UInt element_dimension = _all_dimensions,
+  FEEngine(Mesh & mesh, Int element_dimension = _all_dimensions,
            const ID & id = "fem");
 
   ~FEEngine() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// pre-compute all the shape functions, their derivatives and the jacobians
   virtual void
   initShapeFunctions(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,
-      ElementType type, GhostType ghost_type = _not_ghost,
-      const Array<Int> & filter_elements = empty_filter);
+  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<Int> & 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, ElementType type,
                       GhostType ghost_type = _not_ghost,
                       const Array<Int> & 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, ElementType type,
-            GhostType ghost_type = _not_ghost,
+  integrate(const Array<Real> & f, Array<Real> & intf, Int nb_degree_of_freedom,
+            const ElementType & type, const GhostType & ghost_type = _not_ghost,
             const Array<Int> & filter_elements = empty_filter) const = 0;
 
   /// integrate a scalar value f on all elements of type "type"
   virtual Real
   integrate(const Array<Real> & f, ElementType type,
             GhostType ghost_type = _not_ghost,
             const Array<Int> & 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,
-      ElementType type, GhostType ghost_type = _not_ghost,
+      const Array<Real> & f, Array<Real> & intf, Int nb_degree_of_freedom,
+      const ElementType & type, const GhostType & ghost_type = _not_ghost,
       const Array<Int> & filter_elements = empty_filter) const = 0;
 
   /// integrate one element scalar value on all elements of type "type"
   Real integrate(const Ref<const VectorXr> & f, const Element & element) const {
     return integrate(f, element.type, element.element, element.ghost_type);
   }
 
 private:
-  virtual Real integrate(const Ref<const VectorXr> & f, ElementType type,
-                         UInt index,
-                         GhostType ghost_type = _not_ghost) const = 0;
+  virtual Real integrate(const Ref<const VectorXr> & f,
+                         const ElementType & type, Idx index,
+                         const GhostType & ghost_type = _not_ghost) const = 0;
 
   /* ------------------------------------------------------------------------ */
   /* compatibility with old FEEngine fashion */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the number of integration points
   virtual Int
   getNbIntegrationPoints(ElementType type,
                          GhostType ghost_type = _not_ghost) const = 0;
 
   /// get the precomputed shapes
   const virtual Array<Real> &
-  getShapes(ElementType type, GhostType ghost_type = _not_ghost,
-            UInt id = 0) const = 0;
+  getShapes(const ElementType & type, const GhostType & ghost_type = _not_ghost,
+            Idx id = 0) const = 0;
 
   /// get the derivatives of shapes
-  const virtual Array<Real> &
-  getShapesDerivatives(ElementType type,
-                       GhostType ghost_type = _not_ghost,
-                       UInt id = 0) const = 0;
+  virtual const Array<Real> &
+  getShapesDerivatives(const ElementType & type,
+                       const GhostType & ghost_type = _not_ghost,
+                       Idx id = 0) const = 0;
 
   /// get integration points
   const virtual MatrixXr &
   getIntegrationPoints(ElementType type,
                        GhostType ghost_type = _not_ghost) const = 0;
 
   /* ------------------------------------------------------------------------ */
   /* 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, ElementType type,
-      GhostType ghost_type = _not_ghost,
-      const Array<Int> & filter_elements = empty_filter) const = 0;
+      const Array<Real> & u, Array<Real> & nablauq, Int nb_degree_of_freedom,
+      const ElementType & type, const GhostType & ghost_type = _not_ghost,
+      const Array<Idx> & 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,
-      ElementType type, GhostType ghost_type = _not_ghost,
-      const Array<Int> & filter_elements = empty_filter) const = 0;
+      const Array<Real> & u, Array<Real> & uq, Int nb_degree_of_freedom,
+      const ElementType & type, const GhostType & ghost_type = _not_ghost,
+      const Array<Idx> & 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;
+      const ElementTypeMapArray<Idx> * filter_elements = nullptr) const = 0;
 
   /// pre multiplies a tensor by the shapes derivaties
   virtual void
   computeBtD(const Array<Real> & Ds, Array<Real> & BtDs,
-             ElementType type,
-             GhostType ghost_type = _not_ghost,
-             const Array<Int> & filter_elements = empty_filter) const = 0;
+             const ElementType & type,
+             const GhostType & ghost_type = _not_ghost,
+             const Array<Idx> & 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,
-              ElementType type,
-              GhostType ghost_type = _not_ghost,
-              const Array<Int> & filter_elements = empty_filter) const = 0;
+  computeBtDB(const Array<Real> & Ds, Array<Real> & BtDBs, Int order_d,
+              const ElementType & type,
+              const GhostType & ghost_type = _not_ghost,
+              const Array<Idx> & filter_elements = empty_filter) const = 0;
 
   /// left multiples a vector by the shape functions
   virtual void
   computeNtb(const Array<Real> & bs, Array<Real> & Ntbs,
-             ElementType type,
-             GhostType ghost_type = _not_ghost,
-             const Array<Int> & filter_elements = empty_filter) const = 0;
+             const ElementType & type,
+             const GhostType & ghost_type = _not_ghost,
+             const Array<Idx> & filter_elements = empty_filter) const = 0;
 
   /// left and right  multiplies a tensor by the shapes
   virtual void
   computeNtbN(const Array<Real> & bs, Array<Real> & NtbNs,
               ElementType type, GhostType ghost_type = _not_ghost,
               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;
+      const ElementTypeMapArray<Idx> * 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, ElementType type,
-      GhostType ghost_type = _not_ghost,
-      const Array<Int> & filter_elements = empty_filter) const = 0;
+      Array<Real> & integration_points_coordinates, const ElementType & type,
+      const GhostType & ghost_type = _not_ghost,
+      const Array<Idx> & 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;
+      const ElementTypeMapArray<Idx> * 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, GhostType ghost_type,
-      const ElementTypeMapArray<UInt> * element_filter) const = 0;
+      ElementTypeMapArray<Real> & result, const GhostType ghost_type,
+      const ElementTypeMapArray<Idx> * 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, GhostType ghost_type,
-      const ElementTypeMapArray<UInt> * element_filter) const = 0;
+      ElementTypeMapArray<Real> & result, const GhostType ghost_type,
+      const ElementTypeMapArray<Idx> * element_filter) const = 0;
 
   /// interpolate on a phyiscal point inside an element
   virtual void interpolate(const Ref<const VectorXr> & real_coords,
                            const Ref<const MatrixXr> & nodal_values,
                            Ref<VectorXr> interpolated,
                            const Element & element) const = 0;
 
   /// compute the shape on a provided point
   virtual void
-  computeShapes(const Ref<const VectorXr> & real_coords, UInt elem,
-                ElementType type,  Ref<VectorXr> shapes,
-                GhostType ghost_type = _not_ghost) const = 0;
+  computeShapes(const Ref<const VectorXr> & real_coords, Int elem,
+                const ElementType & type, Ref<VectorXr> shapes,
+                const GhostType & ghost_type = _not_ghost) const = 0;
 
   /// compute the shape derivatives on a provided point
   virtual void
-  computeShapeDerivatives(const Ref<const VectorXr> & real_coords, UInt element,
-                          ElementType type,
-                          Ref<MatrixXr> & shape_derivatives,
-                          GhostType ghost_type = _not_ghost) const = 0;
+  computeShapeDerivatives(const Ref<const VectorXr> & real_coords, Int element,
+                          const ElementType & type,
+                          Ref<MatrixXr> shape_derivatives,
+                          const GhostType & ghost_type = _not_ghost) const = 0;
 
   /// assembles the lumped version of @f[ \int N^t rho N @f]
   virtual void assembleFieldLumped(
       const std::function<void(Matrix<Real> &, const Element &)> & field_funct,
       const ID & matrix_id, const ID & dof_id, DOFManager & dof_manager,
       ElementType type, GhostType ghost_type = _not_ghost) const = 0;
 
   /// assembles the matrix @f[ \int N^t rho N @f]
   virtual void assembleFieldMatrix(
       const std::function<void(Matrix<Real> &, const Element &)> & field_funct,
       const ID & matrix_id, const ID & dof_id, DOFManager & dof_manager,
       ElementType type, GhostType ghost_type = _not_ghost) const = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Other methods                                                            */
   /* ------------------------------------------------------------------------ */
 
   /// pre-compute normals on integration points
   virtual void computeNormalsOnIntegrationPoints(
       GhostType ghost_type = _not_ghost) = 0;
 
   /// pre-compute normals on integration points
   virtual void computeNormalsOnIntegrationPoints(
       const Array<Real> & /*field*/,
       GhostType /*ghost_type*/ = _not_ghost) {
     AKANTU_TO_IMPLEMENT();
   }
 
   /// pre-compute normals on integration points
   virtual void computeNormalsOnIntegrationPoints(
       const Array<Real> & /*field*/, Array<Real> & /*normal*/,
       ElementType /*type*/,
       GhostType /*ghost_type*/ = _not_ghost) const {
     AKANTU_TO_IMPLEMENT();
   }
 
   /// function to print the containt of the class
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
 private:
   /// initialise the class
   void init();
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   using ElementTypesIteratorHelper =
       ElementTypeMapArray<Real, ElementType>::ElementTypesIteratorHelper;
 
-  ElementTypesIteratorHelper elementTypes(UInt dim = _all_dimensions,
+  ElementTypesIteratorHelper elementTypes(Int 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);
+  AKANTU_GET_MACRO_AUTO(ElementDimension, element_dimension);
 
   /// get the mesh contained in the fem object
-  AKANTU_GET_MACRO(Mesh, mesh, const Mesh &);
+  AKANTU_GET_MACRO_AUTO(Mesh, 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 Ref<const MatrixXr> & coord,
                                         ElementType type);
 
   inline Real getElementInradius(const Element & element) const;
 
   /// 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(ElementType type_facet);
 
   /// get igfem element type for a given regular type
   static inline Vector<ElementType>
   getIGFEMElementTypes(ElementType type);
 
   /// get the interpolation element associated to an element type
   static inline InterpolationType
   getInterpolationType(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;
 
   AKANTU_GET_MACRO(ID, id, ID);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   ID id;
 
   /// spatial dimension of the problem
-  UInt element_dimension;
+  Int 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.hh"
 #include "fe_engine_template.hh"
 
 #endif /* AKANTU_FE_ENGINE_HH_ */
diff --git a/src/fe_engine/fe_engine_template.hh b/src/fe_engine/fe_engine_template.hh
index e24410a47..7eaa35dba 100644
--- a/src/fe_engine/fe_engine_template.hh
+++ b/src/fe_engine/fe_engine_template.hh
@@ -1,428 +1,432 @@
 /**
  * @file   fe_engine_template.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Sébastien Hartmann <sebastien.hartmann@epfl.ch>
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri May 14 2021
  *
  * @brief  templated class that calls integration and shape objects
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "fe_engine.hh"
-#include "integrator.hh"
-#include "shape_functions.hh"
+//#include "integrator.hh"
+//#include "shape_functions.hh"
 /* -------------------------------------------------------------------------- */
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #ifndef AKANTU_FE_ENGINE_TEMPLATE_HH_
 #define AKANTU_FE_ENGINE_TEMPLATE_HH_
 
+namespace akantu {
+class Integrator;
+class ShapeFunctions;
+} // namespace akantu
+
 namespace akantu {
 class DOFManager;
 namespace fe_engine {
   namespace details {
     template <ElementKind> struct AssembleLumpedTemplateHelper;
     template <ElementKind> struct AssembleFieldMatrixHelper;
   } // namespace details
 } // namespace fe_engine
 
 template <ElementKind, typename> struct AssembleFieldMatrixStructHelper;
 
 struct DefaultIntegrationOrderFunctor {
   template <ElementType type> static inline constexpr int getOrder() {
     return ElementClassProperty<type>::polynomial_degree;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind = _ek_regular,
           class IntegrationOrderFunctor = DefaultIntegrationOrderFunctor>
 class FEEngineTemplate : public FEEngine {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   using Integ = I<kind, IntegrationOrderFunctor>;
   using Shape = S<kind>;
 
-  FEEngineTemplate(Mesh & mesh, UInt spatial_dimension = _all_dimensions,
+  FEEngineTemplate(Mesh & mesh, Int spatial_dimension = _all_dimensions,
                    const ID & id = "fem");
 
   ~FEEngineTemplate() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// pre-compute all the shape functions, their derivatives and the jacobians
   void initShapeFunctions(GhostType ghost_type = _not_ghost) override;
   void initShapeFunctions(const Array<Real> & nodes,
                           GhostType ghost_type = _not_ghost);
 
   /* ------------------------------------------------------------------------ */
   /* Integration method bridges                                               */
   /* ------------------------------------------------------------------------ */
   /// integrate f for all elements of type "type"
   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<Int> & filter_elements = empty_filter) const override;
+  integrate(const Array<Real> & f, Array<Real> & intf, Int nb_degree_of_freedom,
+            const ElementType & type, const GhostType & ghost_type = _not_ghost,
+            const Array<Idx> & filter_elements = empty_filter) const override;
 
   /// integrate a scalar value on all elements of type "type"
   Real
   integrate(const Array<Real> & f, const ElementType & type,
             const GhostType & ghost_type = _not_ghost,
-            const Array<Int> & filter_elements = empty_filter) const override;
+            const Array<Idx> & filter_elements = empty_filter) const override;
 
   /// integrate one element scalar value on all elements of type "type"
   Real integrate(const Ref<const VectorXr> & f, const ElementType & type,
-                 UInt index,
+                 Int index,
                  const GhostType & ghost_type = _not_ghost) const override;
 
   /// integrate partially around an integration point (@f$ intf_q = f_q * J_q *
   /// w_q @f$)
   void integrateOnIntegrationPoints(
-      const Array<Real> & f, Array<Real> & intf, UInt nb_degree_of_freedom,
+      const Array<Real> & f, Array<Real> & intf, Int nb_degree_of_freedom,
       const ElementType & type, const GhostType & ghost_type = _not_ghost,
-      const Array<Int> & filter_elements = empty_filter) const override;
+      const Array<Idx> & filter_elements = empty_filter) const override;
 
   /// interpolate on a phyiscal point inside an element
   void interpolate(const Ref<const VectorXr> & real_coords,
                    const Ref<const MatrixXr> & nodal_values,
                    Ref<VectorXr> interpolated,
                    const Element & element) const override;
 
   /// get the number of integration points
   Int getNbIntegrationPoints(
       const ElementType & type,
       const GhostType & ghost_type = _not_ghost) const override;
 
   /// get shapes precomputed
-  const Array<Real> & getShapes(ElementType type,
-                                GhostType ghost_type = _not_ghost,
-                                UInt id = 0) const override;
+  const Array<Real> & getShapes(const ElementType & type,
+                                const GhostType & ghost_type = _not_ghost,
+                                Int id = 0) const override;
 
   /// get the derivatives of shapes
-  const Array<Real> & getShapesDerivatives(ElementType type,
-                                           GhostType ghost_type = _not_ghost,
-                                           UInt id = 0) const override;
+  const Array<Real> &
+  getShapesDerivatives(const ElementType & type,
+                       const GhostType & ghost_type = _not_ghost,
+                       Int id = 0) const override;
 
   /// get integration points
   const inline Matrix<Real> &
   getIntegrationPoints(ElementType type,
                        GhostType ghost_type = _not_ghost) const override;
 
   /* ------------------------------------------------------------------------ */
   /* Shape method bridges                                                     */
   /* ------------------------------------------------------------------------ */
 
   /// compute the gradient of a nodal field on the integration points
   void gradientOnIntegrationPoints(
       const Array<Real> & u, Array<Real> & nablauq,
-      const UInt nb_degree_of_freedom, const ElementType & type,
+      const Int nb_degree_of_freedom, const ElementType & type,
       const GhostType & ghost_type = _not_ghost,
-      const Array<Int> & filter_elements = empty_filter) const override;
+      const Array<Idx> & filter_elements = empty_filter) const override;
 
   /// interpolate a nodal field on the integration points
   void interpolateOnIntegrationPoints(
-      const Array<Real> & u, Array<Real> & uq, UInt nb_degree_of_freedom,
+      const Array<Real> & u, Array<Real> & uq, Int nb_degree_of_freedom,
       const ElementType & type, const GhostType & ghost_type = _not_ghost,
-      const Array<Int> & filter_elements = empty_filter) const override;
+      const Array<Idx> & filter_elements = empty_filter) const override;
 
   /// interpolate a nodal field on the integration points given a
   /// by_element_type
   void interpolateOnIntegrationPoints(
       const Array<Real> & u, ElementTypeMapArray<Real> & uq,
-      const ElementTypeMapArray<UInt> * filter_elements =
+      const ElementTypeMapArray<Idx> * filter_elements =
           nullptr) const override;
 
   /// pre multiplies a tensor by the shapes derivaties
   void
   computeBtD(const Array<Real> & Ds, Array<Real> & BtDs,
              const ElementType & type, const GhostType & ghost_type,
-             const Array<Int> & filter_elements = empty_filter) const override;
+             const Array<Idx> & filter_elements = empty_filter) const override;
 
   /// left and right  multiplies a tensor by the shapes derivaties
   void
-  computeBtDB(const Array<Real> & Ds, Array<Real> & BtDBs, UInt order_d,
+  computeBtDB(const Array<Real> & Ds, Array<Real> & BtDBs, Int order_d,
               const ElementType & type, const GhostType & ghost_type,
-              const Array<Int> & filter_elements = empty_filter) const override;
+              const Array<Idx> & filter_elements = empty_filter) const override;
 
   /// left multiples a vector by the shape functions
   void computeNtb(const Array<Real> & bs, Array<Real> & Ntbs,
                   const ElementType & type, const GhostType & ghost_type,
-                  const Array<Int> & filter_elements) const override;
+                  const Array<Idx> & filter_elements) const override;
 
   /// compute the position of integration points given by an element_type_map
   /// from nodes position
   inline void computeIntegrationPointsCoordinates(
       ElementTypeMapArray<Real> & quadrature_points_coordinates,
-      const ElementTypeMapArray<UInt> * filter_elements =
+      const ElementTypeMapArray<Idx> * filter_elements =
           nullptr) const override;
 
   /// compute the position of integration points from nodes position
   inline void computeIntegrationPointsCoordinates(
       Array<Real> & quadrature_points_coordinates, const ElementType & type,
       const GhostType & ghost_type = _not_ghost,
-      const Array<Int> & filter_elements = empty_filter) const override;
+      const Array<Idx> & filter_elements = empty_filter) const override;
 
   /// interpolate field at given position (interpolation_points) from given
   /// values of this field at integration points (field)
   inline void interpolateElementalFieldFromIntegrationPoints(
       const ElementTypeMapArray<Real> & field,
       const ElementTypeMapArray<Real> & interpolation_points_coordinates,
-      ElementTypeMapArray<Real> & result, GhostType ghost_type,
-      const ElementTypeMapArray<UInt> * element_filter) const override;
+      ElementTypeMapArray<Real> & result, const GhostType ghost_type,
+      const ElementTypeMapArray<Idx> * element_filter) const override;
 
   /// Interpolate field at given position from given values of this field at
   /// integration points (field)
   /// using matrices precomputed with
   /// initElementalFieldInterplationFromIntegrationPoints
   inline void interpolateElementalFieldFromIntegrationPoints(
       const ElementTypeMapArray<Real> & field,
       const ElementTypeMapArray<Real> &
           interpolation_points_coordinates_matrices,
       const ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
-      ElementTypeMapArray<Real> & result, GhostType ghost_type,
-      const ElementTypeMapArray<UInt> * element_filter) const override;
+      ElementTypeMapArray<Real> & result, const GhostType ghost_type,
+      const ElementTypeMapArray<Idx> * element_filter) const override;
 
   /// Build pre-computed matrices for interpolation of field form integration
   /// points at other given positions (interpolation_points)
   inline void 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 =
-          nullptr) const override;
+      const ElementTypeMapArray<Idx> * element_filter = nullptr) const override;
 
   /// find natural coords from real coords provided an element
-  void inverseMap(const Vector<Real> & real_coords, UInt element,
-                  ElementType type, Vector<Real> & natural_coords,
-                  GhostType ghost_type = _not_ghost) const;
+  void inverseMap(const Vector<Real> & real_coords, Int element,
+                  const ElementType & type, Vector<Real> & natural_coords,
+                  const GhostType & ghost_type = _not_ghost) const;
 
   /// return true if the coordinates provided are inside the element, false
   /// otherwise
-  inline bool contains(const Vector<Real> & real_coords, UInt element,
-                       ElementType type,
-                       GhostType ghost_type = _not_ghost) const;
+  inline bool contains(const Vector<Real> & real_coords, Int element,
+                       const ElementType & type,
+                       const GhostType & ghost_type = _not_ghost) const;
 
   /// compute the shape on a provided point
   inline void
-  computeShapes(const Ref<const VectorXr> & real_coords, UInt element,
-                ElementType type, Ref<VectorXr> shapes,
-                GhostType ghost_type = _not_ghost) const override;
+  computeShapes(const Ref<const VectorXr> & real_coords, Int element,
+                const ElementType & type, Ref<VectorXr> shapes,
+                const GhostType & ghost_type = _not_ghost) const override;
 
   /// compute the shape derivatives on a provided point
   inline void computeShapeDerivatives(
-      const Ref<const VectorXr> & real__coords, UInt element,
+      const Ref<const VectorXr> & real__coords, Int element,
       const ElementType & type, Ref<MatrixXr> shape_derivatives,
       const GhostType & ghost_type = _not_ghost) const override;
 
   /* ------------------------------------------------------------------------ */
   /* Other methods                                                            */
   /* ------------------------------------------------------------------------ */
   /// pre-compute normals on integration points
   void
   computeNormalsOnIntegrationPoints(GhostType ghost_type = _not_ghost) override;
   void
   computeNormalsOnIntegrationPoints(const Array<Real> & field,
                                     GhostType ghost_type = _not_ghost) override;
   void computeNormalsOnIntegrationPoints(
       const Array<Real> & field, Array<Real> & normal, ElementType type,
       GhostType ghost_type = _not_ghost) const override;
   template <ElementType type>
   void computeNormalsOnIntegrationPoints(const Array<Real> & field,
                                          Array<Real> & normal,
                                          GhostType ghost_type) const;
 
 private:
   // To avoid a weird full specialization of a method in a non specalized class
   void computeNormalsOnIntegrationPointsPoint1(const Array<Real> & /*unused*/,
                                                Array<Real> & normal,
                                                GhostType ghost_type) const;
 
 public:
   /// function to print the contain of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
   void assembleFieldLumped(
       const std::function<void(Matrix<Real> &, const Element &)> & field_funct,
       const ID & matrix_id, const ID & dof_id, DOFManager & dof_manager,
       ElementType type, GhostType ghost_type) const override;
 
   /// assemble a field as a matrix (ex. rho to mass matrix)
   void assembleFieldMatrix(
       const std::function<void(Matrix<Real> &, const Element &)> & field_funct,
       const ID & matrix_id, const ID & dof_id, DOFManager & dof_manager,
       ElementType type, GhostType ghost_type) const override;
 
   /// assemble a field as a lumped matrix (ex. rho in lumped mass)
   // template <class Functor>
   // void assembleFieldLumped(const Functor & field_funct, const ID & matrix_id,
   //                          const ID & dof_id, DOFManager & dof_manager,
   //                          ElementType type,
   //                          GhostType ghost_type) const;
 
   // /// assemble a field as a matrix (ex. rho to mass matrix)
   // template <class Functor>
   // void assembleFieldMatrix(const Functor & field_funct, const ID & matrix_id,
   //                          const ID & dof_id, DOFManager & dof_manager,
   //                          ElementType type,
   //                          GhostType ghost_type) const;
 
   // #ifdef AKANTU_STRUCTURAL_MECHANICS
   //   /// assemble a field as a matrix (ex. rho to mass matrix)
   //   void assembleFieldMatrix(const Array<Real> & field_1,
   //                            UInt nb_degree_of_freedom, SparseMatrix & M,
   //                            Array<Real> * n,
   //                            ElementTypeMapArray<Real> & rotation_mat,
   //                            ElementType type,
   //                            GhostType ghost_type = _not_ghost)
   //                            const;
 
   //   /// compute shapes function in a matrix for structural elements
   //   void
   //   computeShapesMatrix(ElementType type, UInt nb_degree_of_freedom,
   //                       UInt nb_nodes_per_element, Array<Real> * n, UInt id,
   //                       UInt degree_to_interpolate, UInt degree_interpolated,
   //                       const bool sign,
   //                       GhostType ghost_type = _not_ghost) const
   //                       override;
   // #endif
 
 private:
   friend struct fe_engine::details::AssembleLumpedTemplateHelper<kind>;
   friend struct fe_engine::details::AssembleFieldMatrixHelper<kind>;
   friend struct AssembleFieldMatrixStructHelper<kind, void>;
 
   /// templated function to compute the scaling to assemble a lumped matrix
   template <ElementType type>
   void assembleFieldLumped(
       const std::function<void(Matrix<Real> &, const Element &)> & field_funct,
       const ID & matrix_id, const ID & dof_id, DOFManager & dof_manager,
       GhostType ghost_type) const;
 
   /// @f$ \tilde{M}_{i} = \sum_j M_{ij} = \sum_j \int \rho \varphi_i \varphi_j
   /// dV = \int \rho \varphi_i dV @f$
   template <ElementType type>
   void assembleLumpedRowSum(const Array<Real> & field, const ID & matrix_id,
                             const ID & dof_id, DOFManager & dof_manager,
                             GhostType ghost_type) const;
 
   /// @f$ \tilde{M}_{i} = c * M_{ii} = \int_{V_e} \rho dV @f$
   template <ElementType type>
   void assembleLumpedDiagonalScaling(const Array<Real> & field,
                                      const ID & matrix_id, const ID & dof_id,
                                      DOFManager & dof_manager,
                                      GhostType ghost_type) const;
 
   /// assemble a field as a matrix (ex. rho to mass matrix)
   template <ElementType type>
   void assembleFieldMatrix(
       const std::function<void(Matrix<Real> &, const Element &)> & field_funct,
       const ID & matrix_id, const ID & dof_id, DOFManager & dof_manager,
       GhostType ghost_type) const;
 
 #ifdef AKANTU_STRUCTURAL_MECHANICS
 
   /// assemble a field as a matrix for structural elements (ex. rho to mass
   /// matrix)
   template <ElementType type>
   void assembleFieldMatrix(const Array<Real> & field_1,
-                           UInt nb_degree_of_freedom, SparseMatrix & M,
+                           Int nb_degree_of_freedom, SparseMatrix & M,
                            Array<Real> * n,
                            ElementTypeMapArray<Real> & rotation_mat,
                            __attribute__((unused)) GhostType ghost_type) const;
 
 #endif
 
   /* ------------------------------------------------------------------------ */
   /* Mesh Event Handler interface                                             */
   /* ------------------------------------------------------------------------ */
 public:
   void onElementsAdded(const Array<Element> & /*new_elements*/,
                        const NewElementsEvent & /*unused*/) override;
   void onElementsRemoved(const Array<Element> & /*unused*/,
                          const ElementTypeMapArray<UInt> & /*unused*/,
                          const RemovedElementsEvent & /*unused*/) override;
   void onElementsChanged(const Array<Element> & /*unused*/,
                          const Array<Element> & /*unused*/,
                          const ElementTypeMapArray<UInt> & /*unused*/,
                          const ChangedElementsEvent & /*unused*/) override;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the shape class (probably useless: see getShapeFunction)
   const ShapeFunctions & getShapeFunctionsInterface() const override {
     return shape_functions;
   };
   /// get the shape class
   const Shape & getShapeFunctions() const { return shape_functions; };
 
   /// get the integrator class (probably useless: see getIntegrator)
   const Integrator & getIntegratorInterface() const override {
     return integrator;
   };
   /// get the integrator class
   const Integ & getIntegrator() const { return integrator; };
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   Integ integrator;
   Shape shape_functions;
 };
 
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 #include "fe_engine_template_tmpl.hh"
 #include "fe_engine_template_tmpl_field.hh"
 /* -------------------------------------------------------------------------- */
 /* Shape Linked specialization                                                */
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
 #include "fe_engine_template_tmpl_struct.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 /* Shape IGFEM specialization                                                 */
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_IGFEM)
 #include "fe_engine_template_tmpl_igfem.hh"
 #endif
 
 #endif /* AKANTU_FE_ENGINE_TEMPLATE_HH_ */
diff --git a/src/fe_engine/fe_engine_template_cohesive.cc b/src/fe_engine/fe_engine_template_cohesive.cc
index 8f845a189..0facd6408 100644
--- a/src/fe_engine/fe_engine_template_cohesive.cc
+++ b/src/fe_engine/fe_engine_template_cohesive.cc
@@ -1,137 +1,135 @@
 /**
  * @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: Tue Sep 29 2020
  *
  * @brief  Specialization of the FEEngineTemplate for cohesive element
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "fe_engine_template.hh"
 #include "integrator_gauss.hh"
 #include "shape_cohesive.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<Int> & filter_elements) const {
+              const Array<Idx> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
 #ifndef AKANTU_NDEBUG
   auto nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
     nb_element = filter_elements.size();
   }
 
   auto nb_quadrature_points = getNbIntegrationPoints(type);
 
   AKANTU_DEBUG_ASSERT(f.size() == Int(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,
+              Int nb_degree_of_freedom, const ElementType & type,
               const GhostType & ghost_type,
-              const Array<Int> & filter_elements) const {
+              const Array<Idx> & filter_elements) const {
 
 #ifndef AKANTU_NDEBUG
   auto nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
     nb_element = filter_elements.size();
   }
 
   auto nb_quadrature_points = getNbIntegrationPoints(type);
 
   AKANTU_DEBUG_ASSERT(f.size() == Int(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() == Int(nb_degree_of_freedom),
                       "The vector f("
                           << f.getID()
                           << ") has not the good number of component.");
   AKANTU_DEBUG_ASSERT(intf.getNbComponent() == Int(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> & /* u */, Array<Real> & /*  nablauq */,
-        UInt /* nb_degree_of_freedom */, ElementType /* type  */,
-        GhostType /*  ghost_type */,
-        const Array<Int> & /*  filter_elements */) const {
+    gradientOnIntegrationPoints(const Array<Real> &, Array<Real> &, Int,
+                                const ElementType &, const GhostType &,
+                                const Array<Idx> &) const {
   AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/fe_engine/fe_engine_template_tmpl.hh b/src/fe_engine/fe_engine_template_tmpl.hh
index 0dc8c0355..fa2216887 100644
--- a/src/fe_engine/fe_engine_template_tmpl.hh
+++ b/src/fe_engine/fe_engine_template_tmpl.hh
@@ -1,1445 +1,1446 @@
 /**
  * @file   fe_engine_template_tmpl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Sébastien Hartmann <sebastien.hartmann@epfl.ch>
  * @author Mohit Pundir <mohit.pundir@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: Fri May 14 2021
  *
  * @brief  Template implementation of FEEngineTemplate
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "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, const ID & id)
+    Mesh & mesh, Int spatial_dimension, const ID & id)
     : FEEngine(mesh, spatial_dimension, id),
       integrator(mesh, spatial_dimension, id),
       shape_functions(mesh, spatial_dimension, 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 & /*unused*/, Mesh & /*unused*/,
-                       const Array<Real> & /*unused*/, Array<Real> & /*unused*/,
-                       const UInt /*unused*/, ElementType /*unused*/,
-                       GhostType /*unused*/, const Array<UInt> & /*unused*/) {
+      static void call(const S &, Mesh &, const Array<Real> &, Array<Real> &,
+                       Int, const ElementType &, const GhostType &,
+                       const Array<Idx> &) {
         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<Int> & filter_elements) {                     \
-      UInt element_dimension = mesh.getSpatialDimension(type);                 \
+                     Int nb_degree_of_freedom, const ElementType & type,       \
+                     const GhostType & ghost_type,                             \
+                     const Array<Idx> & filter_elements) {                     \
+      auto 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,
+                                Int nb_degree_of_freedom,
                                 const ElementType & type,
                                 const GhostType & ghost_type,
                                 const Array<Int> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
-  UInt nb_element = mesh.getNbElement(type, ghost_type);
+  auto nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter) {
     nb_element = filter_elements.size();
   }
-  UInt nb_points =
+  auto nb_points =
       shape_functions.getIntegrationPoints(type, ghost_type).cols();
 
 #ifndef AKANTU_NDEBUG
 
-  UInt element_dimension = mesh.getSpatialDimension(type);
+  auto 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(
     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, 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,            \
+                     Array<Real> & intf, Int nb_degree_of_freedom,             \
                      const ElementType & type, const GhostType & ghost_type,   \
-                     const Array<Int> & filter_elements) {                     \
+                     const Array<Idx> & 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 Array<Real> & f, Array<Real> & intf, Int nb_degree_of_freedom,
     const ElementType & type, const GhostType & ghost_type,
-    const Array<Int> & filter_elements) const {
+    const Array<Idx> & filter_elements) const {
 
-  UInt nb_element = mesh.getNbElement(type, ghost_type);
+  auto 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);
+  auto 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<Int> & 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<Int> & 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);
+  auto 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);
+  auto 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 Ref<const VectorXr> & f,      \
-                     ElementType type, UInt index, GhostType ghost_type) {     \
+                     const ElementType & type, Int 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 Ref<const VectorXr> & f, ElementType type, UInt index,
-    GhostType ghost_type) const {
+    const Ref<const VectorXr> & f, const ElementType & type, Int 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,            \
+                     Array<Real> & intf, Int nb_degree_of_freedom,             \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<Int> & 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,
+                                 Int nb_degree_of_freedom,
                                  const ElementType & type,
                                  const GhostType & ghost_type,
                                  const Array<Int> & filter_elements) const {
 
-  UInt nb_element = mesh.getNbElement(type, ghost_type);
+  auto nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
     nb_element = filter_elements.size();
-  UInt nb_quadrature_points = getNbIntegrationPoints(type);
+  auto 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 & /*unused*/, const Array<Real> & /*unused*/,
-                       Array<Real> & /*unused*/, const UInt /*unused*/,
-                       ElementType /*unused*/, GhostType /*unused*/,
-                       const Array<UInt> & /*unused*/) {
+      static void call(const S &, const Array<Real> &, Array<Real> &, Int,
+                       const ElementType &, const GhostType &,
+                       const Array<Idx> &) {
         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,        \
+                     Array<Real> & uq, Int nb_degree_of_freedom,               \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<Int> & 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,
+                                   Int nb_degree_of_freedom,
                                    const ElementType & type,
                                    const GhostType & ghost_type,
                                    const Array<Int> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
-  UInt nb_points =
+  auto nb_points =
       shape_functions.getIntegrationPoints(type, ghost_type).cols();
-  UInt nb_element = mesh.getNbElement(type, ghost_type);
+  auto 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 {
+        const ElementTypeMapArray<Idx> * filter_elements) const {
   AKANTU_DEBUG_IN();
 
-  const Array<UInt> * filter = nullptr;
+  const Array<Idx> * 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);
+    for (auto & type : uq.elementTypes(_all_dimensions, ghost_type, kind)) {
+      auto nb_quad_per_element = getNbIntegrationPoints(type, ghost_type);
 
-      UInt nb_element = 0;
+      Int nb_element = 0;
 
       if (filter_elements != nullptr) {
         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;
+      auto 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<Int> & filter_elements) {                     \
+                     const Array<Idx> & 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<Int> & filter_elements) const {
+    const GhostType & ghost_type, const Array<Idx> & 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,                        \
+                     Array<Real> & BtDBs, Int order_d,                         \
                      const ElementType & type, const GhostType & ghost_type,   \
-                     const Array<Int> & filter_elements) {                     \
+                     const Array<Idx> & 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, ElementType type,
-    GhostType ghost_type, const Array<Int> & filter_elements) const {
+    const Array<Real> & Ds, Array<Real> & BtDBs, Int order_d,
+    const ElementType & type, const GhostType & ghost_type,
+    const Array<Idx> & filter_elements) const {
   fe_engine::details::ComputeBtDBHelper<kind>::call(
       shape_functions, Ds, BtDBs, order_d, type, ghost_type, filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ComputeNtbNHelper {};
 
 #define COMPUTE_NtbN(type)                                                     \
   shape_functions.template computeNtbN<type>(bs, NtbNs, ghost_type,            \
                                              filter_elements);
 
 #define AKANTU_SPECIALIZE_COMPUTE_NtbN_HELPER(kind)                            \
   template <> struct ComputeNtbNHelper<kind> {                                 \
     template <class S>                                                         \
     static void call(const S & shape_functions, const Array<Real> & bs,        \
                      Array<Real> & NtbNs, ElementType type,                    \
                      GhostType ghost_type,                                     \
                      const Array<UInt> & filter_elements) {                    \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(COMPUTE_NtbN, kind);                    \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_COMPUTE_NtbN_HELPER)
 
 #undef AKANTU_SPECIALIZE_COMPUTE_NtbN_HELPER
 #undef COMPUTE_NtbN
   } // 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>::computeNtbN(
     const Array<Real> & bs, Array<Real> & NtbNs, ElementType type,
     GhostType ghost_type, const Array<UInt> & filter_elements) const {
   fe_engine::details::ComputeNtbNHelper<kind>::call(
       shape_functions, bs, NtbNs, type, ghost_type, filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ComputeNtbHelper {};
 
 #define COMPUTE_Ntb(type)                                                      \
   shape_functions.template computeNtb<type>(bs, Ntbs, ghost_type,              \
                                             filter_elements);
 
 #define AKANTU_SPECIALIZE_COMPUTE_Ntb_HELPER(kind)                             \
   template <> struct ComputeNtbHelper<kind> {                                  \
     template <class S>                                                         \
     static void call(const S & shape_functions, const Array<Real> & bs,        \
                      Array<Real> & Ntbs, const ElementType & type,             \
                      const GhostType & ghost_type,                             \
-                     const Array<Int> & filter_elements) {                     \
+                     const Array<Idx> & filter_elements) {                     \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(COMPUTE_Ntb, kind);                     \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_COMPUTE_Ntb_HELPER)
 
 #undef AKANTU_SPECIALIZE_COMPUTE_Ntb_HELPER
 #undef COMPUTE_Ntb
   } // 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>::computeNtb(
-    const Array<Real> & bs, Array<Real> & Ntbs, ElementType type,
-    GhostType ghost_type, const Array<UInt> & filter_elements) const {
+    const Array<Real> & bs, Array<Real> & Ntbs, const ElementType & type,
+    const GhostType & ghost_type, const Array<Idx> & filter_elements) const {
   fe_engine::details::ComputeNtbHelper<kind>::call(
       shape_functions, bs, Ntbs, 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 ElementTypeMapArray<Idx> * 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, ElementType type,
-        GhostType ghost_type, const Array<UInt> & filter_elements) const {
+        Array<Real> & quadrature_points_coordinates, const ElementType & type,
+        const GhostType & ghost_type,
+        const Array<Idx> & filter_elements) const {
 
   const Array<Real> & nodes_coordinates = mesh.getNodes();
 
-  UInt spatial_dimension = mesh.getSpatialDimension();
+  auto 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 {
+        const ElementTypeMapArray<Idx> * element_filter) const {
 
   AKANTU_DEBUG_IN();
 
-  UInt spatial_dimension = this->mesh.getSpatialDimension();
+  auto spatial_dimension = this->mesh.getSpatialDimension();
 
   ElementTypeMapArray<Real> quadrature_points_coordinates(
       "quadrature_points_coordinates_for_interpolation", getID());
 
   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, GhostType ghost_type,
-        const ElementTypeMapArray<UInt> * element_filter) const {
+        ElementTypeMapArray<Real> & result, const GhostType ghost_type,
+        const ElementTypeMapArray<Idx> * element_filter) const {
 
   ElementTypeMapArray<Real> interpolation_points_coordinates_matrices(
       "interpolation_points_coordinates_matrices", id);
   ElementTypeMapArray<Real> quad_points_coordinates_inv_matrices(
       "quad_points_coordinates_inv_matrices", 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, GhostType ghost_type,
-        const ElementTypeMapArray<UInt> * element_filter) const {
+        ElementTypeMapArray<Real> & result, const GhostType ghost_type,
+        const ElementTypeMapArray<Idx> * 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 & /*unused*/, const Vector<Real> & /*unused*/,
-                       UInt /*unused*/, const Matrix<Real> & /*unused*/,
-                       Vector<Real> & /*unused*/, ElementType /*unused*/,
-                       GhostType /*unused*/) {
+      static void call(const S &, const Ref<const VectorXr> &, Int,
+                       const Ref<const MatrixXr> &, Ref<VectorXr>,
+                       const ElementType &, const GhostType &) {
         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 Ref<const VectorXr> & real_coords, UInt element,    \
+                     const Ref<const VectorXr> & real_coords, Int element,     \
                      const Ref<const MatrixXr> & nodal_values,                 \
-                     Ref<VectorXr> & interpolated, const ElementType & type,   \
+                     Ref<VectorXr> 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 Ref<const VectorXr> & real_coords,
     const Ref<const MatrixXr> & nodal_values, Ref<VectorXr> 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(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,
                                       GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   //  Real * coord = mesh.getNodes().data();
-  UInt spatial_dimension = mesh.getSpatialDimension();
+  auto spatial_dimension = mesh.getSpatialDimension();
 
   // allocate the normal arrays
   normals_on_integration_points.initialize(
       *this, _nb_component = spatial_dimension,
       _spatial_dimension = element_dimension, _ghost_type = ghost_type,
       _element_kind = kind);
 
   // loop over the type to build the normals
   for (auto & type : mesh.elementTypes(element_dimension, ghost_type, kind)) {
     auto & 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> & /*unused*/,
                        const Array<Real> & /*unused*/, Array<Real> & /*unused*/,
                        ElementType /*unused*/, GhostType /*unused*/) {
         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,          \
                      ElementType type, 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, ElementType type,
                                       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,
                                       GhostType ghost_type) const {
   AKANTU_DEBUG_IN();
 
-  if (type == _point_1) {
-    computeNormalsOnIntegrationPointsPoint1(field, normal, ghost_type);
-    return;
-  }
-
-  auto spatial_dimension = mesh.getSpatialDimension();
-  auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
-  auto nb_points = getNbIntegrationPoints(type, ghost_type);
-
-  auto nb_element = mesh.getConnectivity(type, ghost_type).size();
-  normal.resize(nb_element * nb_points);
-
-  Array<Real> f_el(0, spatial_dimension * nb_nodes_per_element);
-  FEEngine::extractNodalToElementField(mesh, field, f_el, type, ghost_type);
-
-  const auto & quads =
-      integrator.template getIntegrationPoints<type>(ghost_type);
-
-  for (auto && data :
-       zip(make_view(normal, spatial_dimension, nb_points),
-           make_view(f_el, spatial_dimension, nb_nodes_per_element))) {
-    ElementClass<type>::computeNormalsOnNaturalCoordinates(
-        quads, std::get<1>(data), std::get<0>(data));
-  }
+  static_if(aka::bool_constant<type == _point_1>{})
+      .then([&](auto && field) {
+        computeNormalsOnIntegrationPointsPoint1(field, normal, ghost_type);
+      })
+      .else_([&](auto && field) {
+        auto spatial_dimension = mesh.getSpatialDimension();
+        auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
+        auto nb_points = getNbIntegrationPoints(type, ghost_type);
+
+        auto nb_element = mesh.getConnectivity(type, ghost_type).size();
+        normal.resize(nb_element * nb_points);
+
+        Array<Real> f_el(0, spatial_dimension * nb_nodes_per_element);
+        FEEngine::extractNodalToElementField(mesh, field, f_el, type,
+                                             ghost_type);
+
+        const auto & quads =
+            integrator.template getIntegrationPoints<type>(ghost_type);
+
+        for (auto && data :
+             zip(make_view(normal, spatial_dimension, nb_points),
+                 make_view(f_el, spatial_dimension, nb_nodes_per_element))) {
+          ElementClass<type>::computeNormalsOnNaturalCoordinates(
+              quads, std::get<1>(data), std::get<0>(data));
+        }
+      })(field);
 
   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*/,
-                   ElementType /*type*/, Vector<Real> & /*natural_coords*/,
-                   GhostType /*ghost_type*/) {
+  static void
+  call(const S & /*shape_functions*/, const Vector<Real> & /*real_coords*/,
+       Int /*element*/, const ElementType & /*type*/,
+       Vector<Real> & /*natural_coords*/, const GhostType & /*ghost_type*/) {
     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,           \
-                     ElementType type, Vector<Real> & natural_coords,          \
-                     GhostType ghost_type) {                                   \
+                     const Vector<Real> & real_coords, Int 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, ElementType type,
-    Vector<Real> & natural_coords, GhostType ghost_type) const {
+    const Vector<Real> & real_coords, Int 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 & /*unused*/, const Vector<Real> & /*unused*/,
-                       UInt /*unused*/, ElementType /*unused*/,
-                       GhostType /*unused*/) {
+      static void call(const S &, const Vector<Real> &, Int,
+                       const ElementType &, const GhostType &) {
         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,           \
-                     ElementType type, GhostType ghost_type) {                 \
+                     const Vector<Real> & real_coords, Int 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, ElementType type,
-    GhostType ghost_type) const {
+    const Vector<Real> & real_coords, Int 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 & /*unused*/, const Vector<Real> & /*unused*/,
-                       UInt /*unused*/, const ElementType /*unused*/,
-                       Vector<Real> & /*unused*/, GhostType /*unused*/) {
+      static void call(const S &, const Ref<const VectorXr> &, Int,
+                       const ElementType, Ref<VectorXr>, const GhostType &) {
         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 Ref<const VectorXr> & real_coords, UInt element,    \
+                     const Ref<const VectorXr> & real_coords, Int element,     \
                      const ElementType type, Ref<VectorXr> & 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 Ref<const VectorXr> & real_coords, UInt element, ElementType type,
-    Ref<VectorXr> shapes, GhostType ghost_type) const {
+    const Ref<const VectorXr> & real_coords, Int element,
+    const ElementType & type, Ref<VectorXr> 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(const S & /*shape_functions*/,
-                       const Ref<const VectorXr> & /*real_coords*/,
-                       UInt /*element*/, ElementType /*type*/,
-                       Ref<MatrixXr> /*shape_derivatives*/,
-                       GhostType /*ghost_type*/) {
+      static void call(const S &, const Ref<const VectorXr> &, Int,
+                       const ElementType, Ref<MatrixXr>, const GhostType &) {
         AKANTU_TO_IMPLEMENT();
       }
     };
 
 #define COMPUTE_SHAPE_DERIVATIVES(type)                                        \
-  Matrix<Real> coords_mat(real_coords.data(), shape_derivatives.rows(), 1);    \
-  Tensor3<Real> shapesd_tensor(shape_derivatives.data(),                       \
-                               shape_derivatives.rows(),                       \
-                               shape_derivatives.cols(), 1);                   \
+  VectorProxy<const Real> coords_mat(real_coords.data(),                       \
+                                     shape_derivatives.rows(), 1);             \
+  Tensor3Proxy<Real> shapesd_tensor(shape_derivatives.data(),                  \
+                                    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 Ref<const VectorXr> & real_coords, UInt element,    \
+                     const Ref<const VectorXr> & real_coords, Int element,     \
                      const ElementType type, Ref<MatrixXr> 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 Ref<const VectorXr> & real_coords, UInt element,
+    const Ref<const VectorXr> & real_coords, Int element,
     const ElementType & type, Ref<MatrixXr> 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 Int call(const I<k, IOF> & integrator, const ElementType type,      \
                     const GhostType & ghost_type) {                            \
       Int 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 Int
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::getNbIntegrationPoints(
     ElementType type, 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,                    \
                                     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(
-    ElementType type, GhostType ghost_type,
-    __attribute__((unused)) UInt id) const {
+    const ElementType & type, const GhostType & ghost_type,
+    __attribute__((unused)) Int 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> & /*unused*/,
-                                      ElementType /*unused*/,
-                                      GhostType /*unused*/, UInt /*unused*/) {
+      static const Array<Real> & call(const S<k> &, const ElementType &,
+                                      const GhostType &, Int) {
         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,                 \
-         GhostType ghost_type, __attribute__((unused)) UInt id) {              \
+         const GhostType & ghost_type, __attribute__((unused)) Int 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(
-    ElementType type, GhostType ghost_type,
-    __attribute__((unused)) UInt id) const {
+    const ElementType & type, const GhostType & ghost_type,
+    __attribute__((unused)) Int 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,                   \
                                      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(
     ElementType type, 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(indent, 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 & /*unused*/) {
   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> & /*unused*/,
     const ElementTypeMapArray<UInt> & /*unused*/,
     const RemovedElementsEvent & /*unused*/) {}
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::onElementsChanged(
     const Array<Element> & /*unused*/, const Array<Element> & /*unused*/,
     const ElementTypeMapArray<UInt> & /*unused*/,
     const ChangedElementsEvent & /*unused*/) {}
 
 /* -------------------------------------------------------------------------- */
 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> & /*unused*/,
                                             Array<Real> & normal,
                                             GhostType ghost_type) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(mesh.getSpatialDimension() == 1,
                       "Mesh dimension must be 1 to compute normals on points!");
   const auto type = _point_1;
   auto spatial_dimension = mesh.getSpatialDimension();
-  // UInt nb_nodes_per_element  = Mesh::getNbNodesPerElement(type);
+  // Int nb_nodes_per_element  = Mesh::getNbNodesPerElement(type);
   auto nb_points = getNbIntegrationPoints(type, ghost_type);
   const auto & connectivity = mesh.getConnectivity(type, ghost_type);
   auto nb_element = connectivity.size();
 
   normal.resize(nb_element * nb_points);
   auto normals_on_quad =
-      normal.begin_reinterpret(spatial_dimension, nb_points, nb_element);
+      make_view(normal, spatial_dimension, nb_points).begin();
   const auto & segments = mesh.getElementToSubelement(type, ghost_type);
   const auto & 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");
+  for (Idx elem = 0; elem < nb_element; ++elem) {
+    auto 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) {
       auto point = connectivity(elem);
       const auto segment = segments(elem)[0];
       const auto & segment_connectivity =
           mesh_segment->getConnectivity(segment.type, segment.ghost_type);
-      Vector<UInt> segment_points = segment_connectivity.begin(
+      Vector<Idx> segment_points = segment_connectivity.begin(
           Mesh::getNbNodesPerElement(segment.type))[segment.element];
       Real difference;
       if (segment_points(0) == point) {
         difference = coords(elem) - coords(segment_points(1));
       } else {
         difference = coords(elem) - coords(segment_points(0));
       }
 
       normal_value = difference / std::abs(difference);
     }
 
-    for (UInt n(0); n < nb_points; ++n) {
+    for (Idx 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_field.hh b/src/fe_engine/fe_engine_template_tmpl_field.hh
index d1ef14530..085c64633 100644
--- a/src/fe_engine/fe_engine_template_tmpl_field.hh
+++ b/src/fe_engine/fe_engine_template_tmpl_field.hh
@@ -1,508 +1,508 @@
 /**
  * @file   fe_engine_template_tmpl_field.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Aug 09 2017
  * @date last modification: Sat Mar 13 2021
  *
  * @brief  implementation of the assemble field s functions
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2016-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 //#include "fe_engine_template.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_FE_ENGINE_TEMPLATE_TMPL_FIELD_HH_
 #define AKANTU_FE_ENGINE_TEMPLATE_TMPL_FIELD_HH_
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* Matrix lumping functions                                                   */
 /* -------------------------------------------------------------------------- */
 namespace fe_engine {
   namespace details {
     namespace {
       template <class Functor>
       void fillField(const Functor & field_funct, Array<Real> & field,
-                     UInt nb_element, UInt nb_integration_points,
-                     ElementType type, GhostType ghost_type) {
-        UInt nb_degree_of_freedom = field.getNbComponent();
+                     Int nb_element, Int nb_integration_points,
+                     const ElementType & type, const GhostType & ghost_type) {
+        auto nb_degree_of_freedom = field.getNbComponent();
         field.resize(nb_integration_points * nb_element);
 
+        Matrix<Real> mat(nb_degree_of_freedom, nb_integration_points);
+
         Element el{type, 0, ghost_type};
         for (auto && data : enumerate(make_view(field, nb_degree_of_freedom,
                                                 nb_integration_points))) {
           el.element = std::get<0>(data);
-          field_funct(std::get<1>(data), el);
+          mat.fill(0.);
+          field_funct(mat, el);
+          mat = std::get<1>(data);
         }
       }
     } // namespace
   }   // namespace details
 } // namespace fe_engine
 
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct AssembleLumpedTemplateHelper {
       template <template <ElementKind, class> class I,
                 template <ElementKind> class S, ElementKind k, class IOF>
       static void call(const FEEngineTemplate<I, S, k, IOF> & /*unused*/,
                        const std::function<void(Matrix<Real> &,
                                                 const Element &)> & /*unused*/,
                        const ID & /*unused*/, const ID & /*unused*/,
                        DOFManager & /*unused*/, ElementType /*unused*/,
                        GhostType /*unused*/) {
         AKANTU_TO_IMPLEMENT();
       }
     };
 
 #define ASSEMBLE_LUMPED(type)                                                  \
   fem.template assembleFieldLumped<type>(field_funct, lumped, dof_id,          \
                                          dof_manager, ghost_type)
 
 #define AKANTU_SPECIALIZE_ASSEMBLE_HELPER(kind)                                \
   template <> struct AssembleLumpedTemplateHelper<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 std::function<void(Matrix<Real> &, const Element &)> &          \
              field_funct,                                                      \
          const ID & lumped, const ID & dof_id, DOFManager & dof_manager,       \
          ElementType type, GhostType ghost_type) {                             \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(ASSEMBLE_LUMPED, kind);                 \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_ASSEMBLE_HELPER,
                                AKANTU_FE_ENGINE_LIST_ASSEMBLE_FIELDS)
 
 #undef AKANTU_SPECIALIZE_ASSEMBLE_HELPER
 #undef AKANTU_SPECIALIZE_ASSEMBLE_HELPER_LIST_KIND
 #undef ASSEMBLE_LUMPED
   } // namespace details
 } // namespace fe_engine
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IOF>
 void FEEngineTemplate<I, S, kind, IOF>::assembleFieldLumped(
     const std::function<void(Matrix<Real> &, const Element &)> & field_funct,
     const ID & matrix_id, const ID & dof_id, DOFManager & dof_manager,
     ElementType type, GhostType ghost_type) const {
   AKANTU_DEBUG_IN();
 
   fe_engine::details::AssembleLumpedTemplateHelper<kind>::call(
       *this, field_funct, matrix_id, dof_id, dof_manager, type, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::assembleFieldLumped(
     const std::function<void(Matrix<Real> &, const Element &)> & field_funct,
     const ID & matrix_id, const ID & dof_id, DOFManager & dof_manager,
     GhostType ghost_type) const {
   AKANTU_DEBUG_IN();
 
-  UInt nb_degree_of_freedom = dof_manager.getDOFs(dof_id).getNbComponent();
-  UInt nb_element = mesh.getNbElement(type, ghost_type);
-  UInt nb_integration_points = this->getNbIntegrationPoints(type);
+  auto nb_degree_of_freedom = dof_manager.getDOFs(dof_id).getNbComponent();
+  auto nb_element = mesh.getNbElement(type, ghost_type);
+  auto nb_integration_points = this->getNbIntegrationPoints(type);
 
   Array<Real> field(0, nb_degree_of_freedom);
   fe_engine::details::fillField(field_funct, field, nb_element,
                                 nb_integration_points, type, ghost_type);
 
   switch (type) {
   case _triangle_6:
   case _quadrangle_8:
   case _tetrahedron_10:
   case _hexahedron_20:
   case _pentahedron_15:
     this->template assembleLumpedDiagonalScaling<type>(field, matrix_id, dof_id,
                                                        dof_manager, ghost_type);
     break;
   default:
     this->template assembleLumpedRowSum<type>(field, matrix_id, dof_id,
                                               dof_manager, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * @f$ \tilde{M}_{i} = \sum_j M_{ij} = \sum_j \int \rho \varphi_i \varphi_j dV =
  * \int \rho \varphi_i dV @f$
  */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     assembleLumpedRowSum(const Array<Real> & field, const ID & matrix_id,
                          const ID & dof_id, DOFManager & dof_manager,
                          GhostType ghost_type) const {
   AKANTU_DEBUG_IN();
 
   auto shapes_size = ElementClass<type>::getShapeSize();
   auto nb_degree_of_freedom = field.getNbComponent();
 
   auto field_times_shapes =
       std::make_shared<Array<Real>>(0, shapes_size * nb_degree_of_freedom);
 
   shape_functions.template computeNtb<type>(field, *field_times_shapes,
                                             ghost_type);
 
   auto nb_element = mesh.getNbElement(type, ghost_type);
   auto int_field_times_shapes = std::make_shared<Array<Real>>(
       nb_element, shapes_size * nb_degree_of_freedom, "inte_rho_x_shapes");
 
   integrator.template integrate<type>(
       *field_times_shapes, *int_field_times_shapes,
       nb_degree_of_freedom * shapes_size, ghost_type, empty_filter);
 
   dof_manager.assembleElementalArrayToLumpedMatrix(
       dof_id, *int_field_times_shapes, matrix_id, type, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * @f$ \tilde{M}_{i} = c * M_{ii} = \int_{V_e} \rho dV @f$
  */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     assembleLumpedDiagonalScaling(const Array<Real> & field,
                                   const ID & matrix_id, const ID & dof_id,
                                   DOFManager & dof_manager,
                                   GhostType ghost_type) const {
   AKANTU_DEBUG_IN();
 
   const auto & type_p1 = ElementClass<type>::getP1ElementType();
   auto nb_nodes_per_element_p1 = Mesh::getNbNodesPerElement(type_p1);
   auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   auto nb_degree_of_freedom = field.getNbComponent();
   auto nb_element = mesh.getNbElement(type, ghost_type);
 
   Vector<Real> nodal_factor(nb_nodes_per_element);
 
 #define ASSIGN_WEIGHT_TO_NODES(corner, mid)                                    \
   {                                                                            \
     for (Int n = 0; n < nb_nodes_per_element_p1; n++)                          \
       nodal_factor(n) = corner;                                                \
     for (Int n = nb_nodes_per_element_p1; n < nb_nodes_per_element; n++)       \
       nodal_factor(n) = mid;                                                   \
   }
 
   if (type == _triangle_6)
     ASSIGN_WEIGHT_TO_NODES(1. / 12., 1. / 4.);
   if (type == _tetrahedron_10)
     ASSIGN_WEIGHT_TO_NODES(1. / 32., 7. / 48.);
   if (type == _quadrangle_8)
     ASSIGN_WEIGHT_TO_NODES(
         3. / 76.,
         16. / 76.); /** coeff. derived by scaling
                      * the diagonal terms of the corresponding
                      * consistent mass computed with 3x3 gauss points;
                      * coeff. are (1./36., 8./36.) for 2x2 gauss points */
   if (type == _hexahedron_20)
     ASSIGN_WEIGHT_TO_NODES(
         7. / 248., 16. / 248.); /** coeff. derived by scaling
                                  * the diagonal terms of the corresponding
                                  * consistent mass computed with 3x3x3 gauss
                                  * points; coeff. are (1./40.,
                                  * 1./15.) for 2x2x2 gauss points */
   if (type == _pentahedron_15) {
     // coefficients derived by scaling the diagonal terms of the corresponding
     // consistent mass computed with 8 gauss points;
     for (Int n = 0; n < nb_nodes_per_element_p1; n++)
       nodal_factor(n) = 51. / 2358.;
     }
 
     Real mid_triangle = 192. / 2358.;
     Real mid_quadrangle = 300. / 2358.;
 
     nodal_factor(6) = mid_triangle;
     nodal_factor(7) = mid_triangle;
     nodal_factor(8) = mid_triangle;
     nodal_factor(9) = mid_quadrangle;
     nodal_factor(10) = mid_quadrangle;
     nodal_factor(11) = mid_quadrangle;
     nodal_factor(12) = mid_triangle;
     nodal_factor(13) = mid_triangle;
     nodal_factor(14) = mid_triangle;
   }
 
   if (nb_element == 0) {
     AKANTU_DEBUG_OUT();
     return;
   }
 
 #undef ASSIGN_WEIGHT_TO_NODES
   /// compute @f$ \int \rho dV = \rho V @f$ for each element
   auto int_field = std::make_unique<Array<Real>>(
       field.size(), nb_degree_of_freedom, "inte_rho_x");
   integrator.template integrate<type>(field, *int_field, nb_degree_of_freedom,
                                       ghost_type, empty_filter);
 
   /// distribute the mass of the element to the nodes
   auto lumped_per_node = std::make_unique<Array<Real>>(
       nb_element, nb_degree_of_freedom * nb_nodes_per_element, "mass_per_node");
   auto int_field_it = int_field->begin(nb_degree_of_freedom);
   auto lumped_per_node_it =
       lumped_per_node->begin(nb_degree_of_freedom, nb_nodes_per_element);
 
-  for (UInt e = 0; e < nb_element; ++e) {
-    for (UInt n = 0; n < nb_nodes_per_element; ++n) {
-      Vector<Real> l = (*lumped_per_node_it)(n);
-      l = *int_field_it;
-      l *= nodal_factor(n);
+  for (Int e = 0; e < nb_element; ++e) {
+    for (Int n = 0; n < nb_nodes_per_element; ++n) {
+      auto && l = (*lumped_per_node_it)(n);
+      l = *int_field_it * nodal_factor(n);
     }
     ++int_field_it;
     ++lumped_per_node_it;
   }
 
   dof_manager.assembleElementalArrayToLumpedMatrix(dof_id, *lumped_per_node,
                                                    matrix_id, 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 AssembleFieldMatrixHelper {
       template <template <ElementKind, class> class I,
                 template <ElementKind> class S, ElementKind k, class IOF>
       static void call(const FEEngineTemplate<I, S, k, IOF> & /*unused*/,
                        const std::function<void(Matrix<Real> &,
                                                 const Element &)> & /*unused*/,
                        const ID & /*unused*/, const ID & /*unused*/,
                        DOFManager & /*unused*/, ElementType /*unused*/,
                        GhostType /*unused*/) {
         AKANTU_TO_IMPLEMENT();
       }
     };
 
 #define ASSEMBLE_MATRIX(type)                                                  \
   fem.template assembleFieldMatrix<type>(field_funct, matrix_id, dof_id,       \
                                          dof_manager, ghost_type)
 
 #define AKANTU_SPECIALIZE_ASSEMBLE_FIELD_MATRIX_HELPER(kind)                   \
   template <> struct AssembleFieldMatrixHelper<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 std::function<void(Matrix<Real> &, const Element &)> &          \
              field_funct,                                                      \
          const ID & matrix_id, const ID & dof_id, DOFManager & dof_manager,    \
          ElementType type, GhostType ghost_type) {                             \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(ASSEMBLE_MATRIX, kind);                 \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_ASSEMBLE_FIELD_MATRIX_HELPER,
                                AKANTU_FE_ENGINE_LIST_ASSEMBLE_FIELDS)
 
 #undef AKANTU_SPECIALIZE_ASSEMBLE_FIELD_MATRIX_HELPER
 #undef ASSEMBLE_MATRIX
   } // namespace details
 } // namespace fe_engine
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IOF>
 void FEEngineTemplate<I, S, kind, IOF>::assembleFieldMatrix(
     const std::function<void(Matrix<Real> &, const Element &)> & field_funct,
     const ID & matrix_id, const ID & dof_id, DOFManager & dof_manager,
     ElementType type, GhostType ghost_type) const {
   AKANTU_DEBUG_IN();
 
   fe_engine::details::AssembleFieldMatrixHelper<kind>::template call(
       *this, field_funct, matrix_id, dof_id, dof_manager, type, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ShapesForMassHelper {
       template <ElementType type, class ShapeFunctions>
       static auto getShapes(ShapeFunctions & shape_functions,
                             const Matrix<Real> & integration_points,
                             const Array<Real> & nodes,
                             UInt & nb_degree_of_freedom, UInt nb_element,
                             GhostType ghost_type) {
 
         UInt shapes_size = ElementClass<type>::getShapeSize();
         Array<Real> shapes(0, shapes_size);
 
         shape_functions.template computeShapesOnIntegrationPoints<type>(
             nodes, integration_points, shapes, ghost_type);
 
         UInt nb_integration_points = integration_points.cols();
         UInt vect_size = nb_integration_points * nb_element;
         UInt lmat_size = nb_degree_of_freedom * shapes_size;
 
         // Extending the shape functions
         /// \todo move this in the shape functions as Voigt format shapes to
         /// have the code in common with the structural elements
         auto shapes_voigt = std::make_unique<Array<Real>>(
             vect_size, lmat_size * nb_degree_of_freedom, 0.);
         auto mshapes_it = shapes_voigt->begin(nb_degree_of_freedom, lmat_size);
         auto shapes_it = shapes.begin(shapes_size);
 
         for (UInt q = 0; q < vect_size; ++q, ++mshapes_it, ++shapes_it) {
           for (UInt d = 0; d < nb_degree_of_freedom; ++d) {
             for (UInt s = 0; s < shapes_size; ++s) {
               (*mshapes_it)(d, s * nb_degree_of_freedom + d) = (*shapes_it)(s);
             }
           }
         }
 
         return shapes_voigt;
       }
     };
 
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
     template <> struct ShapesForMassHelper<_ek_structural> {
       template <ElementType type, class ShapeFunctions>
       static auto getShapes(ShapeFunctions & shape_functions,
                             const Matrix<Real> & integration_points,
                             const Array<Real> & nodes,
                             UInt & nb_degree_of_freedom, UInt /*nb_element*/,
                             GhostType ghost_type) {
 
         auto nb_unknown = ElementClass<type>::getNbStressComponents();
         auto nb_degree_of_freedom_ = ElementClass<type>::getNbDegreeOfFreedom();
         auto nb_nodes_per_element = ElementClass<type>::getNbNodesPerElement();
         auto shapes = std::make_unique<Array<Real>>(
             0, nb_unknown * nb_nodes_per_element * nb_degree_of_freedom_);
         nb_degree_of_freedom = nb_unknown;
         shape_functions.template computeShapesMassOnIntegrationPoints<type>(
             nodes, integration_points, *shapes, ghost_type);
 
         return shapes;
       }
     };
 #endif
   } // namespace details
 } // namespace fe_engine
   //
 /* -------------------------------------------------------------------------- */
 /**
  * @f$ \tilde{M}_{i} = \sum_j M_{ij} = \sum_j \int \rho \varphi_i \varphi_j dV =
  * \int \rho \varphi_i dV @f$
  */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::assembleFieldMatrix(
     const std::function<void(Matrix<Real> &, const Element &)> & field_funct,
     const ID & matrix_id, const ID & dof_id, DOFManager & dof_manager,
     GhostType ghost_type) const {
   AKANTU_DEBUG_IN();
 
   auto shapes_size = ElementClass<type>::getShapeSize();
   auto nb_degree_of_freedom = dof_manager.getDOFs(dof_id).getNbComponent();
   auto lmat_size = nb_degree_of_freedom * shapes_size;
   auto nb_element = mesh.getNbElement(type, ghost_type);
 
   // \int N * N  so degree 2 * degree of N
   const auto polynomial_degree =
       2 * ElementClassProperty<type>::polynomial_degree;
 
   // getting the integration points
   auto integration_points =
       integrator.template getIntegrationPoints<type, polynomial_degree>();
 
   auto nb_integration_points = integration_points.cols();
   auto vect_size = nb_integration_points * nb_element;
 
   // getting the shapes on the integration points
   auto shapes_voigt =
       fe_engine::details::ShapesForMassHelper<kind>::template getShapes<type>(
           shape_functions, integration_points, mesh.getNodes(),
           nb_degree_of_freedom, nb_element, ghost_type);
 
   auto vect_size = shapes_voigt->size();
 
   // getting the value to assemble on the integration points
   Array<Real> field(vect_size, nb_degree_of_freedom);
   fe_engine::details::fillField(field_funct, field, nb_element,
                                 integration_points.cols(), type, ghost_type);
 
   auto lmat_size = shapes_voigt->getNbComponent() / nb_degree_of_freedom;
 
   // computing \rho * N
-  mshapes_it = make_view(modified_shapes, nb_degree_of_freedom, lmat_size);
-  auto lmat = make_view(local_mat, lmat_size, lmat_size);
-  auto field_it = make_view(field, nb_degree_of_freedom);
   for (auto && data :
        zip(make_view(local_mat, lmat_size, lmat_size),
            make_view(modified_shapes, nb_degree_of_freedom, lmat_size),
            make_view(field, nb_degree_of_freedom))) {
     const auto & rho = std::get<2>(data);
     const auto & N = std::get<1>(data);
     auto & mat = std::get<0>(data);
 
     Matrix<Real> Nt = N.transpose();
     for (Int d = 0; d < Nt.cols(); ++d) {
       Nt(d) *= rho(d);
     }
 
     mat = Nt * N;
   }
 
   // integrate the elemental values
   Array<Real> int_field_times_shapes(nb_element, lmat_size * lmat_size,
                                      "inte_rho_x_shapes");
   this->integrator.template integrate<type, polynomial_degree>(
       local_mat, int_field_times_shapes, lmat_size * lmat_size, ghost_type);
 
   // assemble the elemental values to the matrix
   dof_manager.assembleElementalMatricesToMatrix(
       matrix_id, dof_id, int_field_times_shapes, type, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
 
 #endif /* AKANTU_FE_ENGINE_TEMPLATE_TMPL_FIELD_HH_ */
diff --git a/src/fe_engine/fe_engine_template_tmpl_struct.hh b/src/fe_engine/fe_engine_template_tmpl_struct.hh
index d6d80f772..b450195f3 100644
--- a/src/fe_engine/fe_engine_template_tmpl_struct.hh
+++ b/src/fe_engine/fe_engine_template_tmpl_struct.hh
@@ -1,103 +1,74 @@
 /**
  * @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: Tue Sep 29 2020
  *
  * @brief  Template implementation of FEEngineTemplate for Structural Element
  * Kinds
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2014-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "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,
+                   const Array<Real> & field_1, Int nb_degree_of_freedom,
                    SparseMatrix & M, Array<Real> * n,
                    ElementTypeMapArray<Real> & rotation_mat, ElementType type,
                    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,
-//     ElementType type, 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(
-//     ElementType, UInt, UInt, Array<Real> *, UInt, UInt, UInt,
-//     const bool, GhostType) const {
-
-//   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> & /*unused*/, UInt /*unused*/, SparseMatrix & /*unused*/,
-    Array<Real> * /*unused*/, ElementTypeMapArray<Real> & /*unused*/,
-    GhostType /*unused*/) const {
+    const Array<Real> &, Int, SparseMatrix &, Array<Real> *,
+    ElementTypeMapArray<Real> &, const GhostType &) const {
   AKANTU_TO_IMPLEMENT();
 }
 
 } // namespace akantu
diff --git a/src/fe_engine/gauss_integration_tmpl.hh b/src/fe_engine/gauss_integration_tmpl.hh
index e879729a3..4e1f0c0fc 100644
--- a/src/fe_engine/gauss_integration_tmpl.hh
+++ b/src/fe_engine/gauss_integration_tmpl.hh
@@ -1,287 +1,282 @@
 /**
  * @file   gauss_integration_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue May 10 2016
  * @date last modification: Tue Sep 29 2020
  *
  * @brief  implementation of the gauss integration helpers
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2016-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_GAUSS_INTEGRATION_TMPL_HH_
 #define AKANTU_GAUSS_INTEGRATION_TMPL_HH_
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* GaussIntegrationElement                                                    */
 /* -------------------------------------------------------------------------- */
 namespace _aka_gauss_helpers {
-  template <GaussIntegrationType type, UInt n>
-  struct GaussIntegrationNbPoints {
-    static const UInt nb_points = 0;
-  };
+  template <GaussIntegrationType type, Int n>
+  struct GaussIntegrationNbPoints {};
 
 #if !defined(DOXYGEN)
-  template <UInt n> struct GaussIntegrationNbPoints<_git_not_defined, n> {
-    static constexpr UInt nb_points = 0;
+  template <Int n> struct GaussIntegrationNbPoints<_git_not_defined, n> {
+    static constexpr Int nb_points = 0;
   };
 
-  template <UInt n> struct GaussIntegrationNbPoints<_git_point, n> {
-    static constexpr UInt nb_points = 1;
+  template <Int n> struct GaussIntegrationNbPoints<_git_point, n> {
+    static constexpr Int nb_points = 1;
   };
 
-  template <UInt n> struct GaussIntegrationNbPoints<_git_segment, n> {
-    static constexpr UInt nb_points = (n + 1) / 2 + (bool((n + 1) % 2) ? 1 : 0);
+  template <Int n> struct GaussIntegrationNbPoints<_git_segment, n> {
+    static constexpr Int nb_points = (n + 1) / 2 + (bool((n + 1) % 2) ? 1 : 0);
   };
 
 #define DECLARE_GAUSS_NB_POINTS(type, order, points)                           \
   template <> struct GaussIntegrationNbPoints<type, order> {                   \
-    static constexpr UInt nb_points = points;                                  \
+    static constexpr Int nb_points = points;                                  \
   }
 
 #define DECLARE_GAUSS_NB_POINTS_PENT(type, order, xo, yo)                      \
   template <> struct GaussIntegrationNbPoints<type, order> {                   \
-    static constexpr UInt x_order = xo;                                        \
-    static constexpr UInt yz_order = yo;                                       \
-    static constexpr UInt nb_points = 1;                                       \
+    static constexpr Int x_order = xo;                                        \
+    static constexpr Int yz_order = yo;                                       \
+    static constexpr Int nb_points = 1;                                       \
   }
 
   DECLARE_GAUSS_NB_POINTS(_git_triangle, 1, 1);
   DECLARE_GAUSS_NB_POINTS(_git_triangle, 2, 3);
   DECLARE_GAUSS_NB_POINTS(_git_triangle, 3, 4);
   DECLARE_GAUSS_NB_POINTS(_git_triangle, 4, 6);
   DECLARE_GAUSS_NB_POINTS(_git_triangle, 5, 7);
   DECLARE_GAUSS_NB_POINTS(_git_tetrahedron, 1, 1);
   DECLARE_GAUSS_NB_POINTS(_git_tetrahedron, 2, 4);
   DECLARE_GAUSS_NB_POINTS(_git_tetrahedron, 3, 5);
   DECLARE_GAUSS_NB_POINTS(_git_tetrahedron, 4, 15);
   DECLARE_GAUSS_NB_POINTS(_git_tetrahedron, 5, 15);
   DECLARE_GAUSS_NB_POINTS_PENT(_git_pentahedron, 1, 3,
                                2); // order 3 in x, order 2 in y and z
   DECLARE_GAUSS_NB_POINTS_PENT(_git_pentahedron, 2, 3,
                                2); // order 3 in x, order 2 in y and z
   DECLARE_GAUSS_NB_POINTS_PENT(_git_pentahedron, 3, 3,
                                3); // order 3 in x, order 3 in y and z
   DECLARE_GAUSS_NB_POINTS_PENT(_git_pentahedron, 4, 5,
                                5); // order 5 in x, order 5 in y and z
   DECLARE_GAUSS_NB_POINTS_PENT(_git_pentahedron, 5, 5,
                                5); // order 5 in x, order 5 in y and z
 
-  template <GaussIntegrationType type, UInt n, UInt on = n,
+  template <GaussIntegrationType type, Int n, Int on = n,
             bool end_recurse = false>
   struct GaussIntegrationNbPointsHelper {
-    static constexpr UInt pnp = GaussIntegrationNbPoints<type, n>::nb_points;
-    static constexpr UInt order = n;
-    static constexpr UInt nb_points = pnp;
+    static constexpr Int pnp = GaussIntegrationNbPoints<type, n>::nb_points;
+    static constexpr Int order = n;
+    static constexpr Int nb_points = pnp;
   };
 
-  template <GaussIntegrationType type, UInt n, UInt on>
+  template <GaussIntegrationType type, Int n, Int on>
   struct GaussIntegrationNbPointsHelper<type, n, on, true> {
-    static constexpr UInt nb_points = 0;
+    static constexpr Int nb_points = 0;
   };
 #endif
 
   /* ------------------------------------------------------------------------ */
   /* Generic helper                                                           */
   /* ------------------------------------------------------------------------ */
-  template <GaussIntegrationType type, UInt dimension, UInt n>
+  template <GaussIntegrationType type, Int dimension, Int n>
   struct GaussIntegrationTypeDataHelper {
     using git_np = GaussIntegrationNbPoints<type, n>;
     using git_data = GaussIntegrationTypeData<type, git_np::nb_points>;
 
-    static constexpr UInt getNbQuadraturePoints() { return git_np::nb_points; }
+    static constexpr Int getNbQuadraturePoints() { return git_np::nb_points; }
 
     static decltype(auto) getQuadraturePoints() {
       return Eigen::Map<
           const Eigen::Matrix<Real, dimension, git_np::nb_points>>(
           git_data::quad_positions);
     }
 
     static decltype(auto) getWeights() {
       return Eigen::Map<const Eigen::Matrix<Real, git_np::nb_points, 1>>(
           git_data::quad_weights);
     }
   };
 
 #if !defined(DOXYGEN)
   /* ------------------------------------------------------------------------ */
   /* helper for _segment _quadrangle _hexahedron                              */
   /* ------------------------------------------------------------------------ */
-  template <UInt dimension, UInt dp>
+  template <Int dimension, Int dp>
   struct GaussIntegrationTypeDataHelper<_git_segment, dimension, dp> {
     using git_np = GaussIntegrationNbPoints<_git_segment, dp>;
     using git_data = GaussIntegrationTypeData<_git_segment, git_np::nb_points>;
 
-    static constexpr UInt getNbQuadraturePoints() {
-      return Math::pow<dimension>(git_np::nb_points);
+    static constexpr Int getNbQuadraturePoints() {
+      return Math::pow(git_np::nb_points, dimension);
     }
 
     static constexpr decltype(auto) getQuadraturePoints() {
       const auto tot_nquad = getNbQuadraturePoints();
       const auto nquad = git_np::nb_points;
 
       Eigen::Matrix<Real, dimension, tot_nquad> quads;
       Eigen::Map<const Eigen::Matrix<Real, nquad, 1>> pos(
           git_data::quad_positions);
 
-      UInt offset = 1;
-      for (UInt d = 0; d < dimension; ++d) {
-        for (UInt n = 0, q = 0; n < tot_nquad; ++n, q += offset) {
-          auto rq = q % tot_nquad + q / tot_nquad;
+      Int offset = 1;
+      for (Int d = 0; d < dimension; ++d) {
+        for (Int n = 0, q = 0; n < tot_nquad; ++n, q += offset) {
+          Int rq = q % tot_nquad + q / tot_nquad;
           quads(d, rq) = pos(n % nquad);
         }
         offset *= nquad;
       }
       return quads;
     }
 
     static constexpr decltype(auto) getWeights() {
       const auto tot_nquad = getNbQuadraturePoints();
       const auto nquad = git_np::nb_points;
 
       Eigen::Matrix<Real, tot_nquad, 1> quads_weights;
       quads_weights.fill(1);
       Eigen::Map<const Eigen::Matrix<Real, nquad, 1>> weights(
           git_data::quad_weights);
 
-      UInt offset = 1;
-      for (UInt d = 0; d < dimension; ++d) {
-        for (UInt n = 0, q = 0; n < tot_nquad; ++n, q += offset) {
-          UInt rq = q % tot_nquad + q / tot_nquad;
+      Int offset = 1;
+      for (Int d = 0; d < dimension; ++d) {
+        for (Int n = 0, q = 0; n < tot_nquad; ++n, q += offset) {
+          Int rq = q % tot_nquad + q / tot_nquad;
           quads_weights(rq) *= weights(n % nquad);
         }
         offset *= nquad;
       }
       return quads_weights;
     }
   };
 
   /* ------------------------------------------------------------------------ */
   /* helper for _pentahedron                                                  */
   /* ------------------------------------------------------------------------ */
-  template <UInt dimension, UInt dp>
+  template <Int dimension, Int dp>
   struct GaussIntegrationTypeDataHelper<_git_pentahedron, dimension, dp> {
     using git_info = GaussIntegrationNbPoints<_git_pentahedron, dp>;
     using git_np_seg =
         GaussIntegrationNbPoints<_git_segment, git_info::x_order>;
     using git_np_tri =
         GaussIntegrationNbPoints<_git_triangle, git_info::yz_order>;
     using git_data_seg =
         GaussIntegrationTypeData<_git_segment, git_np_seg::nb_points>;
     using git_data_tri =
         GaussIntegrationTypeData<_git_triangle, git_np_tri::nb_points>;
 
-    static UInt getNbQuadraturePoints() {
+    static constexpr Int getNbQuadraturePoints() {
       return git_np_seg::nb_points * git_np_tri::nb_points;
     }
 
-    static Matrix<Real> getQuadraturePoints() {
-      UInt tot_nquad = getNbQuadraturePoints();
-      UInt nquad_seg = git_np_seg::nb_points;
-      UInt nquad_tri = git_np_tri::nb_points;
-
-      Matrix<Real> quads(dimension, tot_nquad);
-      Matrix<Real> pos_seg_w(git_data_seg::quad_positions, 1, nquad_seg);
-      Matrix<Real> pos_tri_w(git_data_tri::quad_positions, 2, nquad_tri);
-
-      for (UInt ns = 0, q = 0; ns < nquad_seg; ++ns) {
-        Vector<Real> pos_seg = pos_seg_w(ns);
-        for (UInt nt = 0; nt < nquad_tri; ++nt, ++q) {
-          Vector<Real> pos_tri = pos_tri_w(nt);
-          Vector<Real> quad = quads(q);
-          quad(_x) = pos_seg(_x);
-          quad(_y) = pos_tri(_x);
-          quad(_z) = pos_tri(_y);
+    static const Matrix<Real> getQuadraturePoints() {
+      constexpr auto tot_nquad = getNbQuadraturePoints();
+      constexpr auto nquad_seg = git_np_seg::nb_points;
+      constexpr auto nquad_tri = git_np_tri::nb_points;
+
+      Matrix<Real, dimension, tot_nquad> quads;
+      Eigen::Map<Vector<Real, nquad_seg>> pos_seg(git_data_seg::quad_positions);
+      Eigen::Map<Matrix<Real, 2, nquad_tri>> pos_tri(git_data_tri::quad_positions);
+
+      for (Int ns = 0, q = 0; ns < nquad_seg; ++ns) {
+        for (Int nt = 0; nt < nquad_tri; ++nt, ++q) {
+          auto && quad = quads(q);
+          quad(_x) = pos_seg(ns);
+          quad(_y) = pos_tri(_x, nt);
+          quad(_z) = pos_tri(_y, nt);
         }
       }
       return quads;
     }
 
     static const Vector<Real> getWeights() {
-      const auto tot_nquad = getNbQuadraturePoints();
-      const auto nquad_seg = git_np_seg::nb_points;
-      const auto nquad_tri = git_np_tri::nb_points;
-
-      Eigen::Matrix<Real, tot_nquad, 1> quads_weights;
+      constexpr auto tot_nquad = getNbQuadraturePoints();
+      constexpr auto nquad_seg = git_np_seg::nb_points;
+      constexpr auto nquad_tri = git_np_tri::nb_points;
 
-      Eigen::Map<const Eigen::Matrix<Real, nquad_seg, 1>> weight_seg(
+       Vector<Real, tot_nquad> quads_weights;
+      Eigen::Map<const Vector<Real, nquad_seg>> weight_seg(
           git_data_seg::quad_weights);
-      Eigen::Map<const Eigen::Matrix<Real, nquad_tri, 1>> weight_tri(
+      Eigen::Map<const Vector<Real, nquad_tri>> weight_tri(
           git_data_tri::quad_weights);
 
-      for (UInt ns = 0, q = 0; ns < nquad_seg; ++ns) {
-        for (UInt nt = 0; nt < nquad_tri; ++nt, ++q) {
+      for (Int ns = 0, q = 0; ns < nquad_seg; ++ns) {
+        for (Int nt = 0; nt < nquad_tri; ++nt, ++q) {
           quads_weights(q) = weight_seg(ns) * weight_tri(nt);
         }
       }
       return quads_weights;
     }
   };
 #endif
 } // namespace _aka_gauss_helpers
 
 template <ElementType element_type, Int n>
 constexpr decltype(auto)
 GaussIntegrationElement<element_type, n>::getQuadraturePoints() {
   const InterpolationType itp_type =
       ElementClassProperty<element_type>::interpolation_type;
   using interpolation_property = InterpolationProperty<itp_type>;
   using data_helper = _aka_gauss_helpers::GaussIntegrationTypeDataHelper<
       ElementClassProperty<element_type>::gauss_integration_type,
       interpolation_property::natural_space_dimension, n>;
   return data_helper::getQuadraturePoints();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType element_type, Int n>
 constexpr decltype(auto)
 GaussIntegrationElement<element_type, n>::getWeights() {
   const InterpolationType itp_type =
       ElementClassProperty<element_type>::interpolation_type;
   using interpolation_property = InterpolationProperty<itp_type>;
   using data_helper = _aka_gauss_helpers::GaussIntegrationTypeDataHelper<
       ElementClassProperty<element_type>::gauss_integration_type,
       interpolation_property::natural_space_dimension, n>;
   return data_helper::getWeights();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType element_type, Int n>
 constexpr Int
 GaussIntegrationElement<element_type, n>::getNbQuadraturePoints() {
   const InterpolationType itp_type =
       ElementClassProperty<element_type>::interpolation_type;
   using interpolation_property = InterpolationProperty<itp_type>;
   using data_helper = _aka_gauss_helpers::GaussIntegrationTypeDataHelper<
       ElementClassProperty<element_type>::gauss_integration_type,
       interpolation_property::natural_space_dimension, n>;
   return data_helper::getNbQuadraturePoints();
 }
 
 } // namespace akantu
 
 #endif /* AKANTU_GAUSS_INTEGRATION_TMPL_HH_ */
diff --git a/src/fe_engine/integrator.hh b/src/fe_engine/integrator.hh
index 11c1d1760..0434dc2aa 100644
--- a/src/fe_engine/integrator.hh
+++ b/src/fe_engine/integrator.hh
@@ -1,138 +1,134 @@
 /**
  * @file   integrator.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Sep 29 2020
  *
  * @brief  interface for integrator classes
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef AKANTU_INTEGRATOR_HH_
 #define AKANTU_INTEGRATOR_HH_
 
 /* -------------------------------------------------------------------------- */
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
 class Integrator {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-  Integrator(const Mesh & mesh, UInt spatial_dimension,
+  Integrator(const Mesh & mesh, Int spatial_dimension,
              const ID & id = "integrator")
       : mesh(mesh), _spatial_dimension(spatial_dimension),
         jacobians("jacobians", id) {
     AKANTU_DEBUG_IN();
 
     AKANTU_DEBUG_OUT();
   };
 
   virtual ~Integrator() = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// empty method
   template <ElementType type>
-  inline void precomputeJacobiansOnQuadraturePoints(__attribute__((unused))
-                                                    GhostType ghost_type) {}
+  inline void precomputeJacobiansOnQuadraturePoints(GhostType /*ghost_type*/) {}
 
   /// empty method
   void integrateOnElement(const Array<Real> & /*f*/, Real * /*intf*/,
-                          UInt /*nb_degree_of_freedom*/,
+                          Int /*nb_degree_of_freedom*/,
                           const Element & /*elem*/,
                           GhostType /*ghost_type*/) const {};
 
   /// 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) {
-      ;
-    }
+    std::string space(indent, AKANTU_INDENT);
     stream << space << "Integrator [" << std::endl;
     jacobians.printself(stream, indent + 1);
     stream << space << "]" << std::endl;
   };
 
   /* ------------------------------------------------------------------------ */
 public:
   virtual void onElementsAdded(const Array<Element> & /*unused*/) {}
   virtual void
   onElementsRemoved(const Array<Element> &,
                     const ElementTypeMapArray<Idx> & new_numbering) {
     jacobians.onElementsRemoved(new_numbering);
   }
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// access to the jacobians
   Array<Real> & getJacobians(ElementType type,
                              GhostType ghost_type = _not_ghost) {
     return jacobians(type, ghost_type);
   };
 
   /// access to the jacobians const
   const Array<Real> & getJacobians(ElementType type,
                                    GhostType ghost_type = _not_ghost) const {
     return jacobians(type, ghost_type);
   };
 
   AKANTU_GET_MACRO(Jacobians, jacobians, const ElementTypeMapArray<Real> &);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// mesh associated to the integrator
   const Mesh & mesh;
 
   // spatial dimension of the elements to consider
-  UInt _spatial_dimension;
+  Int _spatial_dimension;
 
   /// jacobians for all elements
   ElementTypeMapArray<Real> jacobians;
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 //#include "integrator_inline_impl.hh"
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream,
                                  const Integrator & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #endif /* AKANTU_INTEGRATOR_HH_ */
diff --git a/src/fe_engine/integrator_gauss.hh b/src/fe_engine/integrator_gauss.hh
index f14f045ea..961869b51 100644
--- a/src/fe_engine/integrator_gauss.hh
+++ b/src/fe_engine/integrator_gauss.hh
@@ -1,204 +1,205 @@
 /**
  * @file   integrator_gauss.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Sep 29 2020
  *
  * @brief  Gauss integration facilities
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "integrator.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_INTEGRATOR_GAUSS_HH_
 #define AKANTU_INTEGRATOR_GAUSS_HH_
 
 namespace akantu {
 namespace integrator {
   namespace details {
     template <ElementKind> struct GaussIntegratorComputeJacobiansHelper;
   } // namespace details
 } // namespace integrator
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 class IntegratorGauss : public Integrator {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   IntegratorGauss(const Mesh & mesh, Int spatial_dimension,
                   const ID & id = "integrator_gauss");
 
   ~IntegratorGauss() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   void initIntegrator(const Array<Real> & nodes, ElementType type,
                       GhostType ghost_type);
 
   template <ElementType type>
   inline void initIntegrator(const Array<Real> & nodes,
                              GhostType ghost_type);
 
   /// integrate f on the element "elem" of type "type"
   template <ElementType type>
   inline void integrateOnElement(const Array<Real> & f, Real * intf,
                                  Int nb_degree_of_freedom, const Idx elem,
                                  const GhostType & ghost_type) const;
 
   /// integrate f for all elements of type "type"
   template <ElementType type>
   void integrate(const Array<Real> & in_f, Array<Real> & intf,
                  Int nb_degree_of_freedom, const GhostType & ghost_type,
-                 const Array<Int> & filter_elements) const;
+                 const Array<Idx> & filter_elements) const;
 
   /// integrate scalar field in_f
   template <ElementType type, Int polynomial_degree>
   Real integrate(const Array<Real> & in_f,
                  GhostType ghost_type = _not_ghost) const;
 
   /// integrate partially around a quadrature point (@f$ intf_q = f_q * J_q *
   /// w_q @f$)
   template <ElementType type>
   Real integrate(const Vector<Real> & in_f, Idx index,
                  const GhostType & ghost_type) const;
 
   /// integrate scalar field in_f
   template <ElementType type>
   Real integrate(const Array<Real> & in_f, const GhostType & ghost_type,
-                 const Array<Int> & filter_elements) const;
+                 const Array<Idx> & filter_elements) const;
 
   /// integrate a field without using the pre-computed values
   template <ElementType type, Int polynomial_degree>
   void integrate(const Array<Real> & in_f, Array<Real> & intf,
                  Int nb_degree_of_freedom, const GhostType & ghost_type) const;
 
   /// integrate partially around a quadrature point (@f$ intf_q = f_q * J_q *
   /// w_q @f$)
   template <ElementType type>
   void integrateOnIntegrationPoints(const Array<Real> & in_f,
                                     Array<Real> & intf,
                                     Int nb_degree_of_freedom,
                                     const GhostType & ghost_type,
-                                    const Array<Int> & filter_elements) const;
+                                    const Array<Idx> & filter_elements) const;
 
   /// return a matrix with quadrature points natural coordinates
   template <ElementType type>
   const Matrix<Real> & getIntegrationPoints(GhostType ghost_type) const;
 
   /// return number of quadrature points
   template <ElementType type>
   Int getNbIntegrationPoints(const GhostType & ghost_type) const;
 
   template <ElementType type, Int n> Matrix<Real> getIntegrationPoints() const;
   template <ElementType type, Int n> Vector<Real> getIntegrationWeights() const;
 
 protected:
   friend struct integrator::details::GaussIntegratorComputeJacobiansHelper<
       kind>;
 
   template <ElementType type>
   void computeJacobiansOnIntegrationPoints(
       const Array<Real> & nodes, const Matrix<Real> & quad_points,
       Array<Real> & jacobians, const GhostType & ghost_type,
-      const Array<Int> & filter_elements = empty_filter) const;
+      const Array<Idx> & filter_elements = empty_filter) const;
 
   void computeJacobiansOnIntegrationPoints(
       const Array<Real> & nodes, const Matrix<Real> & quad_points,
       Array<Real> & jacobians, const ElementType & type,
       const GhostType & ghost_type,
-      const Array<Int> & filter_elements = empty_filter) const;
+      const Array<Idx> & filter_elements = empty_filter) const;
 
   /// precompute jacobians on elements of type "type"
   template <ElementType type>
   void precomputeJacobiansOnQuadraturePoints(const Array<Real> & nodes,
                                              GhostType ghost_type);
 
   // multiply the jacobians by the integration weights and stores the results in
   // jacobians
   template <ElementType type, Int polynomial_degree>
   void multiplyJacobiansByWeights(
       Array<Real> & jacobians,
-      const Array<Int> & filter_elements = empty_filter) const;
+      const Array<Idx> & filter_elements = empty_filter) const;
 
   /// compute the vector of quadrature points natural coordinates
   template <ElementType type>
   void computeQuadraturePoints(GhostType ghost_type);
 
   /// check that the jacobians are not negative
   template <ElementType type>
   void checkJacobians(GhostType ghost_type) const;
 
   /// internal integrate partially around a quadrature point (@f$ intf_q = f_q *
   /// J_q *
   /// w_q @f$)
   void integrateOnIntegrationPoints(const Array<Real> & in_f,
                                     Array<Real> & intf,
                                     Int nb_degree_of_freedom,
                                     const Array<Real> & jacobians,
                                     Int nb_element) const;
 
   void integrate(const Array<Real> & in_f, Array<Real> & intf,
                  Int nb_degree_of_freedom, const Array<Real> & jacobians,
                  Int nb_element) const;
 
 public:
   /// compute the jacobians on quad points for a given element
-  template <ElementType type>
-  void computeJacobianOnQuadPointsByElement(const Matrix<Real> & node_coords,
-                                            const Matrix<Real> & quad,
-                                            Vector<Real> & jacobians) const;
+  template <ElementType type, class D1, class D2, class D3>
+  inline void computeJacobianOnQuadPointsByElement(
+      const Eigen::MatrixBase<D1> & node_coords,
+      const Eigen::MatrixBase<D2> & quad,
+      Eigen::MatrixBase<D3> & jacobians) const;
 
 public:
   void onElementsAdded(const Array<Element> & elements) override;
 
   template <ElementType type>
   void onElementsAddedByType(const Array<Idx> & new_elements,
                              const GhostType & ghost_type);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// integrate the field f with the jacobian jac -> inte
-  inline void integrate(Real * f, Real * jac, Real * inte,
+  inline void integrate(const Real * f, const Real * jac, Real * inte,
                         Int nb_degree_of_freedom,
                         Int nb_quadrature_points) const;
 
 private:
   /// ElementTypeMap of the quadrature points
   ElementTypeMap<Matrix<Real>> quadrature_points;
 };
 
 } // namespace akantu
 
 #include "integrator_gauss_inline_impl.hh"
 
 #endif /* AKANTU_INTEGRATOR_GAUSS_HH_ */
diff --git a/src/fe_engine/integrator_gauss_inline_impl.hh b/src/fe_engine/integrator_gauss_inline_impl.hh
index 7d82717dc..064894301 100644
--- a/src/fe_engine/integrator_gauss_inline_impl.hh
+++ b/src/fe_engine/integrator_gauss_inline_impl.hh
@@ -1,752 +1,753 @@
 /**
  * @file   integrator_gauss_inline_impl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Feb 15 2011
  * @date last modification: Tue Oct 27 2020
  *
  * @brief  inline function of gauss integrator
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "fe_engine.hh"
 #include "mesh_iterators.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 namespace debug {
   struct IntegratorGaussException : public Exception {};
 } // namespace debug
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 inline void IntegratorGauss<kind, IntegrationOrderFunctor>::integrateOnElement(
     const Array<Real> & f, Real * intf, Int nb_degree_of_freedom,
     const Idx elem, const GhostType & ghost_type) const {
   auto & jac_loc = jacobians(type, ghost_type);
 
   auto nb_quadrature_points = ElementClass<type>::getNbQuadraturePoints();
   AKANTU_DEBUG_ASSERT(f.getNbComponent() == nb_degree_of_freedom,
                       "The vector f do not have the good number of component.");
 
   auto * f_val = f.data() + elem * f.getNbComponent();
   auto * jac_val = jac_loc.data() + elem * nb_quadrature_points;
 
   integrate(f_val, jac_val, intf, nb_degree_of_freedom, nb_quadrature_points);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 inline Real IntegratorGauss<kind, IntegrationOrderFunctor>::integrate(
     const Vector<Real> & in_f, Idx index, const GhostType & ghost_type) const {
   const Array<Real> & jac_loc = jacobians(type, ghost_type);
 
   auto nb_quadrature_points =
       GaussIntegrationElement<type>::getNbQuadraturePoints();
   AKANTU_DEBUG_ASSERT(in_f.size() == nb_quadrature_points,
                       "The vector f do not have nb_quadrature_points entries.");
 
   auto * jac_val = jac_loc.data() + index * nb_quadrature_points;
   Real intf;
 
   integrate(in_f.data(), jac_val, &intf, 1, nb_quadrature_points);
 
   return intf;
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 inline void IntegratorGauss<kind, IntegrationOrderFunctor>::integrate(
-    Real * f, Real * jac, Real * inte, Int nb_degree_of_freedom,
+    const Real * f, const Real * jac, Real * inte, Int nb_degree_of_freedom,
     Int nb_quadrature_points) const {
-  std::fill_n(inte, nb_degree_of_freedom, 0.);
-
-  auto * cjac = jac;
-  for (Int q = 0; q < nb_quadrature_points; ++q) {
-    for (Int dof = 0; dof < nb_degree_of_freedom; ++dof) {
-      inte[dof] += *f * *cjac;
-      ++f;
-    }
-    ++cjac;
-  }
+  Eigen::Map<VectorXr> inte_v(inte, nb_quadrature_points);
+  Eigen::Map<const VectorXr> cjac(jac, nb_quadrature_points);
+
+  Eigen::Map<const MatrixXr> fq(f, nb_degree_of_freedom, nb_quadrature_points);
+
+  inte_v.zero();
+  inte_v = fq * cjac;
+  // auto * cjac = jac;
+  // for (Int q = 0; q < nb_quadrature_points; ++q) {
+  //   for (Int dof = 0; dof < nb_degree_of_freedom; ++dof) {
+  //     inte[dof] += *f * *cjac;
+  //     ++f;
+  //   }
+  //   ++cjac;
+  // }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 inline const Matrix<Real> &
 IntegratorGauss<kind, IntegrationOrderFunctor>::getIntegrationPoints(
     GhostType ghost_type) const {
   AKANTU_DEBUG_ASSERT(
       quadrature_points.exists(type, ghost_type),
       "Quadrature points for type "
           << quadrature_points.printType(type, ghost_type)
           << " have not been initialized."
           << " Did you use 'computeQuadraturePoints' function ?");
   return quadrature_points(type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 inline Int
 IntegratorGauss<kind, IntegrationOrderFunctor>::getNbIntegrationPoints(
     GhostType ghost_type) const {
   AKANTU_DEBUG_ASSERT(
       quadrature_points.exists(type, ghost_type),
       "Quadrature points for type "
           << quadrature_points.printType(type, ghost_type)
           << " have not been initialized."
           << " Did you use 'computeQuadraturePoints' function ?");
   return quadrature_points(type, ghost_type).cols();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type, Int polynomial_degree>
 inline Matrix<Real>
 IntegratorGauss<kind, IntegrationOrderFunctor>::getIntegrationPoints() const {
   return GaussIntegrationElement<type,
                                  polynomial_degree>::getQuadraturePoints();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type, Int polynomial_degree>
 inline Vector<Real>
 IntegratorGauss<kind, IntegrationOrderFunctor>::getIntegrationWeights() const {
   return GaussIntegrationElement<type, polynomial_degree>::getWeights();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 inline void
 IntegratorGauss<kind, IntegrationOrderFunctor>::computeQuadraturePoints(
     GhostType ghost_type) {
   Matrix<Real> & quads = quadrature_points(type, ghost_type);
   const Int polynomial_degree =
       IntegrationOrderFunctor::template getOrder<type>();
   quads =
       GaussIntegrationElement<type, polynomial_degree>::getQuadraturePoints();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
-template <ElementType type>
+template <ElementType type, class D1, class D2, class D3>
 inline void IntegratorGauss<kind, IntegrationOrderFunctor>::
-    computeJacobianOnQuadPointsByElement(const Matrix<Real> & node_coords,
-                                         const Matrix<Real> & quad,
-                                         Vector<Real> & jacobians) const {
+    computeJacobianOnQuadPointsByElement(
+        const Eigen::MatrixBase<D1> & node_coords,
+        const Eigen::MatrixBase<D2> & quad,
+        Eigen::MatrixBase<D3> & jacobians) const {
   // jacobian
   ElementClass<type>::computeJacobian(quad, node_coords, jacobians);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 IntegratorGauss<kind, IntegrationOrderFunctor>::IntegratorGauss(
     const Mesh & mesh, Int spatial_dimension, const ID & id)
     : Integrator(mesh, spatial_dimension, id) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::checkJacobians(
     GhostType ghost_type) const {
   AKANTU_DEBUG_IN();
 
   Int nb_quadrature_points = this->quadrature_points(type, ghost_type).cols();
   Int nb_element = mesh.getConnectivity(type, ghost_type).size();
   Real * jacobians_val = jacobians(type, ghost_type).data();
 
   for (Idx i = 0; i < nb_element * nb_quadrature_points;
        ++i, ++jacobians_val) {
     if (*jacobians_val < 0) {
       AKANTU_CUSTOM_EXCEPTION_INFO(debug::IntegratorGaussException{},
                                    "Negative jacobian computed,"
                                        << " possible problem in the element "
                                           "node ordering (Quadrature Point "
                                        << i % nb_quadrature_points << ":"
                                        << i / nb_quadrature_points << ":"
                                        << type << ":" << ghost_type << ")");
     }
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::
     computeJacobiansOnIntegrationPoints(
         const Array<Real> & nodes, const Matrix<Real> & quad_points,
         Array<Real> & jacobians, const GhostType & ghost_type,
         const Array<Idx> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   auto spatial_dimension = mesh.getSpatialDimension();
   auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   auto nb_quadrature_points = quad_points.cols();
   auto nb_element = mesh.getNbElement(type, ghost_type);
 
   jacobians.resize(nb_element * nb_quadrature_points);
 
   auto jacobians_it = make_view(jacobians, nb_quadrature_points).begin();
   auto jacobians_begin = jacobians_it;
 
   Array<Real> x_el(0, spatial_dimension * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, nodes, x_el, type, ghost_type,
                                        filter_elements);
 
   auto x_it = make_view(x_el, spatial_dimension, nb_nodes_per_element).begin();
 
   nb_element = x_el.size();
 
   //  Matrix<Real> local_coord(spatial_dimension, nb_nodes_per_element);
   for (Idx elem = 0; elem < nb_element; ++elem, ++x_it) {
     const auto & x = *x_it;
     if (filter_elements != empty_filter) {
       jacobians_it = jacobians_begin + filter_elements(elem);
     }
 
-    auto & J = *jacobians_it;
-    computeJacobianOnQuadPointsByElement<type>(x, quad_points, J);
+    computeJacobianOnQuadPointsByElement<type>(x, quad_points, *jacobians_it);
 
     if (filter_elements == empty_filter) {
       ++jacobians_it;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
 template <>
 template <ElementType type>
 void IntegratorGauss<_ek_structural, DefaultIntegrationOrderFunctor>::
     computeJacobiansOnIntegrationPoints(
         const Array<Real> & nodes, const Matrix<Real> & quad_points,
         Array<Real> & jacobians, const GhostType & ghost_type,
         const Array<Int> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   const auto spatial_dimension = mesh.getSpatialDimension();
   const auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   const auto nb_quadrature_points = quad_points.cols();
   const auto nb_dofs = ElementClass<type>::getNbDegreeOfFreedom();
 
   auto nb_element = mesh.getNbElement(type, ghost_type);
   jacobians.resize(nb_element * nb_quadrature_points);
 
   auto jacobians_it = make_view(jacobians, nb_quadrature_points).begin();
   auto jacobians_begin = jacobians_it;
 
   Array<Real> x_el(0, spatial_dimension * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, nodes, x_el, type, ghost_type,
                                        filter_elements);
 
   auto x_it = make_view(x_el, spatial_dimension, nb_nodes_per_element).begin();
 
   nb_element = x_el.size();
 
   const auto has_extra_normal =
       mesh.hasData<Real>("extra_normal", type, ghost_type);
   Array<Real>::const_vector_iterator extra_normal;
   Array<Real>::const_vector_iterator extra_normal_begin;
   if (has_extra_normal) {
     extra_normal = mesh.getData<Real>("extra_normal", type, ghost_type)
                        .begin(spatial_dimension);
     extra_normal_begin = extra_normal;
   }
 
   //  Matrix<Real> local_coord(spatial_dimension, nb_nodes_per_element);
   for (Idx elem = 0; elem < nb_element; ++elem, ++x_it) {
     if (filter_elements != empty_filter) {
       jacobians_it = jacobians_begin + filter_elements(elem);
       extra_normal = extra_normal_begin + filter_elements(elem);
     }
 
     const auto & X = *x_it;
     auto & J = *jacobians_it;
     Matrix<Real> R(nb_dofs, nb_dofs);
 
     if (has_extra_normal) {
       ElementClass<type>::computeRotationMatrix(R, X, *extra_normal);
     } else {
       ElementClass<type>::computeRotationMatrix(R, X, Vector<Real>(X.rows()));
     }
     // Extracting relevant lines
     auto x = (R.block(0, 0, spatial_dimension, spatial_dimension) * X)
                  .block(0, 0, ElementClass<type>::getNaturalSpaceDimension(),
                         ElementClass<type>::getNbNodesPerElement());
 
     computeJacobianOnQuadPointsByElement<type>(x, quad_points, J);
 
     if (filter_elements == empty_filter) {
       ++jacobians_it;
       ++extra_normal;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_COHESIVE_ELEMENT)
 template <>
 template <ElementType type>
 void IntegratorGauss<_ek_cohesive, DefaultIntegrationOrderFunctor>::
     computeJacobiansOnIntegrationPoints(
         const Array<Real> & nodes, const Matrix<Real> & quad_points,
         Array<Real> & jacobians, const GhostType & ghost_type,
         const Array<Int> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   auto spatial_dimension = mesh.getSpatialDimension();
   auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   auto nb_quadrature_points = quad_points.cols();
   auto nb_element = mesh.getNbElement(type, ghost_type);
 
   jacobians.resize(nb_element * nb_quadrature_points);
 
   auto jacobians_begin = make_view(jacobians, nb_quadrature_points).begin();
 
   Array<Real> x_el(0, spatial_dimension * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, nodes, x_el, type, ghost_type,
                                        filter_elements);
 
   auto x_it = make_view(x_el, spatial_dimension, nb_nodes_per_element).begin();
 
   auto nb_nodes_per_subelement = nb_nodes_per_element / 2;
   Matrix<Real> x(spatial_dimension, nb_nodes_per_subelement);
 
   nb_element = x_el.size();
   Idx l_el = 0;
 
   auto compute = [&](const auto & el) {
     auto && J = jacobians_begin[el];
     auto && X = x_it[l_el];
     ++l_el;
 
     for (Int n = 0; n < nb_nodes_per_subelement; ++n)
       x(n) = (X(n) + X(n + nb_nodes_per_subelement)) / 2.;
 
     if (type == _cohesive_1d_2) {
       J(0) = 1;
     } else {
       this->computeJacobianOnQuadPointsByElement<type>(x, quad_points, J);
     }
   };
 
   for_each_element(nb_element, filter_elements, compute);
 
   AKANTU_DEBUG_OUT();
 }
 #endif
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::
     precomputeJacobiansOnQuadraturePoints(const Array<Real> & nodes,
                                           GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Array<Real> & jacobians_tmp = jacobians.alloc(0, 1, type, ghost_type);
 
   this->computeJacobiansOnIntegrationPoints<type>(
       nodes, quadrature_points(type, ghost_type), jacobians_tmp, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type, Int polynomial_degree>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::multiplyJacobiansByWeights(
     Array<Real> & jacobians, const Array<Int> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
-  auto nb_quadrature_points =
+  constexpr auto nb_quadrature_points =
       GaussIntegrationElement<type, polynomial_degree>::getNbQuadraturePoints();
 
   auto weights = GaussIntegrationElement<type, polynomial_degree>::getWeights();
 
-  auto && view = make_view(jacobians, nb_quadrature_points);
+  auto && view = make_view<nb_quadrature_points>(jacobians);
 
   if (filter_elements != empty_filter) {
-    auto J_it = view.begin();
-    for (auto el : filter_elements) {
-      auto && J = J_it[el];
-      J *= weights;
-    }
+    for (auto && J : filter(filter_elements, view))
+      J.array() *= weights.array();
   } else {
-    for (auto & J : make_view(jacobians, nb_quadrature_points)) {
-      J *= weights;
-    }
+    for (auto && J : view)
+      J.array() *= weights.array();
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::integrate(
     const Array<Real> & in_f, Array<Real> & intf, Int nb_degree_of_freedom,
     const Array<Real> & jacobians, Int nb_element) const {
   AKANTU_DEBUG_IN();
 
   intf.resize(nb_element);
   if (nb_element == 0) {
     return;
   }
 
   auto nb_points = jacobians.size() / nb_element;
 
   for (auto && data : zip(make_view(in_f, nb_degree_of_freedom, nb_points),
                           make_view(intf, nb_degree_of_freedom),
                           make_view(jacobians, nb_points))) {
     auto && inte_f = std::get<0>(data);
     auto && f = std::get<1>(data);
     auto && J = std::get<2>(data);
 
     inte_f = f * J;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::integrate(
     const Array<Real> & in_f, Array<Real> & intf, Int nb_degree_of_freedom,
     const GhostType & ghost_type, const Array<Int> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(jacobians.exists(type, ghost_type),
                       "No jacobians for the type "
                           << jacobians.printType(type, ghost_type));
 
   const auto & jac_loc = jacobians(type, ghost_type);
   if (filter_elements != empty_filter) {
     auto nb_element = filter_elements.size();
     auto filtered_J =
         std::make_shared<Array<Real>>(0, jac_loc.getNbComponent());
     FEEngine::filterElementalData(mesh, jac_loc, *filtered_J, type, ghost_type,
                                   filter_elements);
     this->integrate(in_f, intf, nb_degree_of_freedom, *filtered_J, nb_element);
   } else {
     auto nb_element = mesh.getNbElement(type, ghost_type);
     this->integrate(in_f, intf, nb_degree_of_freedom, jac_loc, nb_element);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type, Int polynomial_degree>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::integrate(
     const Array<Real> & in_f, Array<Real> & intf, Int nb_degree_of_freedom,
     const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   auto quads = this->getIntegrationPoints<type, polynomial_degree>();
 
   Array<Real> jacobians;
   this->computeJacobiansOnIntegrationPoints<type>(mesh.getNodes(), quads,
                                                   jacobians, ghost_type);
   this->multiplyJacobiansByWeights<type, polynomial_degree>(jacobians);
 
   this->integrate(in_f, intf, nb_degree_of_freedom, jacobians,
                   mesh.getNbElement(type, ghost_type));
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type, Int polynomial_degree>
 Real IntegratorGauss<kind, IntegrationOrderFunctor>::integrate(
     const Array<Real> & in_f, GhostType ghost_type) const {
   AKANTU_DEBUG_IN();
 
   Array<Real> intfv(0, 1);
   integrate<type, polynomial_degree>(in_f, intfv, 1, ghost_type);
 
   auto res = Math::reduce(intfv);
 
   AKANTU_DEBUG_OUT();
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 Real IntegratorGauss<kind, IntegrationOrderFunctor>::integrate(
     const Array<Real> & in_f, const GhostType & ghost_type,
     const Array<Int> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(jacobians.exists(type, ghost_type),
                       "No jacobians for the type "
                           << jacobians.printType(type, ghost_type));
 
   Array<Real> intfv(0, 1);
   integrate<type>(in_f, intfv, 1, ghost_type, filter_elements);
 
   auto res = Math::reduce(intfv);
 
   AKANTU_DEBUG_OUT();
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::
     integrateOnIntegrationPoints(const Array<Real> & in_f, Array<Real> & intf,
                                  Int nb_degree_of_freedom,
                                  const Array<Real> & jacobians,
                                  Int nb_element) const {
   AKANTU_DEBUG_IN();
 
   auto nb_points = jacobians.size() / nb_element;
 
   intf.resize(nb_element * nb_points);
 
   auto J_it = jacobians.begin();
   auto f_it = in_f.begin(nb_degree_of_freedom);
   auto inte_it = intf.begin(nb_degree_of_freedom);
 
   for (Idx el = 0; el < nb_element; ++el, ++J_it, ++f_it, ++inte_it) {
     const auto & J = *J_it;
     const auto & f = *f_it;
     auto & inte_f = *inte_it;
 
     inte_f = f;
     inte_f *= J;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::
     integrateOnIntegrationPoints(const Array<Real> & in_f, Array<Real> & intf,
                                  Int nb_degree_of_freedom,
                                  const GhostType & ghost_type,
                                  const Array<Int> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(jacobians.exists(type, ghost_type),
                       "No jacobians for the type "
                           << jacobians.printType(type, ghost_type));
 
   const auto & jac_loc = this->jacobians(type, ghost_type);
 
   if (filter_elements != empty_filter) {
 
     auto nb_element = filter_elements.size();
     auto filtered_J =
         std::make_shared<Array<Real>>(0, jac_loc.getNbComponent());
     FEEngine::filterElementalData(mesh, jac_loc, *filtered_J, type, ghost_type,
                                   filter_elements);
 
     this->integrateOnIntegrationPoints(in_f, intf, nb_degree_of_freedom,
                                        *filtered_J, nb_element);
   } else {
     auto nb_element = mesh.getNbElement(type, ghost_type);
     this->integrateOnIntegrationPoints(in_f, intf, nb_degree_of_freedom,
                                        jac_loc, nb_element);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 inline void
 IntegratorGauss<kind, IntegrationOrderFunctor>::onElementsAddedByType(
     const Array<Idx> & elements, const GhostType & ghost_type) {
   const auto & nodes = mesh.getNodes();
 
   if (not quadrature_points.exists(type, ghost_type)) {
     computeQuadraturePoints<type>(ghost_type);
   }
 
   if (not jacobians.exists(type, ghost_type)) {
     jacobians.alloc(0, 1, type, ghost_type);
   }
 
   this->computeJacobiansOnIntegrationPoints(
       nodes, quadrature_points(type, ghost_type), jacobians(type, ghost_type),
       type, ghost_type, elements);
 
   constexpr auto polynomial_degree =
       IntegrationOrderFunctor::template getOrder<type>();
 
   multiplyJacobiansByWeights<type, polynomial_degree>(
       this->jacobians(type, ghost_type), elements);
 }
 
 /* -------------------------------------------------------------------------- */
 namespace integrator {
   namespace details {
     template <ElementKind kind> struct IntegratorOnElementsAddedHelper {};
 
 #define ON_ELEMENT_ADDED(type)                                                 \
   integrator.template onElementsAddedByType<type>(elements, ghost_type);
 
 #define AKANTU_SPECIALIZE_ON_ELEMENT_ADDED_HELPER(kind)                        \
   template <> struct IntegratorOnElementsAddedHelper<kind> {                   \
     template <class I>                                                         \
     static void call(I & integrator, const Array<Idx> & elements,              \
                      const ElementType & type, const GhostType & ghost_type) { \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(ON_ELEMENT_ADDED, kind);                \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_ON_ELEMENT_ADDED_HELPER)
 
 #undef AKANTU_SPECIALIZE_ON_ELEMENT_ADDED_HELPER
 #undef ON_ELEMENT_ADDED
   } // namespace details
 } // namespace integrator
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::onElementsAdded(
     const Array<Element> & new_elements) {
   for (auto elements_range : MeshElementsByTypes(new_elements)) {
     auto type = elements_range.getType();
     auto ghost_type = elements_range.getGhostType();
 
     if (mesh.getSpatialDimension(type) != _spatial_dimension) {
       continue;
     }
 
     if (mesh.getKind(type) != kind) {
       continue;
     }
 
     integrator::details::IntegratorOnElementsAddedHelper<kind>::call(
         *this, elements_range.getElements(), type, ghost_type);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 inline void IntegratorGauss<kind, IntegrationOrderFunctor>::initIntegrator(
     const Array<Real> & nodes, GhostType ghost_type) {
   computeQuadraturePoints<type>(ghost_type);
   precomputeJacobiansOnQuadraturePoints<type>(nodes, ghost_type);
   checkJacobians<type>(ghost_type);
   constexpr auto polynomial_degree =
       IntegrationOrderFunctor::template getOrder<type>();
   multiplyJacobiansByWeights<type, polynomial_degree>(
       this->jacobians(type, ghost_type));
 }
 
 namespace integrator {
   namespace details {
     template <ElementKind kind> struct GaussIntegratorInitHelper {};
 
 #define INIT_INTEGRATOR(type)                                                  \
   _int.template initIntegrator<type>(nodes, ghost_type)
 
 #define AKANTU_GAUSS_INTERGRATOR_INIT_HELPER(kind)                             \
   template <> struct GaussIntegratorInitHelper<kind> {                         \
     template <ElementKind k, class IOF>                                        \
     static void call(IntegratorGauss<k, IOF> & _int,                           \
                      const Array<Real> & nodes, ElementType type,              \
                      GhostType ghost_type) {                                   \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INIT_INTEGRATOR, kind);                 \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_GAUSS_INTERGRATOR_INIT_HELPER)
 
 #undef AKANTU_GAUSS_INTERGRATOR_INIT_HELPER
 #undef INIT_INTEGRATOR
   } // namespace details
 } // namespace integrator
 
 template <ElementKind kind, class IntegrationOrderFunctor>
 inline void IntegratorGauss<kind, IntegrationOrderFunctor>::initIntegrator(
     const Array<Real> & nodes, ElementType type, GhostType ghost_type) {
   integrator::details::GaussIntegratorInitHelper<kind>::call(*this, nodes, type,
                                                              ghost_type);
 }
 
 namespace integrator {
   namespace details {
     template <ElementKind kind> struct GaussIntegratorComputeJacobiansHelper {};
 
 #define AKANTU_COMPUTE_JACOBIANS(type)                                         \
   _int.template computeJacobiansOnIntegrationPoints<type>(                     \
       nodes, quad_points, jacobians, ghost_type, filter_elements);
 
 #define AKANTU_GAUSS_INTERGRATOR_COMPUTE_JACOBIANS(kind)                       \
   template <> struct GaussIntegratorComputeJacobiansHelper<kind> {             \
     template <ElementKind k, class IOF>                                        \
     static void                                                                \
     call(const IntegratorGauss<k, IOF> & _int, const Array<Real> & nodes,      \
          const Matrix<Real> & quad_points, Array<Real> & jacobians,            \
          const ElementType & type, const GhostType & ghost_type,               \
          const Array<Idx> & filter_elements) {                                 \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(AKANTU_COMPUTE_JACOBIANS, kind);        \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_GAUSS_INTERGRATOR_COMPUTE_JACOBIANS)
 
 #undef AKANTU_GAUSS_INTERGRATOR_COMPUTE_JACOBIANS
 #undef AKANTU_COMPUTE_JACOBIANS
   } // namespace details
 } // namespace integrator
 
 template <ElementKind kind, class IntegrationOrderFunctor>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::
     computeJacobiansOnIntegrationPoints(
         const Array<Real> & nodes, const Matrix<Real> & quad_points,
         Array<Real> & jacobians, const ElementType & type,
         const GhostType & ghost_type,
         const Array<Idx> & filter_elements) const {
   integrator::details::GaussIntegratorComputeJacobiansHelper<kind>::call(
       *this, nodes, quad_points, jacobians, type, ghost_type, filter_elements);
 }
 
 } // namespace akantu
diff --git a/src/fe_engine/shape_cohesive.hh b/src/fe_engine/shape_cohesive.hh
index 7de18e8e2..c61756f23 100644
--- a/src/fe_engine/shape_cohesive.hh
+++ b/src/fe_engine/shape_cohesive.hh
@@ -1,193 +1,194 @@
 /**
  * @file   shape_cohesive.hh
  *
  * @author Mohit Pundir <mohit.pundir@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: Fri May 14 2021
  *
  * @brief  shape functions for cohesive elements description
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "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) {
+  template <typename T1, typename T2>
+  inline decltype(auto) operator()(T1 u_plus, T2 u_minus) {
     return .5 * (u_plus + u_minus);
   }
 };
 
 struct CohesiveReduceFunctionOpening {
-  inline Real operator()(Real u_plus, Real u_minus) {
+  template <typename T1, typename T2>
+  inline decltype(auto) operator()(T1 u_plus, T2 u_minus) {
     return (u_plus - u_minus);
   }
 };
 
 template <> class ShapeLagrange<_ek_cohesive> : public ShapeLagrangeBase {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-  ShapeLagrange(const Mesh & mesh, UInt spatial_dimension,
+  ShapeLagrange(const Mesh & mesh, Int spatial_dimension,
                 const ID & id = "shape_cohesive");
 
   ~ShapeLagrange() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   inline void initShapeFunctions(const Array<Real> & nodes,
                                  const Ref<const MatrixXr> & integration_points,
                                  ElementType type,
                                  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<Int> & filter_elements = empty_filter) const;
+      const Array<Idx> & filter_elements = empty_filter) const;
 
   /// computes the shape functions derivatives for given interpolation points
   template <ElementType type>
   void computeShapeDerivativesOnIntegrationPoints(
       const Array<Real> & nodes, const Ref<const MatrixXr> & integration_points,
       Array<Real> & shape_derivatives, const GhostType & ghost_type,
-      const Array<Int> & filter_elements = empty_filter) const;
+      const Array<Idx> & filter_elements = empty_filter) const;
 
   void computeShapeDerivativesOnIntegrationPoints(
       const Array<Real> & nodes, const Ref<const MatrixXr> & integration_points,
       Array<Real> & shape_derivatives, const ElementType & type,
       const GhostType & ghost_type,
-      const Array<Int> & filter_elements) const override;
+      const Array<Idx> & 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 Array<Real> & u, Array<Real> & uq, Int nb_degree_of_freedom,
       const GhostType ghost_type = _not_ghost,
-      const Array<Int> & filter_elements = empty_filter) const;
+      const Array<Idx> & filter_elements = empty_filter) const;
 
   template <ElementType type>
   void interpolateOnIntegrationPoints(
-      const Array<Real> & u, Array<Real> & uq, UInt nb_degree_of_freedom,
+      const Array<Real> & u, Array<Real> & uq, Int nb_degree_of_freedom,
       const GhostType ghost_type = _not_ghost,
-      const Array<Int> & filter_elements = empty_filter) const {
+      const Array<Idx> & 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,
+      const Array<Real> & u, Array<Real> & nablauq, Int nb_degree_of_freedom,
       GhostType ghost_type = _not_ghost,
-      const Array<Int> & filter_elements = empty_filter) const {
+      const Array<Idx> & 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 {
+                  const Array<Idx> & /*filter_elements*/) const {
     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 {
+                   Int /*order_d*/, GhostType /*ghost_type*/,
+                   const Array<Idx> & /*filter_elements*/) const {
     AKANTU_TO_IMPLEMENT();
   }
 
   /// multiply a field by shape functions
   template <ElementType type>
-  void
-  computeNtb(const Array<Real> & /*bs*/, Array<Real> & /*Ntbs*/,
-             GhostType /*ghost_type*/,
-             const Array<UInt> & /*filter_elements*/ = empty_filter) const {
+  void computeNtb(const Array<Real> & /*bs*/, Array<Real> & /*Ntbs*/,
+                  const GhostType & /*ghost_type*/,
+                  const Array<Idx> & /*filter_elements*/ = empty_filter) const {
     AKANTU_TO_IMPLEMENT();
   }
 
   template <ElementType type>
   void computeNtbN(const Array<Real> & /*bs*/, Array<Real> & /*NtbNs*/,
                    GhostType /*ghost_type*/,
                    const Array<UInt> & /*filter_elements*/) const {
     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,
+      const Array<Real> & u, Array<Real> & nablauq, Int nb_degree_of_freedom,
       GhostType ghost_type = _not_ghost,
-      const Array<Int> & filter_elements = empty_filter) const;
+      const Array<Idx> & 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<Int> & filter_elements = empty_filter) const;
+      const Array<Idx> & filter_elements = empty_filter) const;
 };
 
 /// 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.hh"
 
 #endif /* AKANTU_SHAPE_COHESIVE_HH_ */
diff --git a/src/fe_engine/shape_cohesive_inline_impl.hh b/src/fe_engine/shape_cohesive_inline_impl.hh
index f481b8d1d..82e055772 100644
--- a/src/fe_engine/shape_cohesive_inline_impl.hh
+++ b/src/fe_engine/shape_cohesive_inline_impl.hh
@@ -1,332 +1,332 @@
 /**
  * @file   shape_cohesive_inline_impl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Feb 03 2012
  * @date last modification: Tue Sep 29 2020
  *
  * @brief  ShapeCohesive inline implementation
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "mesh_iterators.hh"
 //#include "shape_cohesive.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_SHAPE_COHESIVE_INLINE_IMPL_HH_
 #define AKANTU_SHAPE_COHESIVE_INLINE_IMPL_HH_
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline ShapeLagrange<_ek_cohesive>::ShapeLagrange(const Mesh & mesh,
-                                                  UInt spatial_dimension,
+                                                  Int spatial_dimension,
                                                   const ID & id)
     : ShapeLagrangeBase(mesh, spatial_dimension, _ek_cohesive, id) {}
 
 #define INIT_SHAPE_FUNCTIONS(type)                                             \
   setIntegrationPointsByType<type>(integration_points, ghost_type);            \
   precomputeShapesOnIntegrationPoints<type>(nodes, ghost_type);                \
   precomputeShapeDerivativesOnIntegrationPoints<type>(nodes, ghost_type);
 
 /* -------------------------------------------------------------------------- */
 inline void ShapeLagrange<_ek_cohesive>::initShapeFunctions(
     const Array<Real> & nodes, const Ref<const MatrixXr> & integration_points,
     ElementType type, GhostType ghost_type) {
   AKANTU_BOOST_COHESIVE_ELEMENT_SWITCH(INIT_SHAPE_FUNCTIONS);
 }
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void ShapeLagrange<_ek_cohesive>::computeShapeDerivativesOnIntegrationPoints(
     const Array<Real> &, const Ref<const MatrixXr> & integration_points,
     Array<Real> & shape_derivatives, const GhostType & ghost_type,
-    const Array<Int> & filter_elements) const {
+    const Array<Idx> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   auto size_of_shapesd = ElementClass<type>::getShapeDerivativesSize();
   auto spatial_dimension = ElementClass<type>::getNaturalSpaceDimension();
   auto nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
 
   auto nb_points = integration_points.cols();
   auto nb_element = mesh.getConnectivity(type, ghost_type).size();
 
   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);
   auto * shapesd_val = shape_derivatives.data();
 
   auto compute = [&](const auto & el) {
     auto ptr = shapesd_val + el * nb_points * size_of_shapesd;
     Tensor3Proxy<Real> B(ptr, spatial_dimension, nb_nodes_per_element,
                          nb_points);
     ElementClass<type>::computeDNDS(integration_points, B);
   };
 
   for_each_element(nb_element, filter_elements, compute);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 inline void
 ShapeLagrange<_ek_cohesive>::computeShapeDerivativesOnIntegrationPoints(
     const Array<Real> & nodes, const Ref<const MatrixXr> & integration_points,
     Array<Real> & shape_derivatives, const ElementType & type,
-    const GhostType & ghost_type, const Array<Int> & filter_elements) const {
+    const GhostType & ghost_type, const Array<Idx> & filter_elements) const {
 #define AKANTU_COMPUTE_SHAPES(type)                                            \
   computeShapeDerivativesOnIntegrationPoints<type>(                            \
       nodes, integration_points, shape_derivatives, ghost_type,                \
       filter_elements);
 
   AKANTU_BOOST_COHESIVE_ELEMENT_SWITCH(AKANTU_COMPUTE_SHAPES);
 
 #undef AKANTU_COMPUTE_SHAPES
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void ShapeLagrange<_ek_cohesive>::precomputeShapesOnIntegrationPoints(
     const Array<Real> & nodes, 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();
+  auto itp_type = ElementClassProperty<type>::interpolation_type;
+  auto & natural_coords = integration_points(type, ghost_type);
+  auto size_of_shapes = ElementClass<type>::getShapeSize();
 
-  Array<Real> & shapes_tmp =
+  auto & 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 <ElementType type>
 void ShapeLagrange<_ek_cohesive>::precomputeShapeDerivativesOnIntegrationPoints(
     const Array<Real> & nodes, 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();
+  auto itp_type = ElementClassProperty<type>::interpolation_type;
+  auto & natural_coords = integration_points(type, ghost_type);
+  auto size_of_shapesd = ElementClass<type>::getShapeDerivativesSize();
 
-  Array<Real> & shapes_derivatives_tmp =
+  auto & 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 <ElementType type, class ReduceFunction>
 void ShapeLagrange<_ek_cohesive>::extractNodalToElementField(
     const Array<Real> & nodal_f, Array<Real> & elemental_f,
-    const GhostType & ghost_type, const Array<Int> & filter_elements) const {
+    const GhostType & ghost_type, const Array<Idx> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
-  UInt nb_nodes_per_itp_element =
+  auto nb_nodes_per_itp_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
-  UInt nb_degree_of_freedom = nodal_f.getNbComponent();
-  UInt nb_element = this->mesh.getNbElement(type, ghost_type);
+  auto nb_degree_of_freedom = nodal_f.getNbComponent();
+  auto nb_element = this->mesh.getNbElement(type, ghost_type);
 
   const auto & conn_array = this->mesh.getConnectivity(type, ghost_type);
-  auto conn = conn_array.begin(conn_array.getNbComponent() / 2, 2);
+  auto conn = make_view(conn_array, conn_array.getNbComponent() / 2, 2).begin();
 
   if (filter_elements != empty_filter) {
     nb_element = filter_elements.size();
   }
 
   elemental_f.resize(nb_element);
 
-  Array<Real>::matrix_iterator u_it =
-      elemental_f.begin(nb_degree_of_freedom, nb_nodes_per_itp_element);
+  auto u_it =
+      make_view(elemental_f, nb_degree_of_freedom, nb_nodes_per_itp_element).begin();
+
+  auto nodal_f_it =
+      make_view(nodal_f, nb_degree_of_freedom).begin();
 
   ReduceFunction reduce_function;
 
   auto compute = [&](const auto & el) {
     auto && u = *u_it;
-    Matrix<UInt> el_conn(conn[el]);
+    auto && el_conn = conn[el];
 
     // compute the average/difference of the nodal field loaded from cohesive
     // element
     for (Int n = 0; n < el_conn.rows(); ++n) {
-      UInt node_plus = el_conn(n, 0);
-      UInt node_minus = el_conn(n, 1);
-      for (UInt d = 0; d < nb_degree_of_freedom; ++d) {
-        Real u_plus = nodal_f(node_plus, d);
-        Real u_minus = nodal_f(node_minus, d);
-        u(d, n) = reduce_function(u_plus, u_minus);
-      }
+      auto node_plus = el_conn(n, 0);
+      auto node_minus = el_conn(n, 1);
+
+      u(n) = reduce_function(nodal_f_it[node_plus], nodal_f_it[node_minus]);
     }
 
     ++u_it;
   };
 
   for_each_element(nb_element, filter_elements, compute);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, class ReduceFunction>
 void ShapeLagrange<_ek_cohesive>::interpolateOnIntegrationPoints(
-    const Array<Real> & in_u, Array<Real> & out_uq, UInt nb_degree_of_freedom,
-    GhostType ghost_type, const Array<Int> & filter_elements) const {
+    const Array<Real> & in_u, Array<Real> & out_uq, Int nb_degree_of_freedom,
+    GhostType ghost_type, const Array<Idx> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
-  InterpolationType itp_type = ElementClassProperty<type>::interpolation_type;
+  auto itp_type = ElementClassProperty<type>::interpolation_type;
 
   AKANTU_DEBUG_ASSERT(this->shapes.exists(itp_type, ghost_type),
                       "No shapes for the type "
                           << this->shapes.printType(itp_type, ghost_type));
 
-  UInt nb_nodes_per_element =
+  auto nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
   Array<Real> u_el(0, nb_degree_of_freedom * nb_nodes_per_element);
   this->extractNodalToElementField<type, ReduceFunction>(in_u, u_el, ghost_type,
                                                          filter_elements);
 
   this->template interpolateElementalFieldOnIntegrationPoints<type>(
       u_el, out_uq, ghost_type, shapes(itp_type, ghost_type), filter_elements);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, class ReduceFunction>
 void ShapeLagrange<_ek_cohesive>::variationOnIntegrationPoints(
-    const Array<Real> & in_u, Array<Real> & nablauq, UInt nb_degree_of_freedom,
-    GhostType ghost_type, const Array<Int> & filter_elements) const {
+    const Array<Real> & in_u, Array<Real> & nablauq, Int nb_degree_of_freedom,
+    GhostType ghost_type, const Array<Idx> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   InterpolationType itp_type = ElementClassProperty<type>::interpolation_type;
 
   AKANTU_DEBUG_ASSERT(
       this->shapes_derivatives.exists(itp_type, ghost_type),
       "No shapes for the type "
           << this->shapes_derivatives.printType(itp_type, ghost_type));
 
-  UInt nb_nodes_per_element =
+  auto nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
   Array<Real> u_el(0, nb_degree_of_freedom * nb_nodes_per_element);
   this->extractNodalToElementField<type, ReduceFunction>(in_u, u_el, ghost_type,
                                                          filter_elements);
 
   this->template gradientElementalFieldOnIntegrationPoints<type>(
       u_el, nablauq, ghost_type, shapes_derivatives(itp_type, ghost_type),
       filter_elements);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, class ReduceFunction>
 void ShapeLagrange<_ek_cohesive>::computeNormalsOnIntegrationPoints(
     const Array<Real> & u, Array<Real> & normals_u, GhostType ghost_type,
-    const Array<Int> & filter_elements) const {
+    const Array<Idx> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
-  UInt nb_element = this->mesh.getNbElement(type, ghost_type);
-  UInt nb_points = this->integration_points(type, ghost_type).cols();
-  UInt spatial_dimension = this->mesh.getSpatialDimension();
+  auto nb_element = this->mesh.getNbElement(type, ghost_type);
+  auto nb_points = this->integration_points(type, ghost_type).cols();
+  auto spatial_dimension = this->mesh.getSpatialDimension();
 
   if (filter_elements != empty_filter) {
     nb_element = filter_elements.size();
   }
 
   normals_u.resize(nb_points * nb_element);
 
   Array<Real> tangents_u(0, (spatial_dimension * (spatial_dimension - 1)));
 
   if (spatial_dimension > 1) {
     tangents_u.resize(nb_element * nb_points);
     this->template variationOnIntegrationPoints<type, ReduceFunction>(
         u, tangents_u, spatial_dimension, ghost_type, filter_elements);
   }
 
   if (spatial_dimension == 3) {
     for (auto && data :
          zip(make_view<3>(normals_u), make_view<3, 2>(tangents_u))) {
       auto && n = std::get<0>(data);
       auto && ts = std::get<1>(data);
 
       n = (ts(0).cross(ts(1))).normalized();
     }
   } else if (spatial_dimension == 2) {
     for (auto && data :
          zip(make_view<2>(normals_u), make_view<2>(tangents_u))) {
       auto && n = std::get<0>(data);
       auto && t = std::get<1>(data);
 
       n(0) = -t(1);
       n(1) = t(0);
       n.normalize();
     }
   } else if (spatial_dimension == 1) {
     const auto facet_type = Mesh::getFacetType(type);
     const auto & mesh_facets = mesh.getMeshFacets();
     const auto & facets = mesh_facets.getSubelementToElement(type, ghost_type);
     const auto & segments =
         mesh_facets.getElementToSubelement(facet_type, ghost_type);
 
     Real values[2];
 
     for (auto el : arange(nb_element)) {
       if (filter_elements != empty_filter) {
         el = filter_elements(el);
       }
 
       for (UInt p = 0; p < 2; ++p) {
         Element facet = facets(el, p);
         Element segment = segments(facet.element)[0];
         VectorProxy<Real> barycenter(values + p, 1);
         mesh.getBarycenter(segment, barycenter);
       }
 
       Real difference = values[0] - values[1];
 
       AKANTU_DEBUG_ASSERT(difference != 0.,
                           "Error in normal computation for cohesive elements");
 
       normals_u(el) = difference / std::abs(difference);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
 
 #endif /* AKANTU_SHAPE_COHESIVE_INLINE_IMPL_HH_ */
diff --git a/src/fe_engine/shape_functions.cc b/src/fe_engine/shape_functions.cc
index 3fda21c5c..14604e6ab 100644
--- a/src/fe_engine/shape_functions.cc
+++ b/src/fe_engine/shape_functions.cc
@@ -1,238 +1,238 @@
 /**
  * @file   shape_functions.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Aug 09 2017
  * @date last modification: Tue Feb 09 2021
  *
  * @brief  implementation of th shape functions interface
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2016-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "shape_functions.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 ShapeFunctions::ShapeFunctions(const Mesh & mesh, UInt spatial_dimension,
                                const ID & id)
     : shapes("shapes_generic", id),
       shapes_derivatives("shapes_derivatives_generic", id),
       mesh(mesh), _spatial_dimension(spatial_dimension) {}
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 inline void
 ShapeFunctions::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<Idx> & element_filter) const {
 
   AKANTU_DEBUG_IN();
 
   auto spatial_dimension = this->mesh.getSpatialDimension();
   auto nb_element = this->mesh.getNbElement(type, ghost_type);
   decltype(nb_element) nb_element_filter;
 
   if (element_filter == empty_filter) {
     nb_element_filter = nb_element;
   } else {
     nb_element_filter = element_filter.size();
   }
 
   constexpr auto nb_quad_per_element =
       GaussIntegrationElement<type>::getNbQuadraturePoints();
   auto nb_interpolation_points_per_elem =
       interpolation_points_coordinates.size() / nb_element;
 
   AKANTU_DEBUG_ASSERT(interpolation_points_coordinates.size() % nb_element == 0,
                       "Number of interpolation points should be a multiple of "
                       "total number of elements");
 
   if (not quad_points_coordinates_inv_matrices.exists(type, ghost_type)) {
     quad_points_coordinates_inv_matrices.alloc(
         nb_element_filter, nb_quad_per_element * nb_quad_per_element, type,
         ghost_type);
   } else {
     quad_points_coordinates_inv_matrices(type, ghost_type)
         .resize(nb_element_filter);
   }
 
   if (!interpolation_points_coordinates_matrices.exists(type, ghost_type)) {
     interpolation_points_coordinates_matrices.alloc(
         nb_element_filter,
         nb_interpolation_points_per_elem * nb_quad_per_element, type,
         ghost_type);
   } else {
     interpolation_points_coordinates_matrices(type, ghost_type)
         .resize(nb_element_filter);
   }
 
   auto & quad_inv_mat = quad_points_coordinates_inv_matrices(type, ghost_type);
   auto & interp_points_mat =
       interpolation_points_coordinates_matrices(type, ghost_type);
 
   Matrix<Real, nb_quad_per_element, nb_quad_per_element> quad_coord_matrix;
 
   auto points_coords_begin =
       make_view(interpolation_points_coordinates, spatial_dimension,
                 nb_interpolation_points_per_elem)
           .begin();
 
   /// loop over the elements of the current material and element type
   for (auto && data :
        zip(element_filter,
            make_view<nb_quad_per_element, nb_quad_per_element>(quad_inv_mat),
            make_view(interp_points_mat, nb_interpolation_points_per_elem,
                      nb_quad_per_element),
            make_view(quadrature_points_coordinates, spatial_dimension,
                      nb_quad_per_element))) {
 
     auto element = std::get<0>(data);
     /// matrix to store the matrix inversion result
     auto & inv_quad_coord_matrix = std::get<1>(data);
     /// matrix to store the interpolation points coordinates
     /// compatible with these functions
     auto & inv_points_coord_matrix = std::get<2>(data);
     /// matrix containing the quadrature points coordinates
     auto & quad_coords = std::get<3>(data);
     /// matrix containing the interpolation points coordinates
-    auto & points_coords = points_coords_begin[element];
+    auto && points_coords = points_coords_begin[element];
 
     /// insert the quad coordinates in a matrix compatible with the
     /// interpolation
     buildElementalFieldInterpolationMatrix<type>(quad_coords,
                                                  quad_coord_matrix);
 
     /// invert the interpolation matrix
     inv_quad_coord_matrix = quad_coord_matrix.inverse();
 
     /// insert the quad coordinates in a matrix compatible with the
     /// interpolation
     buildElementalFieldInterpolationMatrix<type>(points_coords,
                                                  inv_points_coord_matrix);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ShapeFunctions::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<Idx> * element_filter) const {
 
   AKANTU_DEBUG_IN();
 
   auto spatial_dimension = this->mesh.getSpatialDimension();
 
   for (auto ghost_type : ghost_types) {
     auto types_iterable = mesh.elementTypes(spatial_dimension, ghost_type);
     if (element_filter != nullptr) {
       types_iterable =
           element_filter->elementTypes(spatial_dimension, ghost_type);
     }
 
     for (auto type : types_iterable) {
       auto nb_element = mesh.getNbElement(type, ghost_type);
       if (nb_element == 0) {
         continue;
       }
 
       const Array<Idx> * elem_filter;
       if (element_filter != nullptr) {
         elem_filter = &((*element_filter)(type, ghost_type));
       } else {
         elem_filter = &(empty_filter);
       }
 
 #define AKANTU_INIT_ELEMENTAL_FIELD_INTERPOLATION_FROM_C_POINTS(type)          \
   this->initElementalFieldInterpolationFromIntegrationPoints<type>(            \
       interpolation_points_coordinates(type, ghost_type),                      \
       interpolation_points_coordinates_matrices,                               \
       quad_points_coordinates_inv_matrices,                                    \
       quadrature_points_coordinates(type, ghost_type), ghost_type,             \
       *elem_filter)
 
       AKANTU_BOOST_REGULAR_ELEMENT_SWITCH(
           AKANTU_INIT_ELEMENTAL_FIELD_INTERPOLATION_FROM_C_POINTS);
 #undef AKANTU_INIT_ELEMENTAL_FIELD_INTERPOLATION_FROM_C_POINTS
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ShapeFunctions::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<Idx> * element_filter) const {
 
   AKANTU_DEBUG_IN();
 
   auto spatial_dimension = this->mesh.getSpatialDimension();
 
   auto types_iterable = mesh.elementTypes(spatial_dimension, ghost_type);
   if (element_filter != nullptr) {
     types_iterable =
         element_filter->elementTypes(spatial_dimension, ghost_type);
   }
 
   for (auto type : types_iterable) {
     auto nb_element = mesh.getNbElement(type, ghost_type);
     if (nb_element == 0) {
       continue;
     }
 
     const Array<Idx> * elem_filter;
     if (element_filter != nullptr) {
       elem_filter = &((*element_filter)(type, ghost_type));
     } else {
       elem_filter = &(empty_filter);
     }
 
 #define AKANTU_INTERPOLATE_ELEMENTAL_FIELD_FROM_C_POINTS(type)                 \
   interpolateElementalFieldFromIntegrationPoints<type>(                        \
       field(type, ghost_type),                                                 \
       interpolation_points_coordinates_matrices(type, ghost_type),             \
       quad_points_coordinates_inv_matrices(type, ghost_type), result,          \
       ghost_type, *elem_filter)
 
     AKANTU_BOOST_REGULAR_ELEMENT_SWITCH(
         AKANTU_INTERPOLATE_ELEMENTAL_FIELD_FROM_C_POINTS);
 #undef AKANTU_INTERPOLATE_ELEMENTAL_FIELD_FROM_C_POINTS
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/src/fe_engine/shape_functions.hh b/src/fe_engine/shape_functions.hh
index 0fbe1864b..164eb8252 100644
--- a/src/fe_engine/shape_functions.hh
+++ b/src/fe_engine/shape_functions.hh
@@ -1,217 +1,220 @@
 /**
  * @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: Tue Sep 29 2020
  *
  * @brief  shape function class
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_SHAPE_FUNCTIONS_HH_
 #define AKANTU_SHAPE_FUNCTIONS_HH_
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 class ShapeFunctions  {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   ShapeFunctions(const Mesh & mesh, Int spatial_dimension,
                  const ID & id = "shape");
   ~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(indent, 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, class D1>
   void setIntegrationPointsByType(const Eigen::MatrixBase<D1> & 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<Idx> * 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<Idx> * 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, GhostType ghost_type,
       const Array<Real> & shapes,
-      const Array<Int> & filter_elements = empty_filter) const;
+      const Array<Idx> & 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<Int> & filter_elements) const;
+      const Array<Idx> & 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<Int> & element_filter) const;
+      const Array<Idx> & 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<Int> & element_filter) const;
+      const GhostType & ghost_type, const Array<Idx> & element_filter) const;
 
   /// build matrix for the interpolation of field form integration points
   template <ElementType type, typename D1, typename D2>
   inline void buildElementalFieldInterpolationMatrix(
       const Eigen::MatrixBase<D1> & coordinates,
       Eigen::MatrixBase<D2> & coordMatrix,
       Int 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)
   template <typename D1, typename D2>
   inline void
   buildInterpolationMatrix(const Eigen::MatrixBase<D1> & coordinates,
                            Eigen::MatrixBase<D2> & coordMatrix,
                            Int integration_order) const;
 
+  template <ElementType type>
+  friend struct BuildElementalFieldInterpolationMatrix;
+
 public:
   virtual void onElementsAdded(const Array<Element> & /*unused*/) {
     AKANTU_TO_IMPLEMENT();
   }
   virtual void onElementsRemoved(const Array<Element> & /*unused*/,
                                  const ElementTypeMapArray<Idx> & /*unused*/) {
     AKANTU_TO_IMPLEMENT();
   }
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the size of the shapes returned by the element class
   static inline Int getShapeSize(const ElementType & type);
 
   /// get the size of the shapes derivatives returned by the element class
   static inline Int getShapeDerivativesSize(const ElementType & type);
 
   inline const Matrix<Real> &
   getIntegrationPoints(ElementType type,
                        GhostType ghost_type) const {
     return integration_points(type, ghost_type);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get a the shapes vector
   inline const Array<Real> &
   getShapes(ElementType el_type,
             GhostType ghost_type = _not_ghost) const;
 
   /// get a the shapes derivatives vector
   inline const Array<Real> &
   getShapesDerivatives(ElementType el_type,
                        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;
 
   // spatial dimension of the elements to consider
   Int _spatial_dimension;
 
   /// 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.hh"
 
 #endif /* AKANTU_SHAPE_FUNCTIONS_HH_ */
diff --git a/src/fe_engine/shape_functions_inline_impl.hh b/src/fe_engine/shape_functions_inline_impl.hh
index 8ba35476d..0b0e15862 100644
--- a/src/fe_engine/shape_functions_inline_impl.hh
+++ b/src/fe_engine/shape_functions_inline_impl.hh
@@ -1,425 +1,366 @@
 /**
  * @file   shape_functions_inline_impl.hh
  *
  * @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: Sat Dec 19 2020
  *
  * @brief  ShapeFunctions inline implementation
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "fe_engine.hh"
 //#include "shape_functions.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_SHAPE_FUNCTIONS_INLINE_IMPL_HH_
 #define AKANTU_SHAPE_FUNCTIONS_INLINE_IMPL_HH_
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline const Array<Real> &
 ShapeFunctions::getShapes(ElementType el_type,
                           GhostType ghost_type) const {
   return shapes(FEEngine::getInterpolationType(el_type), ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Array<Real> &
 ShapeFunctions::getShapesDerivatives(ElementType el_type,
                                      GhostType ghost_type) const {
   return shapes_derivatives(FEEngine::getInterpolationType(el_type),
                             ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Int ShapeFunctions::getShapeSize(const ElementType & type) {
   AKANTU_DEBUG_IN();
 
   Int 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 Int ShapeFunctions::getShapeDerivativesSize(const ElementType & type) {
   AKANTU_DEBUG_IN();
 
   Int 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, class D1>
 void ShapeFunctions::setIntegrationPointsByType(
     const Eigen::MatrixBase<D1> & points, const GhostType & ghost_type) {
   if (not this->integration_points.exists(type, ghost_type))
     this->integration_points(type, ghost_type) = points;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename D1, typename D2>
 inline void ShapeFunctions::buildInterpolationMatrix(
     const Eigen::MatrixBase<D1> & coordinates,
     Eigen::MatrixBase<D2> & coordMatrix, Int integration_order) const {
   switch (integration_order) {
   case 1: {
     for (Int i = 0; i < coordinates.cols(); ++i)
       coordMatrix(i, 0) = 1;
     }
     break;
   }
   case 2: {
     auto nb_quadrature_points = coordMatrix.cols();
 
     for (Int i = 0; i < coordinates.cols(); ++i) {
       coordMatrix(i, 0) = 1;
       for (Int j = 1; j < nb_quadrature_points; ++j)
         coordMatrix(i, j) = coordinates(j - 1, i);
       }
     }
     break;
   }
   default: {
     AKANTU_TO_IMPLEMENT();
     break;
   }
   }
 }
 
 /* -------------------------------------------------------------------------- */
-template <ElementType type> class BuildElementalFieldInterpolationMatrix {
-  template <typename D1, typename D2>
-  inline void call(const Eigen::MatrixBase<D1> &, Eigen::MatrixBase<D2> &,
-                   Int) const {
-    AKANTU_TO_IMPLEMENT();
-  }
-};
-
-/* -------------------------------------------------------------------------- */
-template <> class BuildElementalFieldInterpolationMatrix<_segment_2> {
-  template <typename D1, typename D2>
-  inline void call(const Eigen::MatrixBase<D1> & coordinates,
-                   Eigen::MatrixBase<D2> & coordMatrix,
-                   Int integration_order) const {
-    buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
-  }
-};
-
-/* -------------------------------------------------------------------------- */
-template <> class BuildElementalFieldInterpolationMatrix<_segment_3> {
-  template <typename D1, typename D2>
-  inline void call(const Eigen::MatrixBase<D1> & coordinates,
-                   Eigen::MatrixBase<D2> & coordMatrix,
-                   Int integration_order) const {
-    buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
-  }
-};
-
-/* -------------------------------------------------------------------------- */
-template <> class BuildElementalFieldInterpolationMatrix<_triangle_3> {
-  template <typename D1, typename D2>
-  inline void call(const Eigen::MatrixBase<D1> & coordinates,
-                   Eigen::MatrixBase<D2> & coordMatrix,
-                   Int integration_order) const {
-    buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
-  }
-};
-
-/* -------------------------------------------------------------------------- */
-template <> class BuildElementalFieldInterpolationMatrix<_triangle_6> {
-  template <typename D1, typename D2>
-  inline void call(const Eigen::MatrixBase<D1> & coordinates,
-                   Eigen::MatrixBase<D2> & coordMatrix,
-                   Int integration_order) const {
-    buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
-  }
-};
-
-/* -------------------------------------------------------------------------- */
-template <> class BuildElementalFieldInterpolationMatrix<_tetrahedron_4> {
-  template <typename D1, typename D2>
-  inline void call(const Eigen::MatrixBase<D1> & coordinates,
-                   Eigen::MatrixBase<D2> & coordMatrix,
-                   Int integration_order) const {
-    buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
-  }
-};
-
-/* -------------------------------------------------------------------------- */
-template <> class BuildElementalFieldInterpolationMatrix<_tetrahedron_10> {
-  template <typename D1, typename D2>
-  inline void call(const Eigen::MatrixBase<D1> & coordinates,
-                   Eigen::MatrixBase<D2> & coordMatrix,
-                   Int integration_order) const {
-    buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
+template <ElementType type> struct BuildElementalFieldInterpolationMatrix {
+  template <typename ShapeFunction, typename D1, typename D2>
+  static inline void
+  call(ShapeFunction && func, const Eigen::MatrixBase<D1> & coordinates,
+       Eigen::MatrixBase<D2> & coordMatrix, Int integration_order) {
+    func.buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
   }
 };
 
 /**
  * @todo Write a more efficient interpolation for quadrangles by
  * dropping unnecessary quadrature points
  *
  */
 /* -------------------------------------------------------------------------- */
-template <> class BuildElementalFieldInterpolationMatrix<_quadrangle_4> {
-  template <typename D1, typename D2>
-  inline void call(const Eigen::MatrixBase<D1> & coordinates,
-                   Eigen::MatrixBase<D2> & coordMatrix,
-                   Int integration_order) const {
+template <> struct BuildElementalFieldInterpolationMatrix<_quadrangle_4> {
+  template <typename ShapeFunction, typename D1, typename D2>
+  static inline void
+  call(ShapeFunction && /*func*/, const Eigen::MatrixBase<D1> & coordinates,
+       Eigen::MatrixBase<D2> & coordMatrix, Int integration_order) {
 
     if (integration_order !=
         ElementClassProperty<_quadrangle_4>::polynomial_degree) {
       AKANTU_TO_IMPLEMENT();
     } else {
       for (Int i = 0; i < coordinates.cols(); ++i) {
         auto x = coordinates(0, i);
         auto y = coordinates(1, i);
 
         coordMatrix(i, 0) = 1;
         coordMatrix(i, 1) = x;
         coordMatrix(i, 2) = y;
         coordMatrix(i, 3) = x * y;
       }
     }
   }
 };
 
 /* -------------------------------------------------------------------------- */
-template <> class BuildElementalFieldInterpolationMatrix<_quadrangle_8> {
-  template <typename D1, typename D2>
-  inline void call(const Eigen::MatrixBase<D1> & coordinates,
-                   Eigen::MatrixBase<D2> & coordMatrix,
-                   Int integration_order) const {
+template <> struct BuildElementalFieldInterpolationMatrix<_quadrangle_8> {
+  template <typename ShapeFunction, typename D1, typename D2>
+  static inline void
+  call(ShapeFunction && /*func*/, const Eigen::MatrixBase<D1> & coordinates,
+       Eigen::MatrixBase<D2> & coordMatrix, Int integration_order) {
 
     if (integration_order !=
         ElementClassProperty<_quadrangle_8>::polynomial_degree) {
       AKANTU_TO_IMPLEMENT();
     } else {
       for (Int i = 0; i < coordinates.cols(); ++i) {
         // Int j = 0;
         auto x = coordinates(0, i);
         auto y = coordinates(1, i);
 
         coordMatrix(i, 0) = 1;
         coordMatrix(i, 1) = x;
         coordMatrix(i, 2) = y;
         coordMatrix(i, 3) = x * y;
         // for (Int e = 0; e <= 2; ++e) {
         //   for (Int n = 0; n <= 2; ++n) {
         //     coordMatrix(i, j) = std::pow(x, e) * std::pow(y, n);
         //     ++j;
         //   }
         // }
       }
     }
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, typename D1, typename D2>
 inline void ShapeFunctions::buildElementalFieldInterpolationMatrix(
     const Eigen::MatrixBase<D1> & coordinates,
     Eigen::MatrixBase<D2> & coordMatrix, Int integration_order) const {
-  BuildElementalFieldInterpolationMatrix<type>::call(coordinates, coordMatrix,
-                                                     integration_order);
+  BuildElementalFieldInterpolationMatrix<type>::call(
+      *this, coordinates, coordMatrix, integration_order);
 }
 
 /* -------------------------------------------------------------------------- */
 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<Int> & element_filter) const {
   AKANTU_DEBUG_IN();
 
   auto nb_element = this->mesh.getNbElement(type, ghost_type);
 
-  auto nb_quad_per_element =
+  constexpr auto nb_quad_per_element =
       GaussIntegrationElement<type>::getNbQuadraturePoints();
   auto nb_interpolation_points_per_elem =
       interpolation_points_coordinates_matrices.getNbComponent() /
       nb_quad_per_element;
 
   if (not 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 field_it =
+      make_view(field, field.getNbComponent(), nb_quad_per_element).begin();
 
   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 result_begin = make_view(result_vec, field.getNbComponent(),
+                                nb_interpolation_points_per_elem)
+                          .begin();
 
   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 (Int 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 = inv_quad_coord_matrix * *field_it->transpose();
+    coefficients = inv_quad_coord_matrix * field_it->transpose();
 
     /// matrix containing the points' coordinates
     const auto & coord = *interpolation_points_coordinates_it;
 
     /// multiply the coordinates matrix by the coefficients matrix and store the
     /// result
     result_begin[element_filter(el)] =
         coefficients.transpose() * coord.transpose();
   }
 
   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<Int> & 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;
   std::unique_ptr<Array<Real>> filtered_N;
   if (filter_elements != empty_filter) {
     nb_element = filter_elements.size();
     filtered_N = std::make_unique<Array<Real>>(0, shapes.getNbComponent());
     FEEngine::filterElementalData(mesh, shapes, *filtered_N, type, ghost_type,
                                   filter_elements);
-    N_it = make_view(*filtered_N, nb_nodes_per_element, nb_points).begin();
+    N_it = make_view(*filtered_N, nb_nodes_per_element, nb_points).cbegin();
   } else {
     N_it = make_view(shapes, nb_nodes_per_element, nb_points).begin();
   }
 
   uq.resize(nb_element * nb_points);
 
   auto u_it =
       make_view(u_el, nb_degree_of_freedom, nb_nodes_per_element).begin();
   auto uq_it = make_view(uq, nb_degree_of_freedom, nb_points).begin();
 
   for (Int el = 0; el < nb_element; ++el, ++N_it, ++u_it, ++uq_it) {
     const auto & u = *u_it;
     const auto & N = *N_it;
     auto & uq = *uq_it;
 
     uq = u * 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<Int> & 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 (Int el = 0; el < nb_element; ++el, ++u_it) {
     const auto & u = *u_it;
     for (Int q = 0; q < nb_points; ++q, ++B_it, ++nabla_u_it) {
       const auto & B = *B_it;
       auto & nabla_u = *nabla_u_it;
       nabla_u = u * B.transpose();
     }
   }
 
   delete filtered_B;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
 
 #endif /* AKANTU_SHAPE_FUNCTIONS_INLINE_IMPL_HH_ */
diff --git a/src/fe_engine/shape_lagrange.hh b/src/fe_engine/shape_lagrange.hh
index e1750628b..5569e1b30 100644
--- a/src/fe_engine/shape_lagrange.hh
+++ b/src/fe_engine/shape_lagrange.hh
@@ -1,180 +1,180 @@
 /**
  * @file   shape_lagrange.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Emil Gallyamov <emil.gallyamov@epfl.ch>
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Feb 15 2011
  * @date last modification: Fri May 14 2021
  *
  * @brief  lagrangian shape functions class
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "shape_lagrange_base.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_SHAPE_LAGRANGE_HH_
 #define AKANTU_SHAPE_LAGRANGE_HH_
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class Shape> class ShapeCohesive;
 class ShapeIGFEM;
 
 template <ElementKind kind> class ShapeLagrange : public ShapeLagrangeBase {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-  ShapeLagrange(const Mesh & mesh, UInt spatial_dimension,
+  ShapeLagrange(const Mesh & mesh, Int spatial_dimension,
                 const ID & id = "shape_lagrange");
   ~ShapeLagrange() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// initialization function for structural elements not yet implemented
   inline void initShapeFunctions(const Array<Real> & nodes,
                                  const Ref<const MatrixXr> & integration_points,
                                  ElementType type,
                                  GhostType ghost_type);
 
   /// computes the shape functions derivatives for given interpolation points
   template <ElementType type>
   void computeShapeDerivativesOnIntegrationPoints(
       const Array<Real> & nodes, const Ref<const MatrixXr> & integration_points,
       Array<Real> & shape_derivatives, const GhostType & ghost_type,
-      const Array<Int> & filter_elements = empty_filter) const;
+      const Array<Idx> & filter_elements = empty_filter) const;
 
   void computeShapeDerivativesOnIntegrationPoints(
       const Array<Real> & nodes, const Ref<const MatrixXr> & integration_points,
       Array<Real> & shape_derivatives, const ElementType & type,
       const GhostType & ghost_type,
-      const Array<Int> & filter_elements) const override;
+      const Array<Idx> & 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>
   void interpolateOnIntegrationPoints(
-      const Array<Real> & u, Array<Real> & uq, UInt nb_degree_of_freedom,
+      const Array<Real> & u, Array<Real> & uq, Int nb_degree_of_freedom,
       GhostType ghost_type = _not_ghost,
-      const Array<Int> & filter_elements = empty_filter) const;
+      const Array<Idx> & filter_elements = empty_filter) const;
 
   template <ElementType type>
   void interpolateOnIntegrationPoints(
-      const Array<Real> & in_u, Array<Real> & out_uq, UInt nb_degree_of_freedom,
+      const Array<Real> & in_u, Array<Real> & out_uq, Int nb_degree_of_freedom,
       const Array<Real> & shapes, GhostType ghost_type = _not_ghost,
-      const Array<Int> & filter_elements = empty_filter) const;
+      const Array<Idx> & filter_elements = empty_filter) const;
 
   /// interpolate on physical point
   template <ElementType type>
-  void interpolate(const Ref<const VectorXr> & real_coords, UInt elem,
+  void interpolate(const Ref<const VectorXr> & real_coords, Idx elem,
                    const Ref<const MatrixXr> & nodal_values,
                    Ref<VectorXr> interpolated,
                    GhostType ghost_type) 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 Array<Real> & u, Array<Real> & nablauq, Int nb_degree_of_freedom,
       GhostType ghost_type = _not_ghost,
-      const Array<Int> & filter_elements = empty_filter) const;
+      const Array<Idx> & filter_elements = empty_filter) const;
 
   template <ElementType type>
   void computeBtD(const Array<Real> & Ds, Array<Real> & BtDs,
                   GhostType ghost_type,
-                  const Array<Int> & filter_elements) const;
+                  const Array<Idx> & filter_elements) const;
 
   template <ElementType type>
-  void computeBtDB(const Array<Real> & Ds, Array<Real> & BtDBs, UInt order_d,
+  void computeBtDB(const Array<Real> & Ds, Array<Real> & BtDBs, Int order_d,
                    GhostType ghost_type,
-                   const Array<Int> & filter_elements) const;
+                   const Array<Idx> & filter_elements) const;
 
   /// multiply a field by shape functions  @f$ fts_{ij} = f_i * \varphi_j @f$
   template <ElementType type>
   void computeNtb(const Array<Real> & bs, Array<Real> & Ntbs,
                   GhostType ghost_type,
-                  const Array<Int> & filter_elements = empty_filter) const;
+                  const Array<Idx> & filter_elements = empty_filter) const;
 
   template <ElementType type>
   void computeNtbN(const Array<Real> & bs, Array<Real> & NtbNs,
                    GhostType ghost_type,
                    const Array<UInt> & filter_elements) const;
 
   /// find natural coords from real coords provided an element
   template <ElementType type>
-  void inverseMap(const Ref<const VectorXr> & real_coords, Int element,
+  void inverseMap(const Ref<const VectorXr> & real_coords, Idx element,
                   Ref<VectorXr> natural_coords,
                   GhostType ghost_type = _not_ghost) const;
 
   /// return true if the coordinates provided are inside the element, false
   /// otherwise
   template <ElementType type>
-  bool contains(const Ref<const VectorXr> & real_coords, UInt elem,
-                GhostType ghost_type) const;
+  bool contains(const Ref<const VectorXr> & real_coords, Idx elem,
+                const GhostType & ghost_type) const;
 
   /// compute the shape on a provided point
   template <ElementType type>
-  void computeShapes(const Ref<const VectorXr> & real_coords, UInt elem,
-                     Ref<VectorXr> shapes, GhostType ghost_type) const;
+  void computeShapes(const Ref<const VectorXr> & real_coords, Idx elem,
+                     Ref<VectorXr> shapes, const GhostType & ghost_type) const;
 
   /// compute the shape derivatives on a provided point
   template <ElementType type>
-  void computeShapeDerivatives(const Ref<const MatrixXr> & real_coords, UInt elem,
-                               Tensor3<Real> & shapes,
-                               GhostType ghost_type) const;
+  void computeShapeDerivatives(const Ref<const MatrixXr> & real_coords, Idx elem,
+                               Tensor3Base<Real> & shapes,
+                               const GhostType & ghost_type) const;
 
 protected:
   /// compute the shape derivatives on integration points for a given element
   template <ElementType type>
   inline void
   computeShapeDerivativesOnCPointsByElement(const Ref<const MatrixXr> & node_coords,
                                             const Ref<const MatrixXr> & natural_coords,
-                                            Tensor3<Real> & shapesd) const;
+                                            Tensor3Base<Real> & shapesd) const;
 };
 
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 #include "shape_lagrange_inline_impl.hh"
 
 #endif /* AKANTU_SHAPE_LAGRANGE_HH_ */
diff --git a/src/fe_engine/shape_lagrange_base.cc b/src/fe_engine/shape_lagrange_base.cc
index 2031f40b4..8ad931002 100644
--- a/src/fe_engine/shape_lagrange_base.cc
+++ b/src/fe_engine/shape_lagrange_base.cc
@@ -1,174 +1,171 @@
 /**
  * @file   shape_lagrange_base.cc
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Aug 09 2017
  * @date last modification: Wed Dec 09 2020
  *
  * @brief  common part for the shape lagrange
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2016-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "shape_lagrange_base.hh"
 #include "mesh_iterators.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
-ShapeLagrangeBase::ShapeLagrangeBase(const Mesh & mesh, UInt spatial_dimension,
+ShapeLagrangeBase::ShapeLagrangeBase(const Mesh & mesh, Int spatial_dimension,
                                      ElementKind kind, const ID & id)
     : ShapeFunctions(mesh, spatial_dimension, 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 & /*unused*/, const Array<Real> & /*unused*/,
-                       const Matrix<Real> & /*unused*/,
-                       Array<Real> & /*unused*/, ElementType /*unused*/,
-                       GhostType /*unused*/,
-                       const Array<UInt> & /*unused*/) {
+      static void call(const S &, const Array<Real> &, const Matrix<Real> &,
+                       Array<Real> &, const ElementType &, const GhostType &,
+                       const Array<Idx> &) {
         AKANTU_TO_IMPLEMENT();
       }
     };
 
 #if !defined(DOXYGEN)
 #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<Int> & filter_elements) {                    \
+                     const Array<Idx> & 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
 #endif
 
 /* -------------------------------------------------------------------------- */
 void ShapeLagrangeBase::computeShapesOnIntegrationPoints(
     const Array<Real> & nodes, const Ref<const MatrixXr> & integration_points,
     Array<Real> & shapes, const ElementType & type,
-    const GhostType & ghost_type, const Array<Int> & filter_elements) const {
+    const GhostType & ghost_type, const Array<Idx> & 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.getSpatialDimension(type) != _spatial_dimension) {
       continue;
     }
 
     if (mesh.getKind(type) != _kind) {
       continue;
     }
 
     const auto & elements = elements_range.getElements();
 
     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);
     }
 
     const auto & natural_coords = integration_points(type, ghost_type);
     computeShapesOnIntegrationPoints(nodes, natural_coords,
                                      shapes(itp_type, ghost_type), type,
                                      ghost_type, elements);
 
     if (_spatial_dimension != mesh.getSpatialDimension()) {
       continue;
     }
 
     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);
     }
    
     computeShapeDerivativesOnIntegrationPoints(
         nodes, natural_coords, shapes_derivatives(itp_type, ghost_type), type,
         ghost_type, elements);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ShapeLagrangeBase::onElementsRemoved(
-    const Array<Element> & /*unused*/,
-    const ElementTypeMapArray<UInt> & new_numbering) {
+    const Array<Element> &, const ElementTypeMapArray<Idx> & 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(indent, 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.hh b/src/fe_engine/shape_lagrange_inline_impl.hh
index 9dbc971d7..6ae6caeb9 100644
--- a/src/fe_engine/shape_lagrange_inline_impl.hh
+++ b/src/fe_engine/shape_lagrange_inline_impl.hh
@@ -1,581 +1,579 @@
 /**
  * @file   shape_lagrange_inline_impl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Oct 27 2010
  * @date last modification: Fri May 14 2021
  *
  * @brief  ShapeLagrange inline implementation
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_iterators.hh"
 #include "aka_voigthelper.hh"
 #include "fe_engine.hh"
-#include "shape_lagrange.hh"
+//#include "shape_lagrange.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_SHAPE_LAGRANGE_INLINE_IMPL_HH_
 #define AKANTU_SHAPE_LAGRANGE_INLINE_IMPL_HH_
 
 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 Ref<const MatrixXr> & integration_points,
     ElementType type, 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 Ref<const MatrixXr> & node_coords,
-    const Ref<const MatrixXr> & natural_coords, Tensor3<Real> & shapesd) const {
+    const Ref<const MatrixXr> & natural_coords,
+    Tensor3Base<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 Ref<const VectorXr> & real_coords,
                                      Int elem, Ref<VectorXr> natural_coords,
                                      const GhostType & ghost_type) const {
 
   AKANTU_DEBUG_IN();
 
   Int spatial_dimension = mesh.getSpatialDimension();
-  Int nb_nodes_per_element =
+  constexpr Int nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
 
   auto * elem_val = mesh.getConnectivity(type, ghost_type).data();
-  Matrix<Real> nodes_coord(spatial_dimension, nb_nodes_per_element);
+  Matrix<Real, Eigen::Dynamic, nb_nodes_per_element> nodes_coord(
+      spatial_dimension, nb_nodes_per_element);
 
   mesh.extractNodalValuesFromElement(mesh.getNodes(), nodes_coord.data(),
                                      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 Ref<const VectorXr> & real_coords,
-                                   UInt elem,
+                                   Idx elem,
                                    const GhostType & ghost_type) const {
 
-  UInt spatial_dimension = mesh.getSpatialDimension();
+  auto 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 Ref<const VectorXr> & real_coords,
-                                      UInt elem,
+                                      Idx elem,
                                       const Ref<const MatrixXr> & nodal_values,
                                       Ref<VectorXr> interpolated,
-                                      GhostType ghost_type) const {
-  UInt nb_shapes = ElementClass<type>::getShapeSize();
-  Vector<Real> shapes(nb_shapes);
+                                      const GhostType & ghost_type) const {
+  constexpr auto nb_shapes = ElementClass<type>::getShapeSize();
+  Vector<Real, nb_shapes> 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 Ref<const VectorXr> & real_coords,
-                                        UInt elem, Ref<VectorXr> shapes,
-                                        GhostType ghost_type) const {
+                                        Idx elem, Ref<VectorXr> shapes,
+                                        const GhostType & ghost_type) const {
 
   AKANTU_DEBUG_IN();
 
-  UInt spatial_dimension = mesh.getSpatialDimension();
+  auto 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 Ref<const MatrixXr> & real_coords, UInt elem, Tensor3<Real> & shapesd,
-    GhostType ghost_type) const {
+    const Ref<const MatrixXr> & real_coords, Idx elem,
+    Tensor3Base<Real> & shapesd, const GhostType & ghost_type) const {
 
   AKANTU_DEBUG_IN();
 
   auto spatial_dimension = mesh.getSpatialDimension();
   auto nb_points = real_coords.cols();
   auto 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 (Int 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);
+    inverseMap<type>(real_coords(i), elem, natural_coords(i), ghost_type);
   }
 
-  Int * elem_val = mesh.getConnectivity(type, ghost_type).data();
+  auto * elem_val = mesh.getConnectivity(type, ghost_type).data();
   Matrix<Real> nodes_coord(spatial_dimension, nb_nodes_per_element);
 
   mesh.extractNodalValuesFromElement(mesh.getNodes(), nodes_coord.data(),
                                      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, UInt spatial_dimension,
+ShapeLagrange<kind>::ShapeLagrange(const Mesh & mesh, Int spatial_dimension,
                                    const ID & id)
     : ShapeLagrangeBase(mesh, spatial_dimension, kind, id) {}
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::computeShapeDerivativesOnIntegrationPoints(
     const Array<Real> & nodes, const Ref<const MatrixXr> & integration_points,
     Array<Real> & shape_derivatives, const GhostType & ghost_type,
-    const Array<Int> & filter_elements) const {
+    const Array<Idx> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
-  UInt spatial_dimension = mesh.getSpatialDimension();
+  auto spatial_dimension = mesh.getSpatialDimension();
 
-  UInt nb_nodes_per_element =
+  auto nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
 
-  UInt nb_points = integration_points.cols();
-  UInt nb_element = mesh.getConnectivity(type, ghost_type).size();
+  auto nb_points = integration_points.cols();
+  auto nb_element = mesh.getConnectivity(type, ghost_type).size();
 
-  UInt size_of_shapesd = ElementClass<type>::getShapeDerivativesSize();
+  auto 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.data();
-  Array<Real>::matrix_iterator x_it =
-      x_el.begin(spatial_dimension, nb_nodes_per_element);
+  auto * shapesd_val = shape_derivatives.data();
+  auto 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) {
+  for (Int elem = 0; elem < nb_element; ++elem, ++x_it) {
     if (filter_elements != empty_filter) {
       shapesd_val = shape_derivatives.data() +
                     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);
+    auto & X = *x_it;
+    Tensor3Proxy<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 Ref<const MatrixXr> & integration_points,
     Array<Real> & shape_derivatives, const ElementType & type,
-    const GhostType & ghost_type, const Array<Int> & filter_elements) const {
+    const GhostType & ghost_type, const Array<Idx> & 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, 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();
+  auto 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, 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();
+  auto 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> & in_u, Array<Real> & out_uq, Int nb_degree_of_freedom,
     const Array<Real> & shapes, GhostType ghost_type,
-    const Array<Int> & filter_elements) const {
+    const Array<Idx> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
-  UInt nb_nodes_per_element =
+  auto 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<Int> & filter_elements) const {
+    const Array<Real> & in_u, Array<Real> & out_uq, Int nb_degree_of_freedom,
+    GhostType ghost_type, const Array<Idx> & 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<Int> & filter_elements) const {
+    Int nb_degree_of_freedom, GhostType ghost_type,
+    const Array<Idx> & 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 =
+  auto 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<Int> & filter_elements) const {
+                                     const Array<Idx> & 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);
+    Bt_D = 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<Int> & filter_elements) const {
+    const Array<Real> & Ds, Array<Real> & BtDBs, Int order_d,
+    GhostType ghost_type, const Array<Idx> & 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;
+    auto 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_B = B.transpose() * 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_B = B.transpose() * 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<Int> & /*filter_elements*/) const {
+    const Array<Real> & /*Ds*/, Array<Real> & /*BtDBs*/, Int /*order_d*/,
+    GhostType /*ghost_type*/, const Array<Idx> & /*filter_elements*/) const {
   AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::computeNtbN(
     const Array<Real> & bs, Array<Real> & NtbNs, GhostType ghost_type,
     const Array<Int> & filter_elements) const {
 
   auto itp_type = ElementClassProperty<type>::interpolation_type;
   auto size_of_shapes = ElementClass<type>::getShapeSize();
   auto nb_degree_of_freedom = bs.getNbComponent();
 
   auto nb_nodes_per_element = mesh.getNbNodesPerElement(type);
   Array<Real> shapes_filtered(0, size_of_shapes);
 
   auto && view = make_view(shapes(itp_type, ghost_type), 1, size_of_shapes);
   auto N_it = view.begin();
   auto N_end = view.end();
 
   if (filter_elements != empty_filter) {
     FEEngine::filterElementalData(this->mesh, shapes(itp_type, ghost_type),
                                   shapes_filtered, type, ghost_type,
                                   filter_elements);
     auto && view = make_view(shapes_filtered, 1, size_of_shapes);
     N_it = view.begin();
     N_end = view.end();
   }
 
   Matrix<Real> Nt_b(nb_nodes_per_element, nb_degree_of_freedom);
   for (auto && values :
        zip(range(N_it, N_end), make_view(bs, nb_degree_of_freedom, 1),
            make_view(NtbNs, nb_nodes_per_element, nb_nodes_per_element))) {
     const auto & N = std::get<0>(values);
     const auto & b = std::get<1>(values);
     auto & Nt_b_N = std::get<2>(values);
     Nt_b.template mul<true, false>(N, b);
     Nt_b_N.template mul<false, false>(Nt_b, N);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::computeNtb(
     const Array<Real> & bs, Array<Real> & Ntbs, GhostType ghost_type,
-    const Array<Int> & filter_elements) const {
+    const Array<Idx> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   Ntbs.resize(bs.size());
 
   auto size_of_shapes = ElementClass<type>::getShapeSize();
   auto itp_type = ElementClassProperty<type>::interpolation_type;
   auto nb_degree_of_freedom = bs.getNbComponent();
 
   Array<Real> shapes_filtered(0, size_of_shapes);
   auto && view = make_view(shapes(itp_type, ghost_type), 1, size_of_shapes);
   auto N_it = view.begin();
   auto N_end = view.end();
 
   if (filter_elements != empty_filter) {
     FEEngine::filterElementalData(this->mesh, shapes(itp_type, ghost_type),
                                   shapes_filtered, type, ghost_type,
                                   filter_elements);
     auto && view = make_view(shapes_filtered, 1, size_of_shapes);
     N_it = view.begin();
     N_end = view.end();
   }
 
   for (auto && values :
        zip(make_view(bs, nb_degree_of_freedom, 1), range(N_it, N_end),
            make_view(Ntbs, nb_degree_of_freedom, size_of_shapes))) {
     const auto & b = std::get<0>(values);
     const auto & N = std::get<1>(values);
     auto & Ntb = std::get<2>(values);
 
     Ntb = b * N;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
 
 #endif /* AKANTU_SHAPE_LAGRANGE_INLINE_IMPL_HH_ */
diff --git a/src/io/dumper/dumpable.cc b/src/io/dumper/dumpable.cc
index 8ae9559a8..3a9c2b2ad 100644
--- a/src/io/dumper/dumpable.cc
+++ b/src/io/dumper/dumpable.cc
@@ -1,279 +1,276 @@
 /**
  * @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: Fri Feb 28 2020
  *
  * @brief  Implementation of the dumpable interface
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2014-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dumpable.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifdef AKANTU_USE_IOHELPER
 
 #include <io_helper.hh>
 #include <utility>
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Dumpable::Dumpable() = default;
 
 /* -------------------------------------------------------------------------- */
 Dumpable::~Dumpable() = default;
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::registerExternalDumper(std::shared_ptr<DumperIOHelper> dumper,
                                       const std::string & dumper_name,
                                       const bool is_default) {
   this->dumpers[dumper_name] = std::move(dumper);
   if (is_default) {
     this->default_dumper = dumper_name;
   }
 }
 
 /* -------------------------------------------------------------------------- */
-void Dumpable::addDumpMesh(const Mesh & mesh, UInt spatial_dimension,
-                           GhostType ghost_type, ElementKind element_kind) {
+void Dumpable::addDumpMesh(const Mesh & mesh, Int 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,
-                                   GhostType ghost_type,
-                                   ElementKind element_kind) {
+                                   const Mesh & mesh, Int 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,
-    GhostType ghost_type, ElementKind element_kind) {
+    const Mesh & mesh, const ElementTypeMapArray<Idx> & elements_filter,
+    const Array<Idx> & nodes_filter, Int 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,
-    GhostType ghost_type, ElementKind element_kind) {
+    const ElementTypeMapArray<Idx> & elements_filter,
+    const Array<Idx> & nodes_filter, Int 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) {
+void Dumpable::addDumpFieldToDumper(const std::string & /*dumper_name*/,
+                                    const std::string & /*field_id*/) {
   AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldExternal(const std::string & field_id,
                                     std::shared_ptr<dumpers::Field> field) {
   this->addDumpFieldExternalToDumper(this->default_dumper, field_id,
                                      std::move(field));
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldExternalToDumper(
     const std::string & dumper_name, const std::string & field_id,
     std::shared_ptr<dumpers::Field> field) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerField(field_id, std::move(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(const std::string & /*dumper_name*/,
                                           const std::string & /*field_id*/) {
   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) {
+void Dumpable::addDumpFieldTensorToDumper(const std::string & /*dumper_name*/,
+                                          const std::string & /*field_id*/) {
   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) {
+void Dumpable::dump(const std::string & dumper_name, Int step) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.dump(step);
 }
 
 /* -------------------------------------------------------------------------- */
-void Dumpable::dump(UInt step) { this->dump(this->default_dumper, step); }
+void Dumpable::dump(Int step) { this->dump(this->default_dumper, step); }
 
 /* -------------------------------------------------------------------------- */
-void Dumpable::dump(const std::string & dumper_name, Real time, UInt step) {
+void Dumpable::dump(const std::string & dumper_name, Real time, Int step) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.dump(time, step);
 }
 
 /* -------------------------------------------------------------------------- */
-void Dumpable::dump(Real time, UInt step) {
+void Dumpable::dump(Real time, Int step) {
   this->dump(this->default_dumper, time, step);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::internalAddDumpFieldToDumper(
     const std::string & dumper_name, const std::string & field_id,
     std::shared_ptr<dumpers::Field> field) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerField(field_id, std::move(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;
 }
 
 } // namespace akantu
 
 #endif
diff --git a/src/io/dumper/dumpable_iohelper.hh b/src/io/dumper/dumpable_iohelper.hh
index 5e8d4a1a5..a147a6382 100644
--- a/src/io/dumper/dumpable_iohelper.hh
+++ b/src/io/dumper/dumpable_iohelper.hh
@@ -1,194 +1,194 @@
 /**
  * @file   dumpable_iohelper.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: Tue Jan 06 2015
  * @date last modification: Fri Feb 28 2020
  *
  * @brief  Interface for object who wants to dump themselves
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dumper_iohelper.hh"
 /* -------------------------------------------------------------------------- */
 #include <set>
 /* -------------------------------------------------------------------------- */
 #ifndef AKANTU_DUMPABLE_IOHELPER_HH_
 #define AKANTU_DUMPABLE_IOHELPER_HH_
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 class Dumpable {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   Dumpable();
   virtual ~Dumpable();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// create a new dumper (of templated type T) and register it under
   /// dumper_name. file_name is used for construction of T. is default states if
   /// this dumper is the default dumper.
   template <class T>
   inline void registerDumper(const std::string & dumper_name,
                              const std::string & file_name = "",
                              bool is_default = false);
 
   /// register an externally created dumper
   void registerExternalDumper(std::shared_ptr<DumperIOHelper> dumper,
                               const std::string & dumper_name,
                               bool is_default = false);
 
   /// register a mesh to the default dumper
   void addDumpMesh(const Mesh & mesh, Int spatial_dimension = _all_dimensions,
                    const GhostType & ghost_type = _not_ghost,
                    const ElementKind & element_kind = _ek_not_defined);
 
   /// register a mesh to the default identified by its name
   void addDumpMeshToDumper(const std::string & dumper_name, const Mesh & mesh,
                            Int spatial_dimension = _all_dimensions,
                            const GhostType & ghost_type = _not_ghost,
                            const ElementKind & element_kind = _ek_not_defined);
 
   /// register a filtered mesh as the default dumper
   void addDumpFilteredMesh(const Mesh & mesh,
                            const ElementTypeMapArray<Idx> & elements_filter,
                            const Array<Idx> & nodes_filter,
-                           UInt spatial_dimension = _all_dimensions,
-                           GhostType ghost_type = _not_ghost,
-                           ElementKind element_kind = _ek_not_defined);
+                           Int spatial_dimension = _all_dimensions,
+                           const GhostType & ghost_type = _not_ghost,
+                           const ElementKind & element_kind = _ek_not_defined);
 
   /// register a filtered mesh and provides a name
   void addDumpFilteredMeshToDumper(
       const std::string & dumper_name, const Mesh & mesh,
       const ElementTypeMapArray<Idx> & elements_filter,
       const Array<Idx> & nodes_filter,
       Int spatial_dimension = _all_dimensions,
       const GhostType & ghost_type = _not_ghost,
       const ElementKind & element_kind = _ek_not_defined);
 
   /// to implement
   virtual void addDumpField(const std::string & field_id);
   /// to implement
   virtual void addDumpFieldToDumper(const std::string & dumper_name,
                                     const std::string & field_id);
   /// add a field
   virtual void addDumpFieldExternal(const std::string & field_id,
                                     std::shared_ptr<dumpers::Field> field);
   virtual void
   addDumpFieldExternalToDumper(const std::string & dumper_name,
                                const std::string & field_id,
                                std::shared_ptr<dumpers::Field> field);
 
   template <typename T>
   inline void addDumpFieldExternal(const std::string & field_id,
                                    const Array<T> & field);
   template <typename T>
   inline void addDumpFieldExternalToDumper(const std::string & dumper_name,
                                            const std::string & field_id,
                                            const Array<T> & field);
   template <typename T>
   inline void
   addDumpFieldExternal(const std::string & field_id,
                        const ElementTypeMapArray<T> & field,
                        Int spatial_dimension = _all_dimensions,
                        const GhostType & ghost_type = _not_ghost,
                        const ElementKind & element_kind = _ek_not_defined);
   template <typename T>
   inline void addDumpFieldExternalToDumper(
       const std::string & dumper_name, const std::string & field_id,
       const ElementTypeMapArray<T> & field,
       Int spatial_dimension = _all_dimensions,
       const GhostType & ghost_type = _not_ghost,
       const ElementKind & element_kind = _ek_not_defined);
 
   void removeDumpField(const std::string & field_id);
   void removeDumpFieldFromDumper(const std::string & dumper_name,
                                  const std::string & field_id);
 
   virtual void addDumpFieldVector(const std::string & field_id);
   virtual void addDumpFieldVectorToDumper(const std::string & dumper_name,
                                           const std::string & field_id);
 
   virtual void addDumpFieldTensor(const std::string & field_id);
   virtual void addDumpFieldTensorToDumper(const std::string & dumper_name,
                                           const std::string & field_id);
 
   void setDirectory(const std::string & directory);
   void setDirectoryToDumper(const std::string & dumper_name,
                             const std::string & directory);
 
   void setBaseName(const std::string & basename);
 
   void setBaseNameToDumper(const std::string & dumper_name,
                            const std::string & basename);
   void setTimeStepToDumper(Real time_step);
   void setTimeStepToDumper(const std::string & dumper_name, Real time_step);
 
   void setTextModeToDumper(const std::string & dumper_name);
   void setTextModeToDumper();
 
   virtual void dump();
   virtual void dump(Int step);
   virtual void dump(Real time, Int step);
   virtual void dump(const std::string & dumper_name);
   virtual void dump(const std::string & dumper_name, Int step);
   virtual void dump(const std::string & dumper_name, Real time, Int step);
 
 public:
   void internalAddDumpFieldToDumper(const std::string & dumper_name,
                                     const std::string & field_id,
                                     std::shared_ptr<dumpers::Field> field);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   DumperIOHelper & getDumper();
   DumperIOHelper & getDumper(const std::string & dumper_name);
 
   template <class T> T & getDumper(const std::string & dumper_name);
   std::string getDefaultDumperName() const;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   using DumperMap = std::map<std::string, std::shared_ptr<DumperIOHelper>>;
   using DumperSet = std::set<std::string>;
 
   DumperMap dumpers;
   std::string default_dumper;
 };
 
 } // namespace akantu
 
 #endif /* AKANTU_DUMPABLE_IOHELPER_HH_ */
diff --git a/src/io/mesh_io/mesh_io_diana.cc b/src/io/mesh_io/mesh_io_diana.cc
index 7573a9c67..be8015571 100644
--- a/src/io/mesh_io/mesh_io_diana.cc
+++ b/src/io/mesh_io/mesh_io_diana.cc
@@ -1,612 +1,610 @@
 /**
  * @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: Fri Feb 28 2020
  *
  * @brief  handles diana meshes
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #include <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_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_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::
     readCoordinates( // NOLINT(readability-convert-member-functions-to-static)
         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( // NOLINT(readability-convert-member-functions-to-static)
         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;
+          auto first = *it;
           ++it;
-          UInt second = *it;
-          for (UInt i = first; i <= second; ++i) {
+          auto second = *it;
+          for (auto 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;
+      auto & ng = mesh.createNodeGroup(name);
+      for (Int i = 0; i < list_ids->size(); ++i) {
+        auto 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)];
+      auto & eg = mesh.createElementGroup(name);
+      for (Int i = 0; i < list_ids->size(); ++i) {
+        auto & 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;
-  ElementType akantu_type_old = _not_defined;
-  Array<UInt> * connectivity = nullptr;
+  ElementType akantu_type, akantu_type_old = _not_defined;
+  Array<Idx> * 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) {
+      for (auto 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;
 
   for (auto type : mesh.elementTypes()) {
-    UInt nb_element = mesh.getNbElement(type);
-    mesh.getDataPointer<UInt>("material", type, _not_ghost, 1)
+    auto nb_element = mesh.getNbElement(type);
+    mesh.getDataPointer<Int>("material", type, _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] = {'\0'};
     strncpy(tutu, line.c_str(), 249);
 
     AKANTU_DEBUG_WARNING("reading line " << line);
-    Array<UInt> temp_id(0, 2);
-    UInt mat;
+    Array<Int> temp_id(0, 2);
+    Int mat;
     while (true) {
       std::stringstream sstr_intervals_elements(line);
-      Vector<UInt> id(2);
+      Vector<Int> 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];
+    //    UInt * temp_id_val = temp_id.data();
+    for (Int i = 0; i < temp_id.size(); ++i)
+      for (Int j = temp_id(i, 0); j <= temp_id(i, 1); ++j) {
+        auto & 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);
+        auto elem = element.element;
+        auto type = element.type;
+        auto & data =
+            mesh.getDataPointer<Int>("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;
+  auto first_mat = true;
+  auto 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);
+      auto 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 06357a266..1a977faab 100644
--- a/src/io/mesh_io/mesh_io_msh.cc
+++ b/src/io/mesh_io/mesh_io_msh.cc
@@ -1,1125 +1,1124 @@
 /**
  * @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 Oct 29 2020
  *
  * @brief  Read/Write for MSH files generated by gmsh
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  * 
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  * 
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -----------------------------------------------------------------------------
    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 "element_group.hh"
 #include "mesh_io.hh"
 #include "mesh_utils.hh"
 #include "node_group.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 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;
 
 /* -------------------------------------------------------------------------- */
 namespace {
   struct File {
     std::string filename;
     std::ifstream infile;
     std::string line;
     size_t current_line{0};
 
     size_t first_node_number{std::numeric_limits<UInt>::max()},
         last_node_number{0};
     bool has_physical_names{false};
 
     std::unordered_map<size_t, size_t> node_tags;
     std::unordered_map<size_t, Element> element_tags;
     double version{0};
     int size_of_size_t{0};
     Mesh & mesh;
     MeshAccessor mesh_accessor;
 
     std::multimap<std::pair<int, int>, int> entity_tag_to_physical_tags;
 
     File(const std::string & filename, Mesh & mesh)
         : filename(filename), mesh(mesh), mesh_accessor(mesh) {
       infile.open(filename.c_str());
       if (not infile.good()) {
         AKANTU_EXCEPTION("Cannot open file " << filename);
       }
     }
 
     ~File() { infile.close(); }
 
     auto good() { return infile.good(); }
 
     std::stringstream get_line() {
       std::string tmp_str;
       if (infile.eof()) {
         AKANTU_EXCEPTION("Reached the end of the file " << filename);
       }
       std::getline(infile, tmp_str);
       line = trim(tmp_str);
       ++current_line;
 
       return std::stringstream(line);
     }
 
     template <typename... Ts> void read_line(Ts &&... ts) {
       auto && sstr = get_line();
       (void)std::initializer_list<int>{
           (sstr >> std::forward<decltype(ts)>(ts), 0)...};
     }
   };
 } // namespace
 
 /* -------------------------------------------------------------------------- */
 template <typename File, typename Readers>
 void MeshIOMSH::populateReaders2(File & file, Readers & readers) {
   readers["$NOD"] = readers["$Nodes"] = [&](const std::string & /*unused*/) {
     UInt nb_nodes;
     file.read_line(nb_nodes);
 
     Array<Real> & nodes = file.mesh_accessor.getNodes();
     nodes.resize(nb_nodes);
     file.mesh_accessor.setNbGlobalNodes(nb_nodes);
 
     size_t index;
     Vector<double> coord(3);
 
     /// for each node, read the coordinates
     for (auto && data : enumerate(make_view(nodes, nodes.getNbComponent()))) {
       file.read_line(index, coord(0), coord(1), coord(2));
 
       if (index > std::numeric_limits<UInt>::max()) {
         AKANTU_EXCEPTION(
             "There are more nodes in this files than the index type of akantu "
             "can handle, consider recompiling with a bigger index type");
       }
 
       file.first_node_number = std::min(file.first_node_number, index);
       file.last_node_number = std::max(file.last_node_number, index);
 
       for (auto && coord_data : zip(std::get<1>(data), coord)) {
         std::get<0>(coord_data) = std::get<1>(coord_data);
       }
       file.node_tags[index] = std::get<0>(data);
     }
   };
 
   readers["$ELM"] = readers["$Elements"] = [&](const std::string & /*unused*/) {
     UInt nb_elements;
     file.read_line(nb_elements);
 
     Int index;
     UInt msh_type;
     ElementType akantu_type;
 
     for (UInt i = 0; i < nb_elements; ++i) {
       auto && sstr_elem = file.get_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 " << file.current_line);
         continue;
       }
 
       Element elem{akantu_type, 0, _not_ghost};
 
       auto & connectivity = file.mesh_accessor.getConnectivity(akantu_type);
       auto node_per_element = connectivity.getNbComponent();
       auto & read_order = this->_read_order[akantu_type];
 
       /// read tags informations
       if (file.version < 2) {
         Int tag0;
         Int tag1;
         Int nb_nodes; // reg-phys, reg-elem, number-of-nodes
         sstr_elem >> tag0 >> tag1 >> nb_nodes;
 
         auto & data0 =
             file.mesh_accessor.template getData<UInt>("tag_0", akantu_type);
         data0.push_back(tag0);
 
         auto & data1 =
             file.mesh_accessor.template getData<UInt>("tag_1", akantu_type);
         data1.push_back(tag1);
       } else if (file.version < 4) {
         UInt nb_tags;
         sstr_elem >> nb_tags;
         for (UInt j = 0; j < nb_tags; ++j) {
           Int tag;
           sstr_elem >> tag;
 
           auto & data = file.mesh_accessor.template getData<UInt>(
               "tag_" + std::to_string(j), akantu_type);
           data.push_back(tag);
         }
       }
 
       Vector<UInt> local_connect(node_per_element);
-      for (UInt j = 0; j < node_per_element; ++j) {
+      for (Int j = 0; j < node_per_element; ++j) {
         UInt node_index;
         sstr_elem >> node_index;
 
         AKANTU_DEBUG_ASSERT(node_index <= file.last_node_number,
                             "Node number not in range : line "
                                 << file.current_line);
 
         local_connect(read_order[j]) = file.node_tags[node_index];
       }
 
       connectivity.push_back(local_connect);
       elem.element = connectivity.size() - 1;
       file.element_tags[index] = elem;
     }
   };
 
-  readers["$Periodic"] = [&](const std::string & /*unused*/) {
-    UInt nb_periodic_entities;
+  readers["$Periodic"] = [&](const std::string &) {
+    Int nb_periodic_entities;
     file.read_line(nb_periodic_entities);
 
     file.mesh_accessor.getNodesFlags().resize(file.mesh.getNbNodes(),
                                               NodeFlag::_normal);
 
-    for (UInt p = 0; p < nb_periodic_entities; ++p) {
+    for (Int p = 0; p < nb_periodic_entities; ++p) {
       // dimension slave-tag master-tag
-      UInt dimension;
+      Int dimension;
       file.read_line(dimension);
 
       // transformation
       file.get_line();
 
       // nb nodes
-      UInt nb_nodes;
+      Int nb_nodes;
       file.read_line(nb_nodes);
 
-      for (UInt n = 0; n < nb_nodes; ++n) {
+      for (Int n = 0; n < nb_nodes; ++n) {
         // slave master
         auto && sstr = file.get_line();
 
         // The info in the mesh seem inconsistent so they are ignored for now.
         continue;
 
         if (dimension == file.mesh.getSpatialDimension() - 1) {
-          UInt slave;
-          UInt master;
+          Idx slave, master;
 
           sstr >> slave;
           sstr >> master;
           file.mesh_accessor.addPeriodicSlave(file.node_tags[slave],
                                               file.node_tags[master]);
         }
       }
     }
 
     // mesh_accessor.markMeshPeriodic();
   };
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename File, typename Readers>
 void MeshIOMSH::populateReaders4(File & file, Readers & readers) {
   static std::map<int, std::string> entity_type{
       {0, "points"},
       {1, "curve"},
       {2, "surface"},
       {3, "volume"},
   };
 
   readers["$Entities"] = [&](const std::string & /*unused*/) {
     size_t num_entity[4];
     file.read_line(num_entity[0], num_entity[1], num_entity[2], num_entity[3]);
 
     for (auto entity_dim : arange(4)) {
       for (auto _ [[gnu::unused]] : arange(num_entity[entity_dim])) {
         auto && sstr = file.get_line();
 
         int tag;
         double min_x;
         double min_y;
         double min_z;
         double max_x;
         double max_y;
         double max_z;
         size_t num_physical_tags;
         sstr >> tag >> min_x >> min_y >> min_z;
 
         if (entity_dim > 0 or file.version < 4.1) {
           sstr >> max_x >> max_y >> max_z;
         }
 
         sstr >> num_physical_tags;
 
         for (auto _ [[gnu::unused]] : arange(num_physical_tags)) {
           int phys_tag;
           sstr >> phys_tag;
 
           std::string physical_name;
           if (this->physical_names.find(phys_tag) ==
               this->physical_names.end()) {
             physical_name = "msh_block_" + std::to_string(phys_tag);
           } else {
             physical_name = this->physical_names[phys_tag];
           }
 
           if (not file.mesh.elementGroupExists(physical_name)) {
             file.mesh.createElementGroup(physical_name, entity_dim);
           } else {
             file.mesh.getElementGroup(physical_name).addDimension(entity_dim);
           }
           file.entity_tag_to_physical_tags.insert(
               std::make_pair(std::make_pair(tag, entity_dim), phys_tag));
         }
       }
     }
   };
 
   readers["$Nodes"] = [&](const std::string & /*unused*/) {
     size_t num_blocks;
     size_t num_nodes;
     if (file.version >= 4.1) {
       file.read_line(num_blocks, num_nodes, file.first_node_number,
                      file.last_node_number);
     } else {
       file.read_line(num_blocks, num_nodes);
     }
     auto & nodes = file.mesh_accessor.getNodes();
     nodes.reserve(num_nodes);
     file.mesh_accessor.setNbGlobalNodes(num_nodes);
 
     if (num_nodes > std::numeric_limits<UInt>::max()) {
       AKANTU_EXCEPTION(
           "There are more nodes in this files than the index type of akantu "
           "can handle, consider recompiling with a bigger index type");
     }
 
     size_t node_id{0};
 
     for (auto block [[gnu::unused]] : arange(num_blocks)) {
       int entity_dim;
       int entity_tag;
       int parametric;
       size_t num_nodes_in_block;
       Vector<double> pos(3);
       Vector<double> real_pos(nodes.getNbComponent());
 
       if (file.version >= 4.1) {
         file.read_line(entity_dim, entity_tag, parametric, num_nodes_in_block);
         if (parametric) {
           AKANTU_EXCEPTION(
               "Akantu does not support parametric nodes in msh files");
         }
         for (auto _ [[gnu::unused]] : arange(num_nodes_in_block)) {
           size_t tag;
           file.read_line(tag);
           file.node_tags[tag] = node_id;
           ++node_id;
         }
 
         for (auto _ [[gnu::unused]] : arange(num_nodes_in_block)) {
           file.read_line(pos(_x), pos(_y), pos(_z));
           for (auto && data : zip(real_pos, pos)) {
             std::get<0>(data) = std::get<1>(data);
           }
 
           nodes.push_back(real_pos);
         }
       } else {
         file.read_line(entity_tag, entity_dim, parametric, num_nodes_in_block);
 
         for (auto _ [[gnu::unused]] : arange(num_nodes_in_block)) {
           size_t tag;
           file.read_line(tag, pos(_x), pos(_y), pos(_z));
 
           if (file.version < 4.1) {
             file.first_node_number = std::min(file.first_node_number, tag);
             file.last_node_number = std::max(file.last_node_number, tag);
           }
 
           for (auto && data : zip(real_pos, pos)) {
             std::get<0>(data) = std::get<1>(data);
           }
 
           nodes.push_back(real_pos);
           file.node_tags[tag] = node_id;
           ++node_id;
         }
       }
     }
   };
 
   readers["$Elements"] = [&](const std::string & /*unused*/) {
     size_t num_blocks;
     size_t num_elements;
     file.read_line(num_blocks, num_elements);
 
     for (auto block [[gnu::unused]] : arange(num_blocks)) {
       int entity_dim;
       int entity_tag;
       int element_type;
       size_t num_elements_in_block;
 
       if (file.version >= 4.1) {
         file.read_line(entity_dim, entity_tag, element_type,
                        num_elements_in_block);
       } else {
         file.read_line(entity_tag, entity_dim, element_type,
                        num_elements_in_block);
       }
 
       /// get the connectivity vector depending on the element type
       auto && akantu_type =
           this->_msh_to_akantu_element_types[(MSHElementType)element_type];
 
       if (akantu_type == _not_defined) {
         AKANTU_DEBUG_WARNING("Unsuported element kind " << element_type
                                                         << " at line "
                                                         << file.current_line);
         continue;
       }
 
       Element elem{akantu_type, 0, _not_ghost};
 
       auto & connectivity = file.mesh_accessor.getConnectivity(akantu_type);
       Vector<UInt> local_connect(connectivity.getNbComponent());
       auto && read_order = this->_read_order[akantu_type];
 
       auto & data0 =
           file.mesh_accessor.template getData<UInt>("tag_0", akantu_type);
       data0.resize(data0.size() + num_elements_in_block, 0);
 
       auto & physical_data = file.mesh_accessor.template getData<std::string>(
           "physical_names", akantu_type);
       physical_data.resize(physical_data.size() + num_elements_in_block, "");
 
       for (auto _ [[gnu::unused]] : arange(num_elements_in_block)) {
         auto && sstr_elem = file.get_line();
         size_t elem_tag;
         sstr_elem >> elem_tag;
         for (auto && c : arange(connectivity.getNbComponent())) {
           size_t node_tag;
           sstr_elem >> node_tag;
 
           AKANTU_DEBUG_ASSERT(node_tag <= file.last_node_number,
                               "Node number not in range : line "
                                   << file.current_line);
 
           node_tag = file.node_tags[node_tag];
           local_connect(read_order[c]) = node_tag;
         }
         connectivity.push_back(local_connect);
         elem.element = connectivity.size() - 1;
         file.element_tags[elem_tag] = elem;
 
         auto range = file.entity_tag_to_physical_tags.equal_range(
             std::make_pair(entity_tag, entity_dim));
         bool first = true;
         for (auto it = range.first; it != range.second; ++it) {
           auto phys_it = this->physical_names.find(it->second);
           if (first) {
             data0(elem.element) =
                 it->second; // for compatibility with version 2
             if (phys_it != this->physical_names.end()) {
               physical_data(elem.element) = phys_it->second;
             }
             first = false;
           }
           if (phys_it != this->physical_names.end()) {
             file.mesh.getElementGroup(phys_it->second).add(elem, true, false);
           }
         }
       }
     }
 
     for (auto && element_group : file.mesh.iterateElementGroups()) {
       element_group.getNodeGroup().optimize();
     }
   };
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIOMSH::read(const std::string & filename, Mesh & mesh) {
 
   File file(filename, mesh);
 
   std::map<std::string, std::function<void(const std::string &)>> readers;
 
   readers["$MeshFormat"] = [&](const std::string & /*unused*/) {
     auto && sstr = file.get_line();
 
     int format;
     sstr >> file.version >> format;
 
     if (format != 0) {
       AKANTU_ERROR("This reader can only read ASCII files.");
     }
 
     if (file.version > 2) {
       sstr >> file.size_of_size_t;
       if (file.size_of_size_t > int(sizeof(UInt))) {
         AKANTU_DEBUG_INFO("The size of the indexes in akantu might be to small "
                           "to read this file (akantu "
                           << sizeof(UInt) << " vs. msh file "
                           << file.size_of_size_t << ")");
       }
     }
 
     if (file.version < 4) {
       this->populateReaders2(file, readers);
     } else {
       this->populateReaders4(file, readers);
     }
   };
 
   auto && read_data = [&](auto && entity_tags, auto && get_data,
                           auto && read_data) {
     auto read_data_tags = [&](auto x) {
       UInt number_of_tags{0};
       file.read_line(number_of_tags);
       std::vector<decltype(x)> tags(number_of_tags);
 
       for (auto && tag : tags) {
         file.read_line(tag);
       }
       return tags;
     };
 
     auto && string_tags = read_data_tags(std::string{});
     auto && real_tags [[gnu::unused]] = read_data_tags(double{});
     auto && int_tags = read_data_tags(int{});
 
     for (auto & s : string_tags) {
       s = trim(s, '"');
     }
 
     auto id = string_tags[0];
     auto size = int_tags[2];
     auto nb_component = int_tags[1];
     auto & data = get_data(id, size, nb_component);
 
     for (auto n [[gnu::unused]] : arange(size)) {
       auto && sstr = file.get_line();
 
       size_t tag;
       sstr >> tag;
       const auto & entity = entity_tags[tag];
       read_data(entity, sstr, data, nb_component);
     }
   };
 
   readers["$NodeData"] = [&](const std::string & /*unused*/) {
     /* $NodeData
        numStringTags(ASCII int)
        stringTag(string) ...
        numRealTags(ASCII int)
        realTag(ASCII double) ...
        numIntegerTags(ASCII int)
        integerTag(ASCII int) ...
        nodeTag(size_t) value(double) ...
        ...
        $EndNodeData */
     read_data(
         file.node_tags,
         [&](auto && id, auto && size [[gnu::unused]],
             auto && nb_component [[gnu::unused]]) -> Array<double> & {
           auto & data =
               file.mesh.template getNodalData<double>(id, nb_component);
           data.resize(size);
           return data;
         },
         [&](auto && node, auto && sstr, auto && data,
             auto && nb_component [[gnu::unused]]) {
           for (auto c : arange(nb_component)) {
             sstr >> data(node, c);
           }
         });
   };
 
   readers["$ElementData"] = [&](const std::string & /*unused*/) {
     /* $ElementData
        numStringTags(ASCII int)
        stringTag(string) ...
        numRealTags(ASCII int)
        realTag(ASCII double) ...
        numIntegerTags(ASCII int)
        integerTag(ASCII int) ...
        elementTag(size_t) value(double) ...
        ...
        $EndElementData
     */
     read_data(
         file.element_tags,
         [&](auto && id, auto && size [[gnu::unused]],
             auto && nb_component
             [[gnu::unused]]) -> ElementTypeMapArray<double> & {
           file.mesh.template getElementalData<double>(id);
           return file.mesh.template getElementalData<double>(id);
         },
         [&](auto && element, auto && sstr, auto && data, auto && nb_component) {
           if (not data.exists(element.type)) {
             data.alloc(mesh.getNbElement(element.type), nb_component,
                        element.type, element.ghost_type);
           }
           auto & data_array = data(element.type);
           for (auto c : arange(nb_component)) {
             sstr >> data_array(element.element, c);
           }
         });
   };
 
   readers["$ElementNodeData"] = [&](const std::string & /*unused*/) {
     /* $ElementNodeData
        numStringTags(ASCII int)
        stringTag(string) ...
        numRealTags(ASCII int)
        realTag(ASCII double) ...
        numIntegerTags(ASCII int)
        integerTag(ASCII int) ...
        elementTag(size_t) value(double) ...
        ...
        $EndElementNodeData
     */
     read_data(
         file.element_tags,
         [&](auto && id, auto && size [[gnu::unused]],
             auto && nb_component
             [[gnu::unused]]) -> ElementTypeMapArray<double> & {
           file.mesh.template getElementalData<double>(id);
           auto & data = file.mesh.template getElementalData<double>(id);
           data.isNodal(true);
           return data;
         },
         [&](auto && element, auto && sstr, auto && data, auto && nb_component) {
           int nb_nodes_per_element;
           sstr >> nb_nodes_per_element;
           if (not data.exists(element.type)) {
             data.alloc(mesh.getNbElement(element.type),
                        nb_component * nb_nodes_per_element, element.type,
                        element.ghost_type);
           }
           auto & data_array = data(element.type);
           for (auto c : arange(nb_component)) {
             sstr >> data_array(element.element, c);
           }
         });
   };
 
   readers["$PhysicalNames"] = [&](const std::string & /*unused*/) {
     file.has_physical_names = true;
     int num_of_phys_names;
     file.read_line(num_of_phys_names); /// the format line
 
     for (auto k [[gnu::unused]] : arange(num_of_phys_names)) {
       int phys_name_id;
       int phys_dim;
       std::string phys_name;
       file.read_line(phys_dim, phys_name_id, std::quoted(phys_name));
 
       this->physical_names[phys_name_id] = phys_name;
     }
   };
 
   readers["Unsupported"] = [&](const std::string & _block) {
     std::string block = _block.substr(1);
     AKANTU_DEBUG_WARNING("Unsupported block_kind " << block << " at line "
                                                    << file.current_line);
     auto && end_block = "$End" + block;
     while (file.line != end_block) {
       file.get_line();
     }
   };
 
   while (file.good()) {
     std::string block;
     file.read_line(block);
 
     auto && it = readers.find(block);
 
     if (it != readers.end()) {
       it->second(block);
 
       std::string end_block;
       file.read_line(end_block);
       block = block.substr(1);
 
       if (end_block != "$End" + block) {
         AKANTU_EXCEPTION("The reader failed to properly read the block "
                          << block << ". Expected a $End" << block << " at line "
                          << file.current_line);
       }
     } else if (not block.empty()) {
       readers["Unsupported"](block);
     }
   }
 
   // mesh.updateTypesOffsets(_not_ghost);
   if (file.version < 4) {
     this->constructPhysicalNames("tag_0", mesh);
     if (file.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"
           << "\n";
   outfile << "2.2 0 8"
           << "\n";
   outfile << "$EndMeshFormat"
           << "\n";
 
   outfile << std::setprecision(std::numeric_limits<Real>::digits10);
   outfile << "$Nodes"
           << "\n";
 
   outfile << nodes.size() << "\n";
 
   outfile << std::uppercase;
-  for (UInt i = 0; i < nodes.size(); ++i) {
-    Int offset = i * nodes.getNbComponent();
+  for (Int i = 0; i < nodes.size(); ++i) {
+    auto offset = i * nodes.getNbComponent();
     outfile << i + 1;
-    for (UInt j = 0; j < nodes.getNbComponent(); ++j) {
+    for (Int j = 0; j < nodes.getNbComponent(); ++j) {
       outfile << " " << nodes.data()[offset + j];
     }
 
     for (UInt p = nodes.getNbComponent(); p < 3; ++p) {
       outfile << " " << 0.;
     }
     outfile << "\n";
     ;
   }
   outfile << std::nouppercase;
   outfile << "$EndNodes"
           << "\n";
 
   outfile << "$Elements"
           << "\n";
   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);
+    const auto & connectivity = mesh.getConnectivity(type, _not_ghost);
     nb_elements += connectivity.size();
   }
   outfile << nb_elements << "\n";
 
   std::map<Element, size_t> element_to_msh_element;
 
-  UInt element_idx = 1;
+  Idx element_idx = 1;
   auto element = ElementNull;
   for (auto && type :
        mesh.elementTypes(_all_dimensions, _not_ghost, _ek_not_defined)) {
     const auto & connectivity = mesh.getConnectivity(type, _not_ghost);
     element.type = type;
 
     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.data();
     }
 
     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.data();
     }
 
     for (auto && data :
          enumerate(make_view(connectivity, connectivity.getNbComponent()))) {
       element.element = std::get<0>(data);
       const auto & conn = std::get<1>(data);
       element_to_msh_element.insert(std::make_pair(element, element_idx));
 
       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] != nullptr) {
           outfile << " " << tag[t][element.element];
         } else {
           outfile << " 0";
         }
       }
 
       for (auto && c : conn) {
         outfile << " " << c + 1;
       }
       outfile << "\n";
       element_idx++;
     }
   }
   outfile << "$EndElements"
           << "\n";
 
   if (mesh.hasData(MeshDataType::_nodal)) {
     auto && tags = mesh.getTagNames();
     for (auto && tag : tags) {
       auto type = mesh.getTypeCode(tag, MeshDataType::_nodal);
       if (type != MeshDataTypeCode::_real) {
         AKANTU_DEBUG_WARNING(
             "The field "
             << tag << " is ignored by the MSH writer, msh files do not support "
             << type << " data");
         continue;
       }
       auto && data = mesh.getNodalData<double>(tag);
       outfile << "$NodeData"
               << "\n";
       outfile << "1"
               << "\n";
       outfile << "\"" << tag << "\"\n";
       outfile << "1\n0.0"
               << "\n";
       outfile << "3\n0"
               << "\n";
       outfile << data.getNbComponent() << "\n";
       outfile << data.size() << "\n";
       for (auto && d : enumerate(make_view(data, data.getNbComponent()))) {
         outfile << std::get<0>(d) + 1;
         for (auto && v : std::get<1>(d)) {
           outfile << " " << v;
         }
         outfile << "\n";
       }
       outfile << "$EndNodeData"
               << "\n";
     }
   }
 
   if (mesh.hasData(MeshDataType::_elemental)) {
     auto && tags = mesh.getTagNames();
     for (auto && tag : tags) {
       auto && data = mesh.getElementalData<double>(tag);
       auto type = mesh.getTypeCode(tag, MeshDataType::_elemental);
       if (type != MeshDataTypeCode::_real) {
         AKANTU_DEBUG_WARNING(
             "The field "
             << tag << " is ignored by the MSH writer, msh files do not support "
             << type << " data");
         continue;
       }
       if (data.isNodal()) {
         continue;
       }
 
       auto size = data.size();
       if (size == 0) {
         continue;
       }
       auto && nb_components = data.getNbComponents();
       auto nb_component = nb_components(*(data.elementTypes().begin()));
 
       outfile << "$ElementData"
               << "\n";
       outfile << "1"
               << "\n";
       outfile << "\"" << tag << "\"\n";
       outfile << "1\n0.0"
               << "\n";
       outfile << "3\n0"
               << "\n";
       outfile << nb_component << "\n";
       outfile << size << "\n";
 
       Element element;
       for (auto type : data.elementTypes()) {
         element.type = type;
         for (auto && _ :
              enumerate(make_view(data(type), nb_components(type)))) {
           element.element = std::get<0>(_);
           outfile << element_to_msh_element[element];
           for (auto && v : std::get<1>(_)) {
             outfile << " " << v;
           }
           outfile << "\n";
         }
       }
       outfile << "$EndElementData"
               << "\n";
     }
   }
 
   outfile.close();
 }
 
 /* --------------------------------------------------------------------------
  */
 
 } // namespace akantu