diff --git a/cmake/libakantu/v3/printers.py b/cmake/libakantu/v3/printers.py
index eca4d1e2b..93344b834 100755
--- a/cmake/libakantu/v3/printers.py
+++ b/cmake/libakantu/v3/printers.py
@@ -1,405 +1,431 @@
 #!/usr/bin/env python3
 # encoding: utf-8
 
 """ printers.py: gdb pretty printers"""
 
 __author__ = "Nicolas Richart"
 __credits__ = [
     "Nicolas Richart <nicolas.richart@epfl.ch>",
 ]
-__copyright__ = "Copyright (©) 2016-2021 EPFL (Ecole Polytechnique Fédérale" \
-                " de Lausanne) Laboratory (LSMS - Laboratoire de Simulation" \
-                " en Mécanique des Solides)"
+__copyright__ = (
+    "Copyright (©) 2016-2021 EPFL (Ecole Polytechnique Fédérale"
+    " de Lausanne) Laboratory (LSMS - Laboratoire de Simulation"
+    " en Mécanique des Solides)"
+)
 __license__ = "LGPLv3"
 
 
 #
 # Inspired from boost's pretty printers from
 # Rüdiger Sonderfeld <ruediger@c-plusplus.de>
 # and from Pretty-printers for libstc++ from Free Software Foundation, Inc.
 #
 import gdb
 import re
 import sys
 import itertools
 
 __use_gdb_pp__ = True
 try:
     import gdb.printing
 except ImportError:
     __use_gdb_pp__ = False
 
 
 class AkantuPrinter(object):
     regex = None
 
     @classmethod
     def supports(cls, typename):
         # print('{0} ~= {1}'.format(typename, cls.regex), file=sys.stderr)
         return cls.regex.search(typename)
 
     @classmethod
     def get_basic_type(cls, value):
-        """ Determines the type associated to a value"""
+        """Determines the type associated to a value"""
 
         _type = value.type
         # If it points to a reference, get the reference.
         if _type.code == gdb.TYPE_CODE_REF:
             _type = _type.target()
 
         # Get the unqualified type, stripped of typedefs.
         _type = _type.unqualified().strip_typedefs()
 
         return _type.tag
 
 
 if __use_gdb_pp__:
-    __akantu_pretty_printers__ = \
-        gdb.printing.RegexpCollectionPrettyPrinter("libakantu-v3")
+    __akantu_pretty_printers__ = gdb.printing.RegexpCollectionPrettyPrinter(
+        "libakantu-v3"
+    )
 else:
+
     class AkantuPrettyPrinters(object):
         def __init__(self, name):
             super(AkantuPrettyPrinters, self).__init__()
             self.name = name
             self.printers = {}
 
         @property
         def enabled(self):
             return True
 
         def add_printer(self, name, regex, printer):
             self.printers[name] = printer
 
         def __call__(self, val):
             typename = AkantuPrinter.get_basic_type(val)
             if not typename:
                 return None
 
             for name, printer in self.printers.items():
-                if(printer.supports(typename)):
+                if printer.supports(typename):
                     return printer
 
             return None
 
     __akantu_pretty_printers__ = AkantuPrettyPrinters("libakantu-v3")
 
 
 def register_pretty_printer(pretty_printer):
     "Registers a Pretty Printer"
 
-    __akantu_pretty_printers__.add_printer(pretty_printer.name,
-                                           pretty_printer.regex,
-                                           pretty_printer)
+    __akantu_pretty_printers__.add_printer(
+        pretty_printer.name, pretty_printer.regex, pretty_printer
+    )
 
     return pretty_printer
 
 
 @register_pretty_printer
 class AkaArrayPrinter(AkantuPrinter):
     """Pretty printer for akantu::Array<T>"""
-    regex = re.compile('^akantu::Array<(.*?), (true|false)>$')
-    name = 'akantu::Array'
+
+    regex = re.compile("^akantu::Array<(.*?), (true|false)>$")
+    name = "akantu::Array"
 
     def __init__(self, value):
         self.typename = self.get_basic_type(value)
         self.value = value
-        self.ptr = self.value['values']
-        self.size = int(self.value['size_'])
-        self.nb_component = int(self.value['nb_component'])
+        self.ptr = self.value["values"]
+        self.size = int(self.value["size_"])
+        self.nb_component = int(self.value["nb_component"])
 
     def display_hint(self):
-        return 'array'
+        return "array"
 
     def to_string(self):
         m = self.regex.search(self.typename)
-        return 'Array<{0}>({1}, {2}) stored at {3}'.format(
-            m.group(1), self.size, self.nb_component, self.ptr)
+        return "Array<{0}>({1}, {2}) stored at {3}".format(
+            m.group(1), self.size, self.nb_component, self.ptr
+        )
 
     def children(self):
         _ptr = self.ptr
         for i in range(self.size):
-            _values = ["{0}".format((_ptr + j).dereference())
-                       for j in range(self.nb_component)]
+            _values = [
+                "{0}".format((_ptr + j).dereference()) for j in range(self.nb_component)
+            ]
             _ptr = _ptr + self.nb_component
-            yield ('[{0}]'.format(i),
-                   ('{0}' if self.nb_component == 1 else '[{0}]').format(
-                       ', '.join(_values)))
+            yield (
+                "[{0}]".format(i),
+                ("{0}" if self.nb_component == 1 else "[{0}]").format(
+                    ", ".join(_values)
+                ),
+            )
 
 
 if sys.version_info[0] > 2:
     # Python 3 stuff
     Iterator = object
 else:
     # Python 2 stuff
     class Iterator:
         """Compatibility mixin for iterators
 
         Instead of writing next() methods for iterators, write
         __next__() methods and use this mixin to make them work in
         Python 2 as well as Python 3.
 
         Idea stolen from the "six" documentation:
         <http://pythonhosted.org/six/#six.Iterator>
         """
+
         def next(self):
             return self.__next__()
 
 
 class RbtreeIterator(Iterator):
     """
     Turn an RB-tree-based container (std::map, std::set etc.) into
     a Python iterable object.
     """
 
     def __init__(self, rbtree):
-        self.size = rbtree['_M_t']['_M_impl']['_M_node_count']
-        self.node = rbtree['_M_t']['_M_impl']['_M_header']['_M_left']
+        self.size = rbtree["_M_t"]["_M_impl"]["_M_node_count"]
+        self.node = rbtree["_M_t"]["_M_impl"]["_M_header"]["_M_left"]
         self.count = 0
 
     def __iter__(self):
         return self
 
     def __len__(self):
         return int(self.size)
 
     def __next__(self):
         if self.count == self.size:
             raise StopIteration
         result = self.node
         self.count = self.count + 1
         if self.count < self.size:
             # Compute the next node.
             node = self.node
-            if node.dereference()['_M_right']:
-                node = node.dereference()['_M_right']
-                while node.dereference()['_M_left']:
-                    node = node.dereference()['_M_left']
+            if node.dereference()["_M_right"]:
+                node = node.dereference()["_M_right"]
+                while node.dereference()["_M_left"]:
+                    node = node.dereference()["_M_left"]
             else:
-                parent = node.dereference()['_M_parent']
-                while node == parent.dereference()['_M_right']:
+                parent = node.dereference()["_M_parent"]
+                while node == parent.dereference()["_M_right"]:
                     node = parent
-                    parent = parent.dereference()['_M_parent']
-                if node.dereference()['_M_right'] != parent:
+                    parent = parent.dereference()["_M_parent"]
+                if node.dereference()["_M_right"] != parent:
                     node = parent
                     self.node = node
         return result
 
 
 def get_value_from_aligned_membuf(buf, valtype):
     """Returns the value held in a __gnu_cxx::__aligned_membuf."""
-    return buf['_M_storage'].address.cast(valtype.pointer()).dereference()
+    return buf["_M_storage"].address.cast(valtype.pointer()).dereference()
 
 
 def get_value_from_Rb_tree_node(node):
     """Returns the value held in an _Rb_tree_node<_Val>"""
     try:
         member = node.type.fields()[1].name
-        if member == '_M_value_field':
+        if member == "_M_value_field":
             # C++03 implementation, node contains the value as a member
-            return node['_M_value_field']
-        elif member == '_M_storage':
+            return node["_M_value_field"]
+        elif member == "_M_storage":
             # C++11 implementation, node stores value in __aligned_membuf
             valtype = node.type.template_argument(0)
-            return get_value_from_aligned_membuf(node['_M_storage'], valtype)
+            return get_value_from_aligned_membuf(node["_M_storage"], valtype)
     except:  # noqa: E722
         pass
     raise ValueError("Unsupported implementation for %s" % str(node.type))
 
 
 def find_type(orig, name):
     typ = orig.strip_typedefs()
     while True:
         # Strip cv-qualifiers.  PR 67440.
-        search = '%s::%s' % (typ.unqualified(), name)
+        search = "%s::%s" % (typ.unqualified(), name)
         try:
             return gdb.lookup_type(search)
         except RuntimeError:
             pass
         # The type was not found, so try the superclass.  We only need
         # to check the first superclass, so we don't bother with
         # anything fancier here.
         field = typ.fields()[0]
         if not field.is_base_class:
             raise ValueError("Cannot find type %s::%s" % (str(orig), name))
         typ = field.type
 
 
 @register_pretty_printer
 class AkaElementTypeMapArrayPrinter(AkantuPrinter):
     """Pretty printer for akantu::ElementTypeMap<Array<T>>"""
-    regex = re.compile('^akantu::ElementTypeMap<akantu::Array<(.*?), (true|false)>\*, akantu::(.*?)>$')  # noqa: E501,W605
-    name = 'akantu::ElementTypeMapArray'
+
+    regex = re.compile(
+        "^akantu::ElementTypeMap<akantu::Array<(.*?), (true|false)>\*, akantu::(.*?)>$"
+    )  # noqa: E501,W605
+    name = "akantu::ElementTypeMapArray"
 
     # Turn an RbtreeIterator into a pretty-print iterator.
     class _rb_iter(Iterator):
         def __init__(self, rbiter, type, ghost_type):
             self.rbiter = rbiter
             self.count = 0
             self.type = type
             self.ghost_type = ghost_type
 
         def __iter__(self):
             return self
 
         def __next__(self):
             if self.count % 2 == 0:
                 n = next(self.rbiter)
                 n = n.cast(self.type).dereference()
                 n = get_value_from_Rb_tree_node(n)
                 self.pair = n
-                item = "{0}:{1}".format(n['first'], self.ghost_type)
+                item = "{0}:{1}".format(n["first"], self.ghost_type)
             else:
-                item = self.pair['second'].dereference()
-            result = ('[{0}]'.format(self.count), item)
+                item = self.pair["second"].dereference()
+            result = ("[{0}]".format(self.count), item)
             self.count = self.count + 1
             return result
 
     def _iter(self, not_ghost, ghost, type):
         iter_size = (len(not_ghost), len(ghost))
-        it = self._rb_iter(not_ghost, type, '_not_ghost')
+        it = self._rb_iter(not_ghost, type, "_not_ghost")
         for _ in range(iter_size[0] * 2):
             yield next(it)
 
-        it = self._rb_iter(ghost, type, '_ghost')
+        it = self._rb_iter(ghost, type, "_ghost")
         for _ in range(iter_size[1] * 2):
             yield next(it)
 
         raise StopIteration
 
     def __init__(self, value):
         self.typename = self.get_basic_type(value)
         self.value = value
-        self.data = self.value['data']
-        self.ghost_data = self.value['ghost_data']
+        self.data = self.value["data"]
+        self.ghost_data = self.value["ghost_data"]
 
     def to_string(self):
         m = self.regex.search(self.typename)
-        return 'ElementTypMapArray<{0}> with '\
-            '{1} _not_ghost and {2} _ghost'.format(
-                m.group(1), len(RbtreeIterator(self.data)),
-                len(RbtreeIterator(self.ghost_data)))
+        return "ElementTypMapArray<{0}> with " "{1} _not_ghost and {2} _ghost".format(
+            m.group(1),
+            len(RbtreeIterator(self.data)),
+            len(RbtreeIterator(self.ghost_data)),
+        )
 
     def children(self):
         # m = self.regex.search(self.typename)
-        rep_type = find_type(self.data.type, '_Rep_type')
-        node = find_type(rep_type, '_Link_type')
+        rep_type = find_type(self.data.type, "_Rep_type")
+        node = find_type(rep_type, "_Link_type")
         node = node.strip_typedefs()
 
         return itertools.chain(
             self._rb_iter(RbtreeIterator(self.data), node, "_not_ghost"),
-            self._rb_iter(RbtreeIterator(self.ghost_data), node, "_ghost"))
+            self._rb_iter(RbtreeIterator(self.ghost_data), node, "_ghost"),
+        )
 
     def display_hint(self):
-        return 'map'
+        return "map"
 
 
 # @register_pretty_printer
 class AkaTensorPrinter(AkantuPrinter):
     """Pretty printer for akantu::Tensor<T>"""
-    regex = re.compile('^akantu::Tensor<(.*), +(.*), +(.*)>$')
-    name = 'akantu::Tensor'
+
+    regex = re.compile("^akantu::Tensor<(.*), +(.*), +(.*)>$")
+    name = "akantu::Tensor"
 
     value = None
     typename = ""
     ptr = None
     dims = []
     ndims = 0
 
     def pretty_print(self):
         def ij2str(i, j, m):
-            return "{0}".format((self.ptr+m*j + i).dereference())
+            return "{0}".format((self.ptr + m * j + i).dereference())
 
         def line(i, m, n):
-            return "[{0}]".format(", ".join((ij2str(i, j, m) for j in
-                                             range(n))))
+            return "[{0}]".format(", ".join((ij2str(i, j, m) for j in range(n))))
 
         m = int(self.dims[0])
-        if (self.ndims == 1):
+        if self.ndims == 1:
             n = 1
         else:
             n = int(self.dims[1])
 
         return "[{0}]".format(", ".join(line(i, m, n) for i in range(m)))
 
     def __init__(self, value):
         self.typename = self.get_basic_type(value)
         self.value = value
-        self.ptr = self.value['values']
-        self.dims = self.value['n']
+        self.ptr = self.value["values"]
+        self.dims = self.value["n"]
 
     def children(self):
-        yield ('values', self.pretty_print())
-        yield ('wrapped', self.value['wrapped'])
+        yield ("values", self.pretty_print())
+        yield ("wrapped", self.value["wrapped"])
 
 
 @register_pretty_printer
 class AkaVectorPrinter(AkaTensorPrinter):
     """Pretty printer for akantu::Vector<T>"""
-    regex = re.compile('^akantu::Vector<(.*)>$')
-    name = 'akantu::Vector'
+
+    regex = re.compile("^akantu::Vector<(.*)>$")
+    name = "akantu::Vector"
     n = 0
     ptr = 0x0
 
     def __init__(self, value):
         super(AkaVectorPrinter, self).__init__(value)
         self.ndims = 1
 
     def to_string(self):
         m = self.regex.search(self.typename)
-        return 'Vector<{0}>({1}) [{2}]'.format(m.group(1), int(self.dims[0]),
-                                               str(self.ptr))
+        return "Vector<{0}>({1}) [{2}]".format(
+            m.group(1), int(self.dims[0]), str(self.ptr)
+        )
 
 
 @register_pretty_printer
 class AkaMatrixPrinter(AkaTensorPrinter):
     """Pretty printer for akantu::Matrix<T>"""
-    regex = re.compile('^akantu::Matrix<(.*)>$')
-    name = 'akantu::Matrix'
+
+    regex = re.compile("^akantu::Matrix<(.*)>$")
+    name = "akantu::Matrix"
 
     def __init__(self, value):
         super(AkaMatrixPrinter, self).__init__(value)
         self.ndims = 2
 
     def to_string(self):
         m = self.regex.search(self.typename)
-        return 'Matrix<%s>(%d, %d) [%s]' % (m.group(1), int(self.dims[0]),
-                                            int(self.dims[1]),
-                                            str(self.ptr))
+        return "Matrix<%s>(%d, %d) [%s]" % (
+            m.group(1),
+            int(self.dims[0]),
+            int(self.dims[1]),
+            str(self.ptr),
+        )
 
 
 @register_pretty_printer
 class AkaElementPrinter(AkantuPrinter):
     """Pretty printer for akantu::Element"""
-    regex = re.compile('^akantu::Element$')
-    name = 'akantu::Element'
+
+    regex = re.compile("^akantu::Element$")
+    name = "akantu::Element"
 
     def __init__(self, value):
         self.typename = self.get_basic_type(value)
         self.value = value
 
-        self.element = self.value['element']
-        self.eltype = self.value['type']
-        self.ghost_type = self.value['ghost_type']
-        self._ek_not_defined = gdb.parse_and_eval('akantu::_not_defined')
-        self._casper = gdb.parse_and_eval('akantu::_casper')
-        self._max_uint = gdb.parse_and_eval('(akantu::UInt) -1')
+        self.element = self.value["element"]
+        self.eltype = self.value["type"]
+        self.ghost_type = self.value["ghost_type"]
+        self._ek_not_defined = gdb.parse_and_eval("akantu::_not_defined")
+        self._casper = gdb.parse_and_eval("akantu::_casper")
+        self._max_uint = gdb.parse_and_eval("(akantu::Int) -1")
 
     def to_string(self):
-        if (self.element == self._max_uint) and \
-           (self.eltype == self._ek_not_defined) and \
-           (self.ghost_type == self._casper):
-            return 'ElementNull'
-
-        return 'Element({0}, {1}, {2})'.format(self.element, self.eltype,
-                                               self.ghost_type)
+        if (
+            (self.element == self._max_uint)
+            and (self.eltype == self._ek_not_defined)
+            and (self.ghost_type == self._casper)
+        ):
+            return "ElementNull"
+
+        return "Element({0}, {1}, {2})".format(
+            self.element, self.eltype, self.ghost_type
+        )
 
 
 def register_akantu_printers(obj):
     "Register Akantu Pretty Printers."
 
     if __use_gdb_pp__:
         gdb.printing.register_pretty_printer(obj, __akantu_pretty_printers__)
     else:
         if obj is None:
             obj = gdb
         obj.pretty_printers.append(__akantu_pretty_printers__)
diff --git a/doc/coding_convention/snippet/for b/doc/coding_convention/snippet/for
index 8bd190800..4973bc15a 100644
--- a/doc/coding_convention/snippet/for
+++ b/doc/coding_convention/snippet/for
@@ -1,5 +1,5 @@
 #name : for (...; ...; ...) { ... }
 # --
-for (${1:UInt ${2:i} = 0}; ${3:$2 < N}; ${4:++$2}) {
+for (${1:Int ${2:i} = 0}; ${3:$2 < N}; ${4:++$2}) {
     $0
 }
diff --git a/doc/dev-doc/manual/getting_started.rst b/doc/dev-doc/manual/getting_started.rst
index 90ac8abd7..e62a2927c 100644
--- a/doc/dev-doc/manual/getting_started.rst
+++ b/doc/dev-doc/manual/getting_started.rst
@@ -1,496 +1,496 @@
 Getting Started
 ===============
 
 Building ``Akantu``
 --------------------
 
 Dependencies
 ````````````
 
 In order to compile ``Akantu``  any compiler supporting fully C++14 should work.
 In addition some libraries are required:
 
  - CMake (>= 3.5.1)
  - Boost (preprocessor and Spirit)
  - zlib
  - blas/lapack
 
 For the python interface:
 
  - Python (>=3 is recommended)
  - pybind11 (if not present the build system will try to download it)
 
 To run parallel simulations:
 
  - MPI
  - Scotch
 
 To use the static or implicit dynamic solvers at least one of the following libraries is needed:
 
  - MUMPS (since this is usually compiled in static you also need MUMPS dependencies)
  - PETSc
 
 To compile the tests and examples:
 
  - Gmsh
  - google-test (if not present the build system will try to download it)
 
 Configuring and compilation
 ```````````````````````````
 
 ``Akantu`` is a `CMake <https://cmake.org/>`_ project, so to configure it, you can either
 follow the usual way::
 
   > cd akantu
   > mkdir build
   > cd build
   > ccmake ..
   [ Set the options that you need ]
   > make
   > make install
 
 Using the python interface
 --------------------------
 
 You can install ``Akantu`` using pip::
 
   > pip install akantu
 
 You can then import the package in a python script as::
 
   import akantu
 
 The python API is similar to the C++ one, see :ref:`reference` . If you encouter any problem with the python interface, you are welcome to do a merge request or post an issue on `GitLab <https://gitlab.com/akantu/akantu/-/issues>`_ .
   
 Tutorials with the python interface
 ```````````````````````````````````    
 
 To help getting started, several tutorials using the python interface
 are available as notebooks with pre-installed version of ``Akantu`` on Binder.
 The following tutorials are currently available:
 
 `Plate whith a hole loaded <https://mybinder.org/v2/git/https%3A%2F%2Fgitlab.com%2Fakantu%2Ftutorials.git/HEAD?filepath=plate-hole/plate-hole.ipynb>`_
 
 `Loaded cohesive crack <https://mybinder.org/v2/git/https%3A%2F%2Fgitlab.com%2Fakantu%2Ftutorials.git/HEAD?filepath=cohesive-fracture/cohesive-fracture.ipynb>`_
 
 `Making your constitutive law in python <https://mybinder.org/v2/git/https%3A%2F%2Fgitlab.com%2Fakantu%2Ftutorials.git/HEAD?filepath=constitutive-laws/python_constitutive_law.ipynb>`_
 
 
 Writing a ``main`` function
 ---------------------------
 
 ``Akantu`` first 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
 the function :cpp:func:`initialize <akantu::initialize>` that is used as
 follows::
 
     #include "aka_common.hh"
     #include "..."
 
     using namespace akantu;
 
     int main(int argc, char *argv[]) {
       initialize("input_file.dat", argc, argv);
 
       // your code ...
 
     }
 
 The :cpp:func:`initialize <akantu::initialize>` function takes the text inpute
 file and the program parameters which can be parsed by ``Akantu`` in due form
 (see sect:parser). Obviously it is necessary to include all files needed in
 main. In this manual all provided code implies the usage of ``akantu`` as
 namespace.
 
 Compiling your simulation
 -------------------------
 
 The easiest way to compile your simulation is to create a ``cmake`` project by
 putting all your code in some directory of your choosing. Then, make sure that
 you have ``cmake`` installed and create a ``CMakeLists.txt`` file. An example of
 a minimal ``CMakeLists.txt`` file would look like this:
 
 .. code-block:: cmake
 
    project(my_simu)
    cmake_minimum_required(VERSION 3.0.0)
 
    find_package(Akantu REQUIRED)
 
    add_akantu_simulation(my_simu my_simu.cc)
 
 Then create a directory called ``build`` and inside it execute ``cmake
 -DAkantu_DIR=<path_to_akantu> -DCMAKE_BUILD_TYPE=RelWithDebInfo ..``. If you
 installed ``Akantu`` in a standard directory such as ``/usr/local`` (using
 ``make install``), you can omit the ``-DAkantu_DIR=<path_to_akantu>`` option.
 
 Other why ``path_to_akantu`` is either the folder where you built ``Akantu`` if
 you did not do a ``make install``, or if you installed ``Akantu`` in
 ``CMAKE_INSTALL_PREFIX`` it is ``<CMAKE_INSTALL_PREFIX>/share/cmake/Akantu``.
 
 Once ``cmake`` managed to configure and generate a ``makefile`` you can just do
 ``make``
 
 
 .. _loading_mesh:
 
 Creating and Loading a Mesh
 ---------------------------
 
 In its current state, ``Akantu`` supports three types of meshes: Gmsh, Abaqus and
 Diana. Once a :cpp:class:`akantu::Mesh` object is created with a given spatial
 dimension, it can be filled by reading a mesh input file. The method
 :cpp:func:`read <akantu::Mesh::read>` of the class :cpp:class:`Mesh
 <akantu::Mesh>` infers the mesh type from the file extension. If a non-standard
 file extension is used, the mesh type has to be specified. ::
 
-    UInt spatial_dimension = 2;
+    Int spatial_dimension = 2;
     Mesh mesh(spatial_dimension);
 
     // Reading Gmsh files
     mesh.read("my_gmsh_mesh.msh");
     mesh.read("my_gmsh_mesh", _miot_gmsh);
 
 The Gmsh reader adds the geometrical and physical tags as mesh data. The
-physical values are stored as a :cpp:type:`UInt <akantu::UInt>` data called
+physical values are stored as a :cpp:type:`Int <akantu::Int>` data called
 ``tag_0``, if a string name is provided it is stored as a ``std::string`` data
-named ``physical_names``. The geometrical tag is stored as a :cpp:type:`UInt
-<akantu::UInt>` data named ``tag_1``.
+named ``physical_names``. The geometrical tag is stored as a :cpp:type:`Int
+<akantu::Int>` data named ``tag_1``.
 
 Using Arrays
 ------------
 
 Data in ``Akantu`` can be stored in data containers implemented by the
 :cpp:class:`akantu::Array` class. In its most basic usage, the :cpp:class:`Array
 <akantu::Array>` class implemented in \akantu is similar to the ``std::vector``
 class of the Standard Template Library (STL) for C++. A simple :cpp:class:`Array
 <akantu::Array>` containing a sequence of ``nb_element`` values (of a given
 type) can be generated with::
 
   Array<type> example_array(nb_element);
 
 where ``type`` usually is :cpp:type:`Real <akantu::Real>`, :cpp:type:`Int
 <akantu::Int>`, :cpp:type:`UInt <akantu::UInt>` or ``bool``. Each value is
 associated to an index, so that data can be accessed by typing::
 
   auto & val = example_array(index);
 
 ``Arrays`` can also contain tuples of values for each index. In that case, the
 number of components per tuple must be specified at the :cpp:class:`Array
 <akantu::Array>` creation. For example, if we want to create an
 :cpp:class:`Array <akantu::Array>` to store the coordinates (sequences of three
 values) of ten nodes, the appropriate code is the following::
 
   UInt nb_nodes = 10;
   UInt spatial_dimension = 3;
 
   Array<Real> position(nb_nodes, spatial_dimension);
 
 In this case the :math:`x` position of the eighth node number will be given
 by ``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 :cpp:class:`Array <akantu::Array>`:
 
   - :cpp:func:`resize(size) <akantu::ArrayDataLayer::resize>` change the size of
     the :cpp:class:`Array <akantu::Array>`.
   - :cpp:func:`clear <akantu::Array::clear>` reset the size of the
     :cpp:class:`Array <akantu::Array>` to zero. (*warning* this changed in >
     v4.0)
   - :cpp:func:`set(t) <akantu::Array::set>` set all entries of the
     :cpp:class:`Array <akantu::Array>` to ``t``.
   - :cpp:func:`copy(const Array & other) <akantu::Array::copy>` copy another
     :cpp:class:`Array <akantu::Array>` into the current one. The two
     :cpp:class:`Arrays <akantu::Array>` should have the same number of
     components.
   - :cpp:func:`push_back(tuple) <akantu::Array::push_back>` append a tuple with
     the correct number of components at the end of the :cpp:class:`Array <akantu::Array>`.
   - :cpp:func:`erase(i) <akantu::Array::erase>` erase the value at the i-th position.
   - :cpp:func:`find(value) <akantu::Array::find>` search ``value`` in the
     current :cpp:class:`Array <akantu::Array>`. Return position index of the
     first occurence or -1 if not found.
   - :cpp:func:`storage() <akantu::Array::storage>` Return the address of the
     allocated memory of the :cpp:class:`Array <akantu::Array>`.
 
 Array 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 :cpp:class:`Array <akantu::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::
 
   // accessing the nodal coordinates Array
   // with spatial_dimension components
   const auto & nodes = mesh.getNodes();
 
   for (const auto & coords : make_view(nodes, spatial_dimension)) {
     // do what you need ....
   }
 
 In that example, each ``coords`` is a :cpp:class:`Vector\<Real\> <akantu::Vector>`
 containing geometrical array of size ``spatial_dimension`` and the iteration is
 conveniently performed by the :cpp:class:`Array <akantu::Array>` iterator.
 
 The :cpp:class:`Array <akantu::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 :cpp:func:`make_view <akantu::make_view>`. For instance,
 assuming that we have a :cpp:class:`Array <akantu::Array>` storing stresses, we
 can loop over the stored tensors by::
 
    for (const auto & stress :
      make_view(stresses, spatial_dimension, spatial_dimension)) {
      // stress is of type `const Matrix<Real>&`
    }
 
 In that last example, the :cpp:class:`Matrix\<Real\> <akantu::Matrix>` objects are
 ``spatial_dimension`` :math:`\times` ``spatial_dimension`` matrices. The light
 objects :cpp:class:`Matrix\<T\> <akantu::Matrix>` and
 :cpp:class:`Vector\<T\> <akantu::Vector>` can be used and combined to do most
 common linear algebra. If the number of component is 1, it is possible to use
 :cpp:func:`make_view <akantu::make_view>` to this effect.
 
 
 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
 :cpp:class:`ElementTypeMapArray\<T\> <akantu::ElementTypeMapArray>` is provided
 to easily manage this kind of data. It consists of a group of ``Arrays``, each
 associated to an element type. The following code can retrieve the
 :cpp:class:`ElementTypeMapArray\<UInt\> <akantu::ElementTypeMapArray>` which
 stores the connectivity arrays for a mesh::
 
   const ElementTypeMapArray<UInt> & connectivities =
     mesh.getConnectivities();
 
 Then, the specific array associated to a given element type can be obtained by::
 
   const Array<UInt> & connectivity_triangle =
     connectivities(_triangle_3);
 
 where the first order 3-node triangular element was used in the presented piece
 of code.
 
 Vector & Matrix
 ```````````````
 
 The :cpp:class:`Array\<T\> <akantu::Array>` iterators as presented in the previous
 section can be shaped as :cpp:class:`Vector\<T\> <akantu::Vector>` or
 :cpp:class:`Matrix\<T\> <akantu::Matrix>`. This objects represent 1st and 2nd order
 tensors. As such they come with some functionalities that we will present a bit
 more into detail in this here.
 
 
 ``Vector<T>``
 '''''''''''''
 
 - Accessors:
 
   - :cpp:func:`v(i) <akantu::Vector::operator()>` gives the ``i`` -th
     component of the vector ``v``
   - :cpp:func:`v[i] <akantu::Vector::operator[]>` gives the ``i`` -th
     component of the vector ``v``
   - :cpp:func:`v.size() <akantu::Vector::size>` gives the number of component
 
 - Level 1: (results are scalars)
 
   - :cpp:func:`v.norm() <akantu::Vector::norm>` returns the geometrical norm
     (:math:`L_2`)
   - :cpp:func:`v.norm\<N\>() <akantu::Vector::norm<>>` returns the :math:`L_N`
     norm defined as :math:`\left(\sum_i |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, ``L_1`` for the Manhattan norm, ``L_2`` for the
     geometrical norm and ``L_inf`` for the norm infinity.
   - :cpp:func:`v.dot(x) <akantu::Vector::dot>` return the dot product of
     ``v`` and ``x``
   - :cpp:func:`v.distance(x) <akantu::Vector::distance>` return the
     geometrical norm of :math:`v - x`
 
 - Level 2: (results are vectors)
 
   - :cpp:func:`v += s <akantu::Vector::operator+=>`,
     :cpp:func:`v -= s <akantu::Vector::operator-=>`,
     :cpp:func:`v *= s <akantu::Vector::operator*=>`,
     :cpp:func:`v /= s <akantu::Vector::operator/=>` those are element-wise
     operators that sum, substract, multiply or divide all the component of ``v``
     by the scalar ``s``
   - :cpp:func:`v += x <akantu::Vector::operator+=>`, :cpp:func:`v -= x
     <akantu::Vector::operator-=>` sums or substracts the vector ``x`` to/from
     ``v``
   - :cpp:func:`v.mul(A, x, alpha) <akantu::Vector::mul>` stores the result of
     :math:`\alpha \boldsymbol{A} \vec{x}` in ``v``, :math:`\alpha` is equal to 1
     by default
   - :cpp:func:`v.solve(A, b) <akantu::Vector::solve>` stores the result of
     the resolution of the system :math:`\boldsymbol{A} \vec{x} = \vec{b}` in ``v``
   - :cpp:func:`v.crossProduct(v1, v2) <akantu::Vector::crossProduct>`
     computes the cross product of ``v1`` and ``v2`` and stores the result in
     ``v``
 
 ``Matrix<T>``
 '''''''''''''
 
 - Accessors:
 
   - :cpp:func:`A(i, j) <akantu::Matrix::operator()>` gives the component
     :math:`A_{ij}` of the matrix ``A``
   - :cpp:func:`A(i) <akantu::Matrix::operator()>` gives the :math:`i^{th}`
     column of the matrix as a ``Vector``
   - :cpp:func:`A[k] <akantu::Matrix::operator[]>` gives the :math:`k^{th}`
     component of the matrix, matrices are stored in a column major way, which
     means that to access :math:`A_{ij}`, :math:`k = i + j M`
   - :cpp:func:`A.rows() <akantu::Matrix::rows>` gives the number of rows of
     ``A`` (:math:`M`)
   - :cpp:func:`A.cols() <akantu::Matrix::cols>` gives the number of columns
     of ``A`` (:math:`N`)
   - :cpp:func:`A.size() <akantu::Matrix::size>` gives the number of component
     in the matrix (:math:`M \times N`)
 
 - Level 1: (results are scalars)
 
   - :cpp:func:`A.norm() <akantu::Matrix::norm>` is equivalent to
     ``A.norm<L_2>()``
   - :cpp:func:`A.norm\<N\>() <akantu::Matrix::norm<>>` returns the :math:`L_N`
     norm defined as :math:`\left(\sum_i\sum_j |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, ``L_1`` for the Manhattan norm, ``L_2`` for the
     geometrical norm and ``L_inf`` for the norm infinity.
   - :cpp:func:`A.trace() <akantu::Matrix::trace>` return the trace of ``A``
   - :cpp:func:`A.det() <akantu::Matrix::det>` return the determinant of ``A``
   - :cpp:func:`A.doubleDot(B) <akantu::Matrix::doubleDot>` return the double
     dot product of ``A`` and ``B``, :math:`\mat{A}:\mat{B}`
 
 - Level 3: (results are matrices)
 
   - :cpp:func:`A.eye(s) <akantu::Matrix::eye>`, ``Matrix<T>::eye(s)``
     fills/creates a matrix with the :math:`s\mat{I}` with :math:`\mat{I}` the
     identity matrix
   - :cpp:func:`A.inverse(B) <akantu::Matrix::inverse>` stores
     :math:`\mat{B}^{-1}` in ``A``
   - :cpp:func:`A.transpose() <akantu::Matrix::transpose>` returns
     :math:`\mat{A}^{t}`
   - :cpp:func:`A.outerProduct(v1, v2) <akantu::Matrix::outerProduct>` stores
     :math:`\vec{v_1} \vec{v_2}^{t}` in ``A``
   - :cpp:func:`C.mul\<t_A, t_B\>(A, B, alpha) <akantu::Matrix::mul>`: stores
     the result of the product of ``A`` and code{B} time the scalar ``alpha`` in
     ``C``. ``t_A`` and ``t_B`` are boolean defining if ``A`` and ``B`` should be
     transposed or not.
 
     +----------+----------+--------------+
     |``t_A``   |``t_B``   |result        |
     |          |          |              |
     +----------+----------+--------------+
     |false     |false     |:math:`\mat{C}|
     |          |          |= \alpha      |
     |          |          |\mat{A}       |
     |          |          |\mat{B}`      |
     |          |          |              |
     +----------+----------+--------------+
     |false     |true      |:math:`\mat{C}|
     |          |          |= \alpha      |
     |          |          |\mat{A}       |
     |          |          |\mat{B}^t`    |
     |          |          |              |
     +----------+----------+--------------+
     |true      |false     |:math:`\mat{C}|
     |          |          |= \alpha      |
     |          |          |\mat{A}^t     |
     |          |          |\mat{B}`      |
     |          |          |              |
     +----------+----------+--------------+
     |true      |true      |:math:`\mat{C}|
     |          |          |= \alpha      |
     |          |          |\mat{A}^t     |
     |          |          |\mat{B}^t`    |
     +----------+----------+--------------+
 
   - :cpp:func:`A.eigs(d, V) <akantu::Matrix::eigs>` this method computes the
     eigenvalues and eigenvectors of ``A`` and store the results in ``d`` and
     ``V`` such that :math:`d(i) = \lambda_i` and :math:`V(i) = \vec{v_i}` with
     :math:`\mat{A}\vec{v_i} = \lambda_i\vec{v_i}` and :math:`\lambda_1 > ... >
     \lambda_i > ... > \lambda_N`
 
 
 .. _sect-common-groups:
 
 Mesh
 ----
 
 
 
 Manipulating group of nodes and/or elements
 ```````````````````````````````````````````
 
 ``Akantu`` provides the possibility to manipulate subgroups of elements and
 nodes. Any :cpp:class:`ElementGroup <akantu::ElementGroup>` and/or
 :cpp:class:`NodeGroup <akantu::NodeGroup>` must be managed by a
 :cpp:class:`GroupManager <akantu::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 :cpp:class:`Mesh
 <akantu::Mesh>` class which inherits from :cpp:class:`GroupManager
 <akantu::GroupManager>`.
 
 For instance, the following code shows how to request an element group
 to a mesh:
 
 .. code-block:: c++
 
   // 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 */
 
 
 The ``NodeGroup`` object
 ''''''''''''''''''''''''
 
 A group of nodes is stored in :cpp:class:`NodeGroup <akantu::NodeGroup>`
 objects. They are quite simple objects which store the indexes of the selected
 nodes in a :cpp:class:`Array\<UInt\> <akantu::Array>`. Nodes are selected by
 adding them when calling :cpp:func:`add <akantu::NodeGroup::add>`. For instance
 you can select nodes having a positive :math:`X` coordinate with the following
 code:
 
 .. code-block:: c++
 
   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);
   }
 
 
 The ``ElementGroup`` object
 '''''''''''''''''''''''''''
 
 A group of elements is stored in :cpp:class:`ElementGroup
 <akantu::ElementGroup>` objects. Since a group can contain elements of various
 types the :cpp:class:`ElementGroup <akantu::ElementGroup>` object stores indexes
 in a :cpp:class:`ElementTypeMapArray\<UInt\> <akantu::ElementTypeMapArray>`
 object. Then elements can be added to the group by calling :cpp:func:`add
 <akantu::ElementGroup::add>`.
 
 For instance, selecting the elements for which the barycenter of the
 nodes has a positive :math:`X` coordinate can be made with:
 
 .. code-block:: c++
 
    auto & group = mesh.createElementGroup("XpositiveElement");
    Vector<Real> barycenter(spatial_dimension);
 
    for_each_element(mesh, [&](auto && element) {
      mesh.getBarycenter(element, barycenter);
      if (barycenter(_x) > 0.) { group.add(element); }
    });
diff --git a/doc/manual/manual-changelog.tex b/doc/manual/manual-changelog.tex
index 8e7b937f1..5a752203f 100644
--- a/doc/manual/manual-changelog.tex
+++ b/doc/manual/manual-changelog.tex
@@ -1,47 +1,47 @@
 \chapter*{Changes, New Features, and Fixes}
 
 \section*{Version 3.0.0}
 
 \begin{itemize}
 \item[\textbf{\texttt{c++14}}] Switch from C++ standard \code{2003} to \code{2014}\\
   Example of changes implied by this:
   \begin{cpp}
- for (UInt g = _not_ghost; g <= _ghost; ++g) {
+ for (Int g = _not_ghost; g <= _ghost; ++g) {
    GhostType gt = (GhostType)g;
    Mesh::type_iterator it = this->mesh.firstType(spatial_dimension, gt);
    Mesh::type_iterator end = this->mesh.lastType(spatial_dimension, gt);
    for (; it != end; ++it) {
      ElementType & type = *it;
        ...
    }
  }
 \end{cpp}
 becomes
   \begin{cpp}
  for (auto ghost_type : ghost_types) {
    for (auto type : mesh.elementTypes(spatial_dimension,
                                       ghost_type)) {
      ...
    }
  }
 \end{cpp}
 \item[\textbf{\texttt{feature}}] Parallel cohesive elements
 \item[\textbf{\texttt{feature}}] Models using new interface for solvers
   \begin{itemize}
   \item Same configuration for all models
   \item Solver can be configured in input file
   \item PETSc interface temporary inactive
   \item Periodic boundary condition temporary inactive
   \end{itemize}
 \item[\textbf{\texttt{feature}}] Element groups created by default for \code{``physical\_names''}
 \item[\textbf{\texttt{feature}}] Named arguments for functions (e.g. \code{model.initFull(\_analysis\_method = \_static)})
 
 \item[\textbf{\texttt{api}}] Only one function to solve a step \code{model.solveStep()}
 \item[\textbf{\texttt{api}}] Simplification of the parallel simulation with the
   \code{mesh.distribute()} function
 
 \end{itemize}
 %%% Local Variables:
 %%% mode: latex
 %%% TeX-master: "manual"
 %%% End:
diff --git a/doc/manual/manual-feengine.tex b/doc/manual/manual-feengine.tex
index ef64c823e..4e5d2649c 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,
+				 const Int 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,
+                                    Int 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,
+               Int 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
+Int sp_dim = 3; //spatial dimension
+Int 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<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 573f19639..8d7d873d4 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;
+Int 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
+values are stored as a \code{Int} 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{physical\_names}. The geometrical tag is stored as a \code{Int} 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;
+%   Int 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;
+  Int nb_nodes = 10;
+  Int 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<Idx> & connectivities = mesh.getConnectivities();
 \end{cpp}
 Then, the specific array associated to a given element type can be obtained by
 \begin{cpp}
   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<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<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);
+    Int nb_element  = mesh.getNbElement(type);
 
-    for(UInt e = 0; e < nb_element; ++e) {
+    for(Int 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/doc/manual/manual-heattransfermodel.tex b/doc/manual/manual-heattransfermodel.tex
index cd980f706..d95a6d339 100644
--- a/doc/manual/manual-heattransfermodel.tex
+++ b/doc/manual/manual-heattransfermodel.tex
@@ -1,163 +1,163 @@
 \chapter{Heat Transfer Model}
 
 The heat transfer model is a specific implementation of the \code{Model} interface
 dedicated to handle the dynamic heat equation.
 \section{Theory}
 The strong form of the dynamic heat equation
 can be expressed as
 \begin{equation}
   \rho c_v \dot{T} + \nabla \cdot \vec{\kappa} \nabla T = b
 \end{equation}
 with $T$ the scalar temperature field,
 $c_v$ the specific heat capacity,
 $\rho$ the mass density,
 $\mat{\kappa}$ the conductivity tensor, and $b$ the heat generation per unit of volume.
 The discretized weak form with a finite number of elements is
 \begin{equation}
   \forall i \quad
   \sum_j \left( \int_\Omega \rho c_v N_j N_i  d\Omega \right) \dot{T}_j
   - \sum_j \left( \int_\Omega \vec{\kappa} \nabla N_j \nabla N_i d\Omega \right) T_j =
   - \int_{\Gamma}  N_i \vec{q} \cdot \vec{n} d\Gamma + \int_\Omega b N_i d\Omega
 \end{equation}
 with $i$ and $j$ the node indices, $\vec{n}$ the normal field to the surface
 $\Gamma = \partial \Omega$.
 To simplify, we can define the capacity and the conductivity matrices as
 \begin{equation}
   C_{ij} = \int_\Omega \rho c_v N_j N_i  d\Omega \qquad \textrm{and} \qquad
   K_{ij} = - \int_\Omega \vec{\kappa} \nabla N_j \nabla N_i d\Omega
 \end{equation}
 and the system to solve can be written
 \begin{equation}
   \mat{C} \cdot \vec{\dot{T}} = \vec{Q}^{\text{ext}} -\mat{K} \cdot \vec{T}~,
 \end{equation}
 with $\vec{Q}^{\text{ext}}$ the consistent heat generated.
 
 \section{Using the Heat Transfer Model}
 A material file name has to be provided during initialization.
 Currently, the \code{HeatTransferModel} object uses dynamic analysis
 with an explicit time integration scheme.  It can simply be created
 like this
 \begin{cpp}
   HeatTransferModel model(mesh, spatial_dimension);
 \end{cpp}
 while an existing mesh has been used (see \ref{sect:common:mesh}).
 Then the model object can be initialized with:
 \begin{cpp}
   model.initFull()
 \end{cpp}
 This function will load the material
 properties, and allocate / initialize the nodes and element \code{Array}s
 More precisely, the heat transfer model contains 4 \code{Arrays}:
 \begin{description}
 \item[temperature] contains the nodal temperature $T$ (zero  by   default  after  the
   initialization).
 \item[temperature\_rate] contains the variations of temperature $\dot{T}$
   (zero  by   default  after  the
   initialization).
 \item[blocked\_dofs] contains a Boolean value for each degree of
   freedom specifying whether the degree is blocked or not. A Dirichlet
   boundary condition ($T_d$) can be prescribed by setting the
   \textbf{blocked\_dofs} value of a degree of freedom to \code{true}.
   The \textbf{temperature} and the \textbf{temperature\_rate} are
   computed for all degrees of freedom where the \textbf{blocked\_dofs}
   value is set to \code{false}.  For the remaining degrees of freedom,
   the imposed values (zero by default after initialization) are kept.
 \item[external\_heat\_rate] contains the external heat generations.  $\vec{Q^{ext}}$
   on the nodes.
 \item[internal\_heat\_rate] contains the internal heat generations.  $\vec{Q^{int}} =  -\mat{K} \cdot \vec{T}$  on the nodes.
 \end{description}
 
 Only a single material can be specified on the domain.
 A material text file (\eg material.dat) provides the material properties as follows:
 \begin{cpp}
   model heat_transfer_model [
     capacity = %\emph{XXX}%
     density = %\emph{XXX}%
     conductivity = [%\emph{XXX}% ... %\emph{XXX}%]
   ]
 \end{cpp}
 where the \code{capacity} and \code{density} are scalars, and the \code{conductivity} is specified as a $3\times 3$ tensor.
 
 \subsection{Explicit Dynamic}
 
 The explicit  time integration scheme in \akantu  uses a lumped capacity
 matrix $\mat{C}$ (reducing the computational  cost, see Chapter \ref{sect:smm}).
 This matrix is assembled by
 distributing the capacity of each element onto its nodes. Therefore, the resulting $\mat{C}$ is a diagonal matrix stored in the \code{capacity} \code{Array} of the model.
 
 \begin{cpp}
   model.assembleCapacityLumped();
 \end{cpp}
 \index{HeatTransferModel!assembleCapacityLumped}
 
 \note{Currently, only the explicit time integration with lumped capacity matrix
 is implemented within \akantu.} The explicit integration scheme is \index{Forward Euler} \emph{Forward Euler}
 \cite{curnier92a}.
 
 \begin{itemize}
 \item Predictor: $\vec{T}_{n+1} = \vec{T}_{n} + \Delta t \dot{\vec{T}}_{n}$
 \item Update residual: $\vec{R}_{n+1} = \left( \vec{Q^{ext}_{n+1}} - \vec{K}\vec{T}_{n+1} \right)$
 \item Corrector : $\dot{\vec{T}}_{n+1} = \mat{C}^{-1} \vec{R}_{n+1}$
 \end{itemize}
 
 The explicit integration scheme is conditionally stable. The time step has to be smaller than the stable time step,
 and it can be obtained in \akantu as follows:
 
 \begin{cpp}
   time_step = model.getStableTimeStep();
 \end{cpp}
 \index{HeatTransferModel!StableTimeStep}
 
 The stable time step is defined as:
 \begin{equation}\label{eqn:htm:explicit:stabletime}
   \Delta t_{\st{crit}} = 2 \Delta x^2 \frac{\rho c_v}{\mid\mid \mat{\kappa} \mid\mid^\infty}
 \end{equation}
 where $\Delta x$ is the characteristic length (\eg the inradius in the
 case of linear triangle element), $\rho$ is the density,
 $\mat{\kappa}$ is the conductivity tensor, and $c_v$ is the specific
 heat capacity. It is necessary to impose a time step which is smaller
 than the stable time step, for instance, by multiplying the stable
 time step by a safety factor smaller than one.
 
 \begin{cpp}
   const Real safety_time_factor = 0.1;
   Real applied_time_step = time_step * safety_time_factor;
   model.setTimeStep(applied_time_step);
 \end{cpp}
 
 The following loop  allows, for each time  step, to update the  \code{temperature}, \code{residual} and
 \code{temperature\_rate}  fields  following the previously described integration scheme.
 
 \begin{cpp}
-  for (UInt s = 1; (s-1)*applied_time_step < total_time; ++s) {
+  for (Int s = 1; (s-1)*applied_time_step < total_time; ++s) {
     model.solveStep();
   }
 \end{cpp}
 \index{HeatTransferModel!solveStep()}
 
 An    example    of    explicit     dynamic    heat propagation is    presented    in \\
 \shellcode{\examplesdir/heat\_transfer/explicit\_heat\_transfer.cc}.  \\
 This example consists of a square 2D plate of \SI{1}{\metre^2}
 having an initial temperature of \SI{100}{\kelvin} everywhere but a
 none centered hot point maintained at
 \SI{300}{\kelvin}. Figure~\ref{fig:htm:explicit:dynamic} presents
 the geometry of this case. The material used is a linear fictitious
 elastic material with a density of
 \SI{8940}{\kilo\gram\per\metre^3}, a conductivity of
 \SI{401}{\watt\per\metre\per\kelvin} and a specific heat capacity of
 \SI{385}{\joule\per\kelvin\per\kilogram}. The time step used is
 \SI{0.12}{\second}.
 
 \begin{figure}[!htb]
   \centering
   \includegraphics[width=.4\textwidth]{figures/hot-point-1}
   \hfill
   \includegraphics[width=.4\textwidth]{figures/hot-point-2}
   \caption{Initial temperature field (left) and after 15000 time steps = 30 minutes (right). The lines represent iso-surfaces.}
   \label{fig:htm:explicit:dynamic}
 \end{figure}
 
 %%% Local Variables:
 %%% mode: latex
 %%% TeX-master: "manual"
 %%% End:
diff --git a/doc/manual/manual-io.tex b/doc/manual/manual-io.tex
index b4aac0022..f0d5284a5 100644
--- a/doc/manual/manual-io.tex
+++ b/doc/manual/manual-io.tex
@@ -1,297 +1,297 @@
 \chapter{Input/Output}\index{I\/O}
 
 \section{Input file \label{sect:parser}}
 
 The text input file of a simulation should be precised using the method \code{initialize} which will instantiate the static \code{Parser} object of \akantu. This section explains how to manipulate \code{Parser} objects to input data in \akantu.      
 \begin{cpp}
 int main(int argc, char *argv[]) {
   initialize("input_files.dat", argc, argv);
   ...
 \end{cpp}
 
 \subsection{Akantu Parser}
 
 \akantu file parser has a tree organization.
 \begin{itemize}
 \item \code{Parser}, the root of the tree, can be accessed using
 \begin{cpp}
 Parser & parser = getStaticParser();
 \end{cpp}
 \item \code{ParserSection}, branch of the tree, contains map a of sub-sections (\code{SectionType}, \code{ParserSection}) and a \code{ParserSection *} pointing to the parent section. The user section of the input file can directly be accessed by
 \begin{cpp}
 const ParserSection & usersect = getUserParser();
 \end{cpp} 
 \item \code{ParserParameter}, the leaf of the tree, carries data of the input file which can be casted to the correct type with
 \begin{cpp}
 Real mass = usersect.getParameter("mass");
 \end{cpp}
 or used directly within an expression
 \begin{cpp}
 Real dead_weight = 9.81 * usersect.getParameterValue<Real>("mass");
 \end{cpp}
 \end{itemize}
 
 \subsection{Grammar}
 
 The structure of text input files consists of different sections containing a list of parameters. As example, the file parsed in the previous section will look like
 \begin{cpp}
   user parameters [
      mass = 10.5
   ]
 \end{cpp}  
 Basically every standard arithmetic operations can be used inside of input files as well as the constant \code{pi} and \code{e} and the exponent operator \code{\^{}}. Operations between \code{ParserParameter} are also possible with the convention that only parameters of the current and the parent sections are available. \code{Vector} and \code{Matrix} can also be read according to the \code{NumPy}\cite{numpy} writing convention (a.e. cauchy$\_$stress$\_$tensor = [[$\sigma_{xx}$, $\sigma_{xy}$],[$\sigma_{yx}$,$\sigma_{yy}$]]). 
 An example illustrating how to parse the following input file can be found in \code{example$\backslash$io$\backslash$parser$\backslash$example$\_$parser.cc}.
 \begin{cpp}
 user parameters [
    spatial$\_$dimension = 2
    mesh$\_$file = swiss$\_$cheese.msh
    inner$\_$holes = holes
    outter$\_$crust = crust
    lactostatic$\_$p = 30e3
    stress = [[lactostatic$\_$p,0],[0,lactostatic$\_$p]]
    max$\_$nb$\_$iterations = 100
    precision = 1e-9
 ]
 \end{cpp}
 \subsection{Material section \label{sect:io:material}}
 The input file should also be used to specify material characteristics (constitutive behavior and material properties). The dedicated material section is then read by \code{initFull} method of \code{SolidMechanicsModel} which initializes the different materials specified with the following convention:
 \begin{cpp}
   material %\emph{constitutive\_law}% %\emph{<optional flavor>}% [
      name = $value$
      rho = $value$
      ...
   ]
 \end{cpp}
 \index{Constitutive\_laws} where \emph{constitutive\_law} is the adopted
 constitutive law, followed by the material properties listed one by line in the
 bracket (\eg \code{name} and density \code{rho}). Some constitutive laws can
 also have an \emph{optional flavor}. More information can be found in sections relative to material
 constitutive laws \ref{sect:smm:CL} or in Appendix \ref{app:material-parameters}.
 
 \section{Output data}
 
 \subsection{Generic data}
 In this chapter, we address ways to get the internal data in human-readable formats.
 The models in \akantu handle data associated to the
 mesh, but this data can be split into several \code{Arrays}. For example, the
 data stored per element type in a \code{ElementTypeMapArray} is composed of as
 many \code{Array}s as types in the mesh.
 
 In order to get this data in a visualization software, the models contain a
 object to dump \code{VTK} files. These files can be visualized in software such
 as \code{ParaView}\cite{paraview}, \code{ViSit}\cite{visit} or \code{Mayavi}\cite{mayavi}.
 
 The internal dumper of the model can be configured to specify which data fields
 are to be written. This is done with the
 \code{addDumpField}\index{I\/O!addDumpField} method. By default all the files
 are generated in a folder called \code{paraview/}
 
 \begin{cpp}
   model.setBaseName("output"); // prefix for all generated files
 
   model.addDumpField("displacement");
   model.addDumpField("stress");
   ...
 
   model.dump()
 \end{cpp}
 
 The fields are dumped with the number of components of the memory. For example, in 2D, the memory has 
 \code{Vector}s of 2 components, or the $2^{nd}$ order tensors with $2\times2$ components.  
 This memory can be dealt with \code{addDumpFieldVector}\index{I\/O!addDumpFieldVector} which always dumps
 \code{Vector}s with 3 components or \code{addDumpFieldTensor}\index{I\/O!addDumpFieldTensor} which dumps $2^{nd}$
 order tensors with $3\times3$ components respectively. The routines \code{addDumpFieldVector}\index{I\/O!addDumpFieldVector} and
 \code{addDumpFieldTensor}\index{I\/O!addDumpFieldTensor} were introduced because of \code{ParaView} which mostly manipulate 3D data.
 
 Those fields which are stored by quadrature point are modified to be seen in the
 \code{VTK} file as elemental data. To do this, the default is to average the
 values of all the quadrature points.
 
 The list of fields depends on the models (for
 \code{SolidMechanicsModel} see table~\ref{tab:io:smm_field_list}).
 
 \begin{table}
   \centering
   \begin{tabular}{llll}
     \toprule
     key          &    type      & support \\
     \midrule
     displacement & Vector<Real> & nodes  \\
     mass         & Vector<Real> & nodes  \\
     velocity     & Vector<Real> & nodes  \\
     acceleration & Vector<Real> & nodes  \\
     force	       & Vector<Real> & nodes  \\
     residual     & Vector<Real> & nodes  \\
     increment     & Vector<Real> & nodes  \\
     {blocked\_dofs}  & Vector<bool> & nodes  \\    
     partitions   & Real         & elements \\
     material\_index & variable  & elements\\    
     strain & Matrix<Real> & quadrature points  \\
     Green strain & Matrix<Real> & quadrature points  \\
     principal strain & Vector<Real> & quadrature points  \\
     principal Green strain & Vector<Real> & quadrature points  \\
     grad\_u & Matrix<Real> & quadrature points  \\    
     stress & Matrix<Real> & quadrature points  \\
     Von Mises stress & Real & quadrature points  \\        
     material\_index & variable  & quadrature points \\
     \bottomrule
   \end{tabular}
   \caption{List of dumpable fields for \code{SolidMechanicsModel}.}
   \label{tab:io:smm_field_list}
 \end{table}
 
 \subsection{Cohesive elements' data}
 Cohesive elements and their relative data can be easily dumped thanks
 to a specific dumper contained in
 \code{SolidMechanicsModelCohesive}. In order to use it, one has just
 to add the string \code{"cohesive elements"} when calling each method
 already illustrated. Here is an example on how to dump displacement
 and damage:
 \begin{cpp}
   model.setBaseNameToDumper("cohesive elements", "cohesive_elements_output");
   model.addDumpFieldVectorToDumper("cohesive elements", "displacement");
   model.addDumpFieldToDumper("cohesive elements", "damage");
   ...
 
   model.dump("cohesive elements");
 \end{cpp}
 
 \subsubsection{Fragmentation data}
 
 Whenever the \code{SolidMechanicsModelCohesive} is used, it is
 possible to dump additional data about the fragments that get formed
 in the simulation both in serial and parallel. This task is carried
 out by the \code{FragmentManager} class, that takes care of computing
 the following quantities for each fragment:
 \begin{itemize}
 \item index;
 \item mass;
 \item moments of inertia;
 \item velocity;
 \item number of elements.
 \end{itemize}
 These computations can be realized at once by calling the function
 \code{computeAllData}, or individually by calling the other public
 functions of the class. The data can be dumped to be visualized in
 Paraview, or can be accessed within the simulation. An example of
 usage is:
 \begin{cpp}
   FragmentManager fragment_manager(model);
   fragment_manager.buildAllData();
   ...
 
   model.addDumpField("fragments");       // this field contains the indices
   model.addDumpField("fragments mass");
   model.addDumpField("moments of inertia");
   model.addDumpField("elements per fragment");
   ...
 
-  for (UInt step = 1; step <= total_steps; ++step) {
+  for (Int step = 1; step <= total_steps; ++step) {
     ...
 
     fragment_manager.buildAllData();
     model.dump();
   }
   ...
 
   const Array<Real> & fragment_velocities = fragment_manager.getVelocity();
   ...
 \end{cpp}
 At the end of this example the velocities of the fragments are
 accessed with a reference to a \code{const Array<Real>}. The size of
 this array is the number of fragments, and its number of components is
 the spatial dimension in this case.
 
 
 \subsection{Advanced dumping}
 
 \subsubsection{Arbitrary fields}
 In addition to the predetermined fields from the models and materials, the user
 can add any data to a dumper as long as the support is the same. That is to say
 data that have the size of the full mesh on if the dumper is dumping the mesh,
 or of the size of an element group if it is a filtered dumper.
 
 For this the easiest is to use the ``external'' fields register functions\index{I\/O!addDumpFieldExternal}
 
 The simple case force nodal and elemental data are to pass directly the data
 container itself if it as the good size.
 \begin{itemize}
 \item For nodal fields :
 \begin{cpp}
   template<class T>
   addDumpFieldExternal(const std::string & field_name,
                        const Array<T> & field);
 \end{cpp}
 
 It is assumed that the array as the same size as the number of nodes in the mesh
 
 \begin{cpp}
   Array<T> nodal_data(nb_nodes, nb_component);
   mesh.addDumpFieldExternal("my_field", nodal_data);
 \end{cpp}
 
 \item For elemental fields :
 
 \begin{cpp}
   template<class T>
   addDumpFieldExternal(const std::string & field_name,
                        const ElementTypeMapArray<T> & field);
 \end{cpp}
 
 It is assumed that the arrays in the map have the same sizes as the element numbers in the mesh for element types of dimension \code{spatial\_dimension}.
 
 \begin{cpp}
   ElementTypeMapArray<Real> elem_data;
   elem_data.initialize(mesh,
                        _nb_component = 1,
                        _with_nb_element = true);
   mesh.addDumpFieldExternal("my_field", elem_data);
 \end{cpp}
 \end{itemize}
 
 If some changes have to be applied on the data as for example a padding for
 \code{ParaView} vectors, this can be done by using the
 field interface.
 
 \begin{cpp}
   mesh.addDumpFieldExternal(const std::string & field_name,
                              std::shared<dumpers::Field> & field);
 \end{cpp}
 
 All these functions use the default dumper registered in the mesh but  also have the \code{ToDumper} variation with the dumper name specified.
 For example:
 \begin{cpp}
   mesh.addDumpFieldExternalToDumper("cohesive elements",
                                     "my_field",
                                     my_field);
 \end{cpp}
 
 
 An example of code presenting this interface is present in the
 \shellcode{\examplesdir/io/dumper}. This interface is part of the
 \code{Dumpable} class from which the \code{Mesh} inherits.
 
 \subsubsection{Creating a new dumper}
 
 You can also create you own dumpers, \akantu uses a third-party library in order
 to write the output files, \code{IOHelper}. \akantu supports the \code{ParaView}
 format and a Text format defined by \code{IOHelper}.
 
 This two files format are handled by the classes
 \code{DumperParaview}\index{I\/O!DumperParaview} and
 \code{DumperText}\index{I\/O!DumperText}.
 
 In order to use them you can instantiate on of this object in your code. This
 dumper have a simple interface. You can register a mesh
 \code{registerMesh}\index{I\/O!registerMesh},
 \code{registerFilteredMesh}\index{I\/O!registerFilteredMesh} or a field,
 \code{registerField}\index{I\/O!registerField}.
 
 An example of code presenting this low level interface is present in the
 \shellcode{\examplesdir/io/dumper}. The different types of \code{Field} that can
 be created are present in the source folder \shellcode{src/io/dumper}.
 
 %%% Local Variables:
 %%% mode: latex
 %%% TeX-master: "manual"
 %%% End: 
diff --git a/doc/manual/manual-solidmechanicsmodel.tex b/doc/manual/manual-solidmechanicsmodel.tex
index f0fe8760f..5e321d550 100644
--- a/doc/manual/manual-solidmechanicsmodel.tex
+++ b/doc/manual/manual-solidmechanicsmodel.tex
@@ -1,1138 +1,1138 @@
 \chapter{Solid Mechanics Model\index{SolidMechanicsModel}\label{sect:smm}}
 
 The solid mechanics model is a specific implementation of the
 \code{Model} interface dedicated to handle the equations of motion or
 equations of equilibrium. The model is created for a given mesh.  It
 will create its own \code{FEEngine} object to compute the interpolation,
 gradient, integration and assembly operations.  A
 \code{SolidMechanicsModel} object can simply be created like this:
 \begin{cpp}
   SolidMechanicsModel model(mesh);
 \end{cpp}
 where \code{mesh} is the mesh for which the equations are to be
 solved. A second parameter called \code{spatial\_dimension} can be
 added after \code{mesh} if the spatial dimension of the problem is
 different than that of the mesh.
 
 This model contains at least the following six \code{Arrays}:
 \begin{description}
 \item[blocked\_dofs] contains a Boolean value for each degree of
   freedom specifying whether that degree is blocked or not. A
   Dirichlet boundary condition can be prescribed by setting the
   \textbf{blocked\_dofs} value of a degree of freedom to \code{true}.
   A Neumann boundary condition can be applied by setting the
   \textbf{blocked\_dofs} value of a degree of freedom to \code{false}.
   The \textbf{displacement}, \textbf{velocity} and
   \textbf{acceleration} are computed for all degrees of freedom for
   which the \textbf{blocked\_dofs} value is set to \code{false}. For
   the remaining degrees of freedom, the imposed values (zero by
   default after initialization) are kept.
 \item[displacement] contains the displacements of all degrees of
   freedom. It can be either a computed displacement for free degrees
   of freedom or an imposed displacement in case of blocked ones
   ($\vec{u}$ in the following).
 \item[velocity] contains the velocities of all degrees of freedom.  As
   \textbf{displacement}, it contains computed or imposed velocities
   depending on the nature of the degrees of freedom ($\dot{\vec{u}}$
   in the following).
 \item[acceleration] contains the accelerations of all degrees of
   freedom. As \textbf{displacement}, it contains computed or imposed
   accelerations depending on the nature of the degrees of freedom
   ($\ddot{\vec{u}}$ in the following).
 \item[external\_force] contains the external forces applied on the nodes
   ($\vec{f}_{\st{ext}}$ in the following).
 \item[internal\_force] contains the internal forces on the nodes
   ($\vec{f}_{\st{int}}$ in the following).
 \end{description}
 
 Some examples to help to understand how to use this model will be
 presented in the next sections.
 
 \section{Model Setup}
 
 
 \subsection{Setting Initial Conditions \label{sect:smm:initial_condition}}
 
 For a unique solution of the equations of motion, initial
 displacements and velocities for all degrees of freedom must be
 specified:
 \begin{eqnarray}
   \vec{u}(t=0) = \vec{u}_0\\
   \dot{\vec u}(t=0) =\vec{v}_0
 \end{eqnarray} The solid mechanics model can be initialized as
 follows:
 \begin{cpp}
   model.initFull()
 \end{cpp}
 This function initializes the internal arrays and sets them to
 zero. Initial displacements and velocities that are not equal to zero
 can be prescribed by running a loop over the total number of
 nodes. Here, the initial displacement in $x$-direction and the
 initial velocity in $y$-direction for all nodes is set to $0.1$ and $1$,
 respectively.
 \begin{cpp}
 auto & disp = model.getDisplacement();
 auto & velo = model.getVelocity();
 
-for (UInt node = 0; node < mesh.getNbNodes(); ++node) {
+for (Int node = 0; node < mesh.getNbNodes(); ++node) {
   disp(node, 0) = 0.1;
   velo(node, 1) = 1.;
 }
 \end{cpp}
 
 \subsection{Setting Boundary Conditions\label{sect:smm:boundary}}
 This section explains how to impose Dirichlet or Neumann boundary
 conditions. A Dirichlet boundary condition specifies the values that
 the displacement needs to take for every point $x$ at the boundary
 ($\Gamma_u$) of the problem domain (Fig.~\ref{fig:smm:boundaries}):
 \begin{equation}
   \vec{u} = \bar{\vec u} \quad \forall \vec{x}\in
   \Gamma_{u}
 \end{equation}
 A Neumann boundary condition imposes the value of the gradient of the
 solution at the boundary $\Gamma_t$ of the problem domain
 (Fig.~\ref{fig:smm:boundaries}):
 \begin{equation}
   \vec{t} = \mat{\sigma} \vec{n} = \bar{\vec t} \quad
   \forall \vec{x}\in \Gamma_{t}
 \end{equation}
 
 \begin{figure} \centering
 \def\svgwidth{0.5\columnwidth}
   \input{figures/problemDomain.pdf_tex}
   \caption{Problem domain $\Omega$ with boundary in three
     dimensions. The Dirchelet and the Neumann regions of the boundary
     are denoted with $\Gamma_u$ and $\Gamma_t$,
     respecitvely.\label{fig:smm:boundaries}}
   \label{fig:problemDomain}
 \end{figure}
 
 Different ways of imposing these boundary conditions exist. A basic
 way is to loop over nodes or elements at the boundary and apply local
 values. A more advanced method consists of using the notion of the
 boundary of the mesh. In the following both ways are presented.
 
 Starting with the basic approach, as mentioned, the Dirichlet boundary
 conditions can be applied by looping over the nodes and assigning the
 required values. Figure~\ref{fig:smm:dirichlet_bc} shows a beam with a
 fixed support on the left side. On the right end of the beam, a load
 is applied. At the fixed support, the displacement has a given
 value. For this example, the displacements in both the $x$ and the
 $y$-direction are set to zero. Implementing this displacement boundary
 condition is similar to the implementation of initial displacement
 conditions described above. However, in order to impose a displacement
 boundary condition for all time steps, the corresponding nodes need to
 be marked as boundary nodes using the function \code{blocked}. While, 
 in order to impose a load on the right side, the nodes are not marked.
 The detail codes are shown as follows:
 
 \begin{cpp}
 auto & blocked = model.getBlockedDOFs();
 const auto & pos = mesh.getNodes();
 
-UInt nb_nodes = mesh.getNbNodes();
+Int nb_nodes = mesh.getNbNodes();
 
-for (UInt node = 0; node < nb_nodes; ++node) {
+for (Int node = 0; node < nb_nodes; ++node) {
   if(Math::are_float_equal(pos(node, _x), 0)) {
     blocked(node, _x) = true; // block dof in x-direction
     blocked(node, _y) = true; // block dof in y-direction
     disp(node, _x) = 0.; // fixed displacement in x-direction
     disp(node, _y) = 0.; // fixed displacement in y-direction
   } else if (Math::are_float_equal(pos(node, _y), 0)) {
     blocked(node, _x) = false; // unblock dof in x-direction
     forces(node, _x) = 10.;    // force in x-direction
   }
 }
 \end{cpp}
 
 \begin{figure}[!htb]
   \centering
   \includegraphics[scale=0.4]{figures/dirichlet}
   \caption{Beam with fixed support and load.\label{fig:smm:dirichlet_bc}}
 \end{figure}
 
 
 For the more advanced approach, one needs the notion of a boundary in
 the mesh. Therefore, the boundary should be created before boundary
 condition functors can be applied. Generally the boundary can be
 specified from the mesh file or the geometry.  For the first case, the
 function \code{createGroupsFromMeshData} is called.  This function
 can read any types of mesh data which are provided in the mesh
 file. If the mesh file is created with Gmsh, the function takes one
 input strings which is either \code{tag\_0}, \code{tag\_1} or
 \code{physical\_names}. The first two tags are assigned by Gmsh to
 each element which shows the physical group that they belong to. In
 Gmsh, it is also possible to consider strings for different groups of
 elements. These elements can be separated by giving a string
 \code{physical\_names} to the function
 \code{createGroupsFromMeshData}:
 \begin{cpp}
 mesh.createGroupsFromMeshData<std::string>("physical_names").
 \end{cpp}
 Boundary conditions support can also be
 created from the geometry by calling
 \code{createBoundaryGroupFromGeometry}. This function gathers all the
 elements on the boundary of the geometry.
 
 To apply the required boundary conditions, the function \code{applyBC}
 needs to be called on a \code{SolidMechanicsModel}. This function
 gets a Dirichlet or Neumann functor and a string which specifies the
 desired boundary on which the boundary conditions is to be
 applied. The functors specify the type of conditions to apply. Three
 built-in functors for Dirichlet exist: \code{FlagOnly, FixedValue,}
 and \code{IncrementValue}. The functor \code{FlagOnly} is used if a
 point is fixed in a given direction. Therefore, the input parameter to
 this functor is only the fixed direction. The \code{FixedValue}
 functor is used when a displacement value is applied in a fixed
 direction. The \code{IncrementValue} applies an increment to the
 displacement in a given direction. The following code shows the
 utilization of three functors for the top, bottom and side surface of
 the mesh which were already defined in the Gmsh file:
 
 \begin{cpp}
 model.applyBC(BC::Dirichlet::FixedValue(13.0, _y), "Top");
 
 model.applyBC(BC::Dirichlet::FlagOnly(_x), "Bottom");
 
 model.applyBC(BC::Dirichlet::IncrementValue(13.0, _x), "Side");
 \end{cpp}
 
 To apply a Neumann boundary condition, the applied traction or stress
 should be specified before. In case of specifying the traction on the
 surface, the functor \code{FromTraction} of Neumann boundary
 conditions is called. Otherwise, the functor \code{FromStress} should
 be called which gets the stress tensor as an input parameter.
 
 \begin{cpp}
 Vector<Real> surface_traction = {0., 0., 1.};
 auto surface_stress(3, 3) = Matrix<Real>::eye(3);
 
 model.applyBC(BC::Neumann::FromTraction(surface_traction), "Bottom");
 
 model.applyBC(BC::Neumann::FromStress(surface_stress), "Top");
 \end{cpp}
 
 If the boundary conditions need to be removed during the simulation, a
 functor is called from the Neumann boundary condition to free those
 boundary conditions from the desired boundary.
 
 \begin{cpp}
  model.applyBC(BC::Neumann::FreeBoundary(), "Side");
 \end{cpp}
 
 User specified functors can also be implemented.  A full example for
 setting both initial and boundary conditions can be found in
 \shellcode{\examplesdir/boundary\_conditions.cc}.  The problem solved
 in this example is shown in Fig.~\ref{fig:smm:bc_and_ic}. It consists
 of a plate that is fixed with movable supports on the left and bottom
 side. On the right side, a traction, which increases linearly with the
 number of time steps, is applied. The initial displacement and
 velocity in $x$-direction at all free nodes is zero and two
 respectively.
 \begin{figure}[!htb]
   \centering
   \includegraphics[scale=0.8]{figures/bc_and_ic_example}
   \caption{Plate on movable supports.\label{fig:smm:bc_and_ic}}
 \end{figure}
 
 As it is mentioned in Section \ref{sect:common:groups}, node and
 element groups can be used to assign the boundary conditions. A
 generic example is given below with a Dirichlet boundary condition.
 
 \begin{cpp}
   // create a node group
   NodeGroup & node_group = mesh.createNodeGroup("nodes_fix");
 
   /*
   fill the node group with the nodes you want
   */
 
   // create an element group using the existing node group
   mesh.createElementGroupFromNodeGroup("el_fix", "nodes_fix", spatial_dimension-1);
 
   // boundary condition can be applied using the element group name
   model.applyBC(BC::Dirichlet::FixedValue(0.0, _x), "el_fix");
 \end{cpp}
 
 \subsection{Material Selector\label{sect:smm:materialselector}}
 
 If the user wants to assign different materials to different
 finite elements groups in \akantu, a material selector has to be
 used. By default, \akantu assigns the first valid material in the
 material file to all elements present in the model (regular continuum
 materials are assigned to the regular elements and cohesive materials
 are assigned to cohesive elements or element facets).
 
 To assign different materials to specific elements, mesh data
 information such as tag information or specified physical names can be
 used. \code{MeshDataMaterialSelector} class uses this information to
 assign different materials. With the proper physical name or tag name
 and index, different materials can be assigned as demonstrated in the
 examples below.
 
 \begin{cpp}
   auto mat_selector = std::make_shared<MeshDataMaterialSelector<std::string>>("physical_names", model);
   model.setMaterialSelector(mat_selector);
 \end{cpp}
 
 In this example the physical names specified in a GMSH geometry file will by
 used to match the material names in the input file.
 
 Another example would be to use the first (\code{tag\_0}) or the second
 (\code{tag\_1}) tag associated to each elements in the mesh:
 
 \begin{cpp}
-  auto mat_selector = std::make_shared<MeshDataMaterialSelector<UInt>>(
+  auto mat_selector = std::make_shared<MeshDataMaterialSelector<Int>>(
       "tag_1", model, first_index);
   model.setMaterialSelector(*mat_selector);
 \end{cpp}
 
 where \code{first\_index} (default is 1) is the value of \code{tag\_1} that will
 be associated to the first material in the material input file. The following
 values of the tag will be associated with the following materials.
 
 There are four different material selectors pre-defined in
 \akantu. \code{MaterialSelector} and \code{DefaultMaterialSelector} is
 used to assign a material to regular elements by default. For the
 regular elements, as in the example above,
 \code{MeshDataMaterialSelector} can be used to assign different
 materials to different elements. 
 
 Apart from the \akantu's default material selectors, users can always
 develop their own classes in the main code to tackle various
 multi-material assignment situations.
 
 % An application of \code{DefaultMaterialCohesiveSelector} and usage in
 % a customly generated material selector class can be seen in
 % \shellcode{\examplesdir/cohesive\_element/cohesive\_extrinsic\_IG\_TG/cohesive\_extrinsic\_IG\_TG.cc}.
 
 \IfFileExists{manual-cohesive_elements_insertion.tex}{\input{manual-cohesive_elements_insertion}}{}
 
 \section{Static Analysis\label{sect:smm:static}}
 
 The \code{SolidMechanicsModel} class can handle different analysis
 methods, the first one being presented is the static case.  In this
 case, the equation to solve is
 \begin{equation}
   \label{eqn:smm:static} \mat{K} \vec{u} =
   \vec{f}_{\st{ext}}
 \end{equation}
 where $\mat{K}$ is the global stiffness matrix, $\vec{u}$ the
 displacement vector and $\vec{f}_{\st{ext}}$ the vector of external
 forces applied to the system.
 
 To solve such a problem, the static solver of the
 \code{SolidMechanicsModel}\index{SolidMechanicsModel} object is used.
 First, a model has to be created and initialized.  To create the
 model, a mesh (which can be read from a file) is needed, as explained
 in Section~\ref{sect:common:mesh}.  Once an instance of a
 \code{SolidMechanicsModel} is obtained, the easiest way to initialize
 it is to use the \code{initFull}\index{SolidMechanicsModel!initFull}
 method by giving the \code{SolidMechanicsModelOptions}. These options
 specify the type of analysis to be performed and whether the materials
 should be initialized with \code{initMaterials} or not.
 \begin{cpp}
 SolidMechanicsModel model(mesh);
 model.initFull(_analysis_method = _static);
 \end{cpp}
 Here, a static analysis is chosen by passing the argument
 \code{\_static} to the method. By default, the Boolean for no
 initialization of the materials is set to false, so that they are
 initialized during the \code{initFull}. The method \code{initFull}
 also initializes all appropriate vectors to zero.  Once the model is
 created and initialized, the boundary conditions can be set as
 explained in Section~\ref{sect:smm:boundary}.  Boundary conditions
 will prescribe the external forces for some free degrees of freedom
 $\vec{f}_{\st{ext}}$ and displacements for some others.  At this point
 of the analysis, the function
 \code{solveStep}\index{SolidMechanicsModel!solveStep} can be called:
 \begin{cpp}
 model.solveStep<_scm_newton_raphson_tangent_modified, SolveConvergenceCriteria::_residual>(1e-4, 1);
 \end{cpp}
 This function is templated by the solving method and the convergence
 criterion and takes two arguments: the tolerance and the maximum
 number of iterations (100 by default), which are $\num{1e-4}$ and $1$ for this example. The
 modified Newton-Raphson method is chosen to solve the system. In this
 method, the equilibrium equation (\ref{eqn:smm:static}) is modified in
 order to apply a Newton-Raphson convergence algorithm:
 \begin{align}\label{eqn:smm:static-newton-raphson}
   \mat{K}^{i+1}\delta\vec{u}^{i+1} &= \vec{r} \\
   &= \vec{f}_{\st{ext}} -\vec{f}_{\st{int}}\\
   &= \vec{f}_{\st{ext}} - \mat{K}^{i} \vec{u}^{i}\\
   \vec{u}^{i+1} &= \vec{u}^{i} + \delta\vec{u}^{i+1}~,\nonumber
 \end{align}
 where $\delta\vec{u}$ is the increment of displacement to be added
 from one iteration to the other, and $i$ is the Newton-Raphson
 iteration counter.  By invoking the \code{solveStep} method in the
 first step, the global stiffness matrix $\mat{K}$ from
 Equation~(\ref{eqn:smm:static}) is automatically assembled. A
 Newton-Raphson iteration is subsequently started, $\mat{K}$ is updated
 according to the displacement computed at the previous iteration and
 one loops until the forces are balanced (\code{SolveConvergenceCriteria::\_residual}), \ie
 $||\vec{r}|| < \mbox{\code{SolveConvergenceCriteria::\_residual}}$.  One can also iterate
 until the increment of displacement is zero (\code{SolveConvergenceCriteria::\_increment})
 which also means that the equilibrium is found.  For a linear elastic
 problem, the solution is obtained in one iteration and therefore the
 maximum number of iterations can be set to one. But for a non-linear
 case, one needs to iterate as long as the norm of the residual exceeds
 the tolerance threshold and therefore the maximum number of iterations
 has to be higher, e.g.  $100$:
 \begin{cpp}
 model.solveStep<_scm_newton_raphson_tangent_modified,SolveConvergenceCriteria::_residual>(1e-4, 100)
 \end{cpp}
 At the end of the analysis, the final solution is stored in the
 \textbf{displacement} vector.  A full example of how to solve a static
 problem is presented in the code \code{\examplesdir/static/static.cc}.
 This example is composed of a 2D plate of steel, blocked with rollers
 on the left and bottom sides as shown in Figure \ref{fig:smm:static}.
 The nodes from the right side of the sample are displaced by $0.01\%$
 of the length of the plate.
 
 \begin{figure}[!htb]
   \centering
   \includegraphics[scale=1.05]{figures/static}
   \caption{Numerical setup\label{fig:smm:static}}
 \end{figure}
 
 The results of this analysis is depicted in
 Figure~\ref{fig:smm:implicit:static_solution}.
 
 \begin{figure}[!htb]
   \centering
   \includegraphics[width=.7\linewidth]{figures/static_analysis}
   \caption{Solution of the static analysis. Left: the initial
 condition, right: the solution (deformation magnified 50 times)}
   \label{fig:smm:implicit:static_solution}
 \end{figure}
 
 
 \subsection{Static implicit analysis with dynamic insertion of cohesive elements}
 In order to solve problems with the extrinsic cohesive method in the
 static implicit solution scheme, the function \code{solveStepCohesive}
 has to be used:
 \begin{cpp}
 model.solveStepCohesive<_scm_newton_raphson_tangent, SolveConvergenceCriteria::_increment>(1e-13, error, 25, false, 1e5, true);
 \end{cpp}
 
 in which the arguments are: tolerance, error, max\_iteration,
 load\_reduction, tol\_increase\_factor, do\_not\_factorize.  This
 function, first applies the Newton-Raphson procedure to solve the
 problem.  Then, it calls the method \code{checkCohesiveStress} to
 check if cohesive elements have to be inserted.  Since the approach is
 implicit, only one element is added, the most stressed one (see
 Section \ref{extrinsic_insertion}).  After insertion, the
 Newton-Raphson procedure is applied again to solve the same
 incremental loading step, with the new inserted cohesive element.  The
 procedure loops in this way since no new cohesive elements have to be
 inserted.  At that point, the solution is saved, and the simulation
 can advance to the next incremental loading step.  In case the
 convergence is not reached, the obtained solution is not saved and the
 simulation return to the main file with the error given by the
 solution saved in the argument of the function \emph{error}.  In this
 way, the user can intervene in the simulation in order to find anyhow
 convergence.  A possibility is, for instance, to reduce the last
 incremental loading step.  The variable \emph{load\_reduction} can be
 used to identify if the load has been already reduced or not.  At the
 same time, with the variable \emph{tol\_increase\_factor} it is
 possible to increase the tolerance by a factor defined by the user in
 the main file, in order to accept a solution even with an error bigger
 than the tolerance set at the beginning.  It is possible to increase
 the tolerance only in the phase of loading reduction, i.e., when
 load\_reduction = true.  A not converged solution is never saved.  In
 case the convergence is not reached even after the loading reduction
 procedure, the displacement field is not updated and remains the one
 of the last converged incremental steps.  Also, cohesive elements are
 inserted only if convergence is reached.  An example of the extrinsic
 cohesive method in the static implicit solution scheme is presented in
 \shellcode{\examplesdir/cohesive\_element/cohesive\_extrinsic\_implicit}.
 
 \section{Dynamic Methods} \label{sect:smm:Dynamic_methods}
 
 Different ways to solve the equations of motion are implemented in the
 solid mechanics model.  The complete equations that should be solved
 are:
 \begin{equation}
 \label{eqn:equation-motion}
 \mat{M}\ddot{\vec{u}} +
 \mat{C}\dot{\vec{u}} + \mat{K}\vec{u} = \vec{f}_{\st{ext}}~,
 \end{equation}
 where $\mat{M}$, $\mat{C}$ and $\mat{K}$ are the mass,
 damping and stiffness matrices, respectively.
 
 In the previous section, it has already been discussed how to solve this
 equation in the static case, where $\ddot{\vec{u}} = \dot{\vec{u}} = 0$.  Here
 the method to solve this equation in the general case will be presented.  For
 this purpose, a time discretization has to be specified.  The most common
 discretization method in solid mechanics is the Newmark-$\beta$ method, which is
 also the default in \akantu.
 
 For the Newmark-$\beta$ method, (\ref{eqn:equation-motion}) becomes a
 system of three equations (see \cite{curnier92a} \cite{hughes-83a} for
 more details):
 \begin{align}
 \mat{M} \ddot{\vec{u}}_{n+1} + \mat{C}\dot{\vec{u}}_{n+1} + \mat{K} \vec{u}_{n+1} &={\vec{f}_{\st{ext}}}_{\, n+1}
 \label{eqn:equation-motion-discret} \\
 \vec{u}_{n+1} &=\vec{u}_{n} + \left(1 - \alpha\right) \Delta t \dot{\vec{u}}_{n} +
 \alpha \Delta t \dot{\vec{u}}_{n+1} + \left(\frac{1}{2} -
 \alpha\right) \Delta t^2
 \ddot{\vec{u}}_{n} \label{eqn:finite-difference-1}\\
 \dot{\vec{u}}_{n+1} &= \dot{\vec{u}}_{n} + \left(1 - \beta\right)
 \Delta t \ddot{\vec{u}}_{n} + \beta \Delta t
 \ddot{\vec{u}}_{n+1} \label{eqn:finite-difference-2}
 \end{align}
 
 In these new equations, $\ddot{\vec{u}}_{n}$, $\dot{\vec{u}}_{n}$ and
 $\vec{u}_{n}$ are the approximations of $\ddot{\vec{u}}(t_n)$,
 $\dot{\vec{u}}(t_n)$ and $\vec{u}(t_n)$.
 Equation~(\ref{eqn:equation-motion-discret}) is the equation of motion
 discretized in space (finite-element discretization), and equations
 (\ref{eqn:finite-difference-1}) and (\ref{eqn:finite-difference-2})
 are discretized in both space and time (Newmark discretization).  The
 $\alpha$ and $\beta$ parameters determine the stability and the
 accuracy of the algorithm. Classical values for $\alpha$ and $\beta$
 are usually $\beta = 1/2$ for no numerical damping and $0 < \alpha <
 1/2$.
 
 \begin{center}
   \begin{tabular}{cll}
     \toprule
     $\alpha$ & Method ($\beta = 1/2$) & Type\\
     \midrule
     $0$ & central difference & explicit\\
     $1/6$ & Fox-Goodwin (royal road) &implicit\\
     $1/3$ & Linear acceleration &implicit\\
     $1/2$ & Average acceleration (trapezoidal rule)& implicit\\
     \bottomrule
   \end{tabular}
 \end{center}
 
 The solution of this system of equations,
 (\ref{eqn:equation-motion-discret})-(\ref{eqn:finite-difference-2}) is
 split into a predictor and a corrector system of equations.  Moreover,
 in the case of a non-linear equations, an iterative algorithm such as
 the Newton-Raphson method is applied. The system of equations can be
 written as:
 
 \begin{enumerate}
 \item \textit{Predictor:}
 \begin{align}
   \vec{u}_{n+1}^{0} &= \vec{u}_{n} + \Delta t
   \dot{\vec{u}}_{n} + \frac{\Delta t^2}{2} \ddot{\vec{u}}_{n} \\
   \dot{\vec{u}}_{n+1}^{0} &= \dot{\vec{u}}_{n} + \Delta t
   \ddot{\vec{u}}_{n} \\
   \ddot{\vec{u}}_{n+1}^{0} &= \ddot{\vec{u}}_{n}
 \end{align}
 
 \item \textit{Solve:}
 \begin{align}
   \left(c \mat{M} + d \mat{C} + e \mat{K}_{n+1}^i\right)
   \vec{w} = {\vec{f}_{\st{ext}}}_{\,n+1} - {\vec{f}_{\st{int}}}_{\,n+1}^i -
   \mat{C} \dot{\vec{u}}_{n+1}^i - \mat{M} \ddot{\vec{u}}_{n+1}^i = \vec{r}_{n+1}^i
 \end{align}
 
 \item \textit{Corrector:}
 \begin{align}
   \ddot{\vec{u}}_{n+1}^{i+1} &= \ddot{\vec{u}}_{n+1}^{i} +c \vec{w} \\
   \dot{\vec{u}}_{n+1}^{i+1} &= \dot{\vec{u}}_{n+1}^{i} + d\vec{w} \\
   \vec{u}_{n+1}^{i+1} &= \vec{u}_{n+1}^{i} + e \vec{w}
 \end{align}
 \end{enumerate}
 
 where $i$ is the Newton-Raphson iteration counter and $c$, $d$ and $e$
 are parameters depending on the method used to solve the equations
 
 \begin{center}
   \begin{tabular}{lcccc}
     \toprule
     & $\vec{w}$ & $e$ & $d$ & $c$\\
     \midrule
     in acceleration &$ \delta\ddot{\vec{u}}$ & $\alpha \beta\Delta t^2$ &$\beta \Delta t$ &$1$\\
     in velocity & $ \delta\dot{\vec{u}}$& $\alpha\Delta t$ & $1$ & $\frac{1}{\beta \Delta t}$\\
     in displacement &$\delta\vec{u}$ & $ 1$ & $\frac{1}{\alpha \Delta t}$ & $\frac{1}{\alpha \beta \Delta t^2}$\\
     \bottomrule
   \end{tabular}
 \end{center}
 
 % \note{If you want to use the implicit solver \akantu should be compiled at
 % least with one sparse matrix solver such as Mumps\cite{mumps}.}
 
 
 \subsection{Implicit Time Integration}
 To solve a problem with an implicit time integration scheme, first a
 \code{SolidMechanicsModel} object has to be created and initialized.
 Then the initial and boundary conditions have to be set.  Everything
 is similar to the example in the static case
 (Section~\ref{sect:smm:static}), however, in this case the implicit
 dynamic scheme is selected at the initialization of the model.
 
 \begin{cpp}
 SolidMechanicsModel model(mesh);
 model.initFull(_analysis_method = _implicit_dynamic);
 /*Boundary conditions see Section ~ %\ref{sect:smm:boundary}% */
 \end{cpp}
 Because a dynamic simulation is conducted, an integration time step
 $\Delta t$ has to be specified. In the case of implicit simulations,
 \akantu implements a trapezoidal rule by default.  That is to say
 $\alpha = 1/2$ and $\beta = 1/2$ which is unconditionally
 stable. Therefore the value of the time step can be chosen arbitrarily
 within reason.  \index{SolidMechanicsModel!setTimeStep}
 \begin{cpp}
 model.setTimeStep(time_step);
 \end{cpp}
 Since the system has to be solved for a given amount of time steps, the
 method \code{solveStep()}, (which has already been used in the static
 example in Section~\ref{sect:smm:static}), is called inside a time
 loop:
 \begin{cpp}
 /// time loop
 Real time = 0.;
 
 auto & solver = model.getNonLinearSolver();
 solver.set("max_iterations", 100);
 solver.set("threshold", 1e-12);
 solver.set("convergence_type", SolveConvergenceCriteria::_solution);
 
-for (UInt s = 1; time <max_time; ++s, time += time_step) {
+for (Int s = 1; time <max_time; ++s, time += time_step) {
   model.solveStep();
 }
 \end{cpp}
 An example of solid mechanics with an implicit time integration scheme
 is presented in
 \shellcode{\examplesdir/implicit/implicit\_dynamic.cc}.  This example
 consists of a 3D beam of
 $\SI{10}{\metre}\,\times\,\SI{1}{\metre}\,\times\,\SI{1}{\metre}$
 blocked on one side and is on a roller on the other side.  A constant
 force of \SI{5}{\kilo\newton} is applied in its middle.
 Figure~\ref{fig:smm:implicit:dynamic} presents the geometry of this
 case. The material used is a fictitious linear elastic material with a
 density of \SI{1000}{\kilo\gram\per\cubic\metre}, a Young's Modulus of
 \SI{120}{\mega\pascal} and Poisson's ratio of $0.3$. These values
 were chosen to simplify the analytical solution.
 
 An approximation of the dynamic response of the middle point of the
 beam is given by:
 \begin{equation}
   \label{eqn:smm:implicit}
   u\left(\frac{L}{2}, t\right)
   = \frac{1}{\pi^4} \left(1 - cos\left(\pi^2 t\right) +
     \frac{1}{81}\left(1 - cos\left(3^2 \pi^2 t\right)\right) +
     \frac{1}{625}\left(1 - cos\left(5^2 \pi^2 t\right)\right)\right)
 \end{equation}
 
 \begin{figure}[!htb]
   \centering
   \includegraphics[scale=.6]{figures/implicit_dynamic}
   \caption{Numerical setup}
   \label{fig:smm:implicit:dynamic}
 \end{figure}
 
 Figure \ref{fig:smm:implicit:dynamic_solution} presents the deformed
 beam at 3 different times during the simulation: time steps 0, 1000 and
 2000.
 
 \begin{figure}[!htb]
   \centering
   \setlength{\unitlength}{0.1\textwidth}
   \begin{tikzpicture}
     \node[above right] (img) at (0,0)
     {\includegraphics[width=.6\linewidth]{figures/dynamic_analysis}};
     \node[left] at (0pt,20pt) {$0$}; \node[left] at (0pt,60pt) {$1000$};
     \node[left] at (0pt,100pt) {$2000$};
   \end{tikzpicture}
 
   \caption{Deformed beam at 3 different times (displacement are
     magnified by a factor 10).}
   \label{fig:smm:implicit:dynamic_solution}
 \end{figure}
 
 \subsection{Explicit Time Integration}
 \label{ssect:smm:expl-time-integr}
 
 The explicit dynamic time integration scheme is based on the
 Newmark-$\beta$ scheme with $\alpha=0$ (see equations
 \ref{eqn:equation-motion-discret}-\ref{eqn:finite-difference-2}).  In
 \akantu, $\beta$ is defaults to $\beta=1/2$, see section
 \ref{sect:smm:Dynamic_methods}.
 
 The initialization of the simulation is similar to the static and
 implicit dynamic version.  The model is created from the
 \code{SolidMechanicsModel} class.  In the initialization, the explicit
 scheme is selected using the \code{\_explicit\_lumped\_mass} constant.
 
 \begin{cpp}
 SolidMechanicsModel model(mesh);
 model.initFull(_analysis_method = _explicit_lumped_mass);
 \end{cpp}
 \index{SolidMechanicsModel!initFull}
 \note{Writing \code{model.initFull()} or \code{model.initFull();} is
 equivalent to use the \code{\_explicit\_lumped\_mass} keyword, as this
 is the default case.}
 
 The explicit time integration scheme implemented in \akantu uses a
 lumped mass matrix $\mat{M}$ (reducing the computational cost). This
 matrix is assembled by distributing the mass of each element onto its
 nodes. The resulting $\mat{M}$ is therefore a diagonal matrix stored
 in the \textbf{mass} vector of the model.
 
 The explicit integration scheme is conditionally stable. The time step
 has to be smaller than the stable time step which is obtained in
 \akantu as follows:
 
 \begin{cpp}
 critical_time_step = model.getStableTimeStep();
 \end{cpp} \index{SolidMechanicsModel!StableTimeStep}
 
 The stable time  step corresponds to the time the fastest wave (the compressive
 wave) needs to travel the characteristic length of the mesh:
 \begin{equation}
 \label{eqn:smm:explicit:stabletime}
 \Delta t_{\st{crit}} = \frac{\Delta x}{c}
 \end{equation}
 where $\Delta x$ is a characteristic length (\eg the inradius in the case of
 linear triangle element) and $c$ is the celerity of the fastest wave in the
 material. It is generally the compressive wave of celerity
 $c = \sqrt{\frac{2 \mu + \lambda}{\rho}}$, $\mu$ and $\lambda$ are the first and
 second Lame's coefficients and $\rho$ is the density. However, it is recommended
 to impose a time step that is smaller than the stable time step, for instance,
 by multiplying the stable time step by a safety factor smaller than one.
 
 \begin{cpp}
 const Real safety_time_factor = 0.8;
 Real applied_time_step = critical_time_step * safety_time_factor;
 model.setTimeStep(applied_time_step);
 \end{cpp}
 \index{SolidMechanicsModel!setTimeStep} The initial displacement and
 velocity fields are, by default, equal to zero if not given
 specifically by the user (see \ref{sect:smm:initial_condition}).
 
 Like in implicit dynamics, a time loop is used in which the
 displacement, velocity and acceleration fields are updated at each
 time step. The values of these fields are obtained from the
 Newmark$-\beta$ equations with $\beta=1/2$ and $\alpha=0$. In \akantu
 these computations at each time step are invoked by calling the
 function \code{solveStep}:
 \begin{cpp}
-for (UInt s = 1; (s-1)*applied_time_step < total_time; ++s) {
+for (Int s = 1; (s-1)*applied_time_step < total_time; ++s) {
   model.solveStep();
 }
 \end{cpp} \index{SolidMechanicsModel!solveStep}
 The method
 \code{solveStep} wraps the four following functions:
 \begin{itemize}
 \item \code{model.explicitPred()} allows to compute the displacement
   field at $t+1$ and a part of the velocity field at $t+1$, denoted by
   $\vec{\dot{u}^{\st{p}}}_{n+1}$, which will be used later in the method
   \code{model.explicitCorr()}. The equations are:
   \begin{align}
     \vec{u}_{n+1} &= \vec{u}_{n} + \Delta t
     \vec{\dot{u}}_{n} + \frac{\Delta t^2}{2} \vec{\ddot{u}}_{n}\\
     \vec{\dot{u}^{\st{p}}}_{n+1} &= \vec{\dot{u}}_{n} + \Delta t
     \vec{\ddot{u}}_{n}
     \label{eqn:smm:explicit:onehalfvelocity}
   \end{align}
 
 \item \code{model.updateResidual()} and
   \code{model.updateAcceleration()} compute the acceleration increment
   $\delta \vec{\ddot{u}}$:
   \begin{equation}
     \left(\mat{M} + \frac{1}{2} \Delta t \mat{C}\right)
     \delta \vec{\ddot{u}} = \vec{f_{\st{ext}}} - \vec{f}_{\st{int}\, n+1}
     - \mat{C} \vec{\dot{u}^{\st{p}}}_{n+1} - \mat{M} \vec{\ddot{u}}_{n}
   \end{equation}
 
   \note{The internal force $\vec{f}_{\st{int}\, n+1}$ is computed from
     the displacement $\vec{u}_{n+1}$ based on the constitutive law.}
 
 \item \code{model.explicitCorr()} computes the velocity and
   acceleration fields at $t+1$:
   \begin{align}
     \vec{\dot{u}}_{n+1} &= \vec{\dot{u}^{\st{p}}}_{n+1} + \frac{\Delta t}{2}
     \delta \vec{\ddot{u}} \\ \vec{\ddot{u}}_{n+1} &=
     \vec{\ddot{u}}_{n} + \delta \vec{\ddot{u}}
   \end{align}
 \end{itemize}
 
 The use of an explicit time integration scheme is illustrated by the
 example:\par
 \noindent \shellcode{\examplesdir/explicit/explicit\_dynamic.cc}\par
 \noindent This example models the propagation of a wave in a steel beam. The
 beam and the applied displacement in the $x$ direction are shown in
 Figure~\ref{fig:smm:explicit}.
 
 \begin{figure}[!htb] \centering
   \begin{tikzpicture}
     \coordinate (c) at (0,2);
     \draw[shift={(c)},thick, color=blue] plot [id=x, domain=-5:5, samples=50] ({\x, {(40 * sin(0.1*pi*3*\x) * exp(- (0.1*pi*3*\x)*(0.1*pi*3*\x) / 4))}});
     \draw[shift={(c)},-latex] (-6,0) -- (6,0) node[right, below] {$x$};
     \draw[shift={(c)},-latex] (0,-0.7) -- (0,1) node[right] {$u$};
     \draw[shift={(c)}] (-0.1,0.6) node[left] {$A$}-- (1.5,0.6);
 
     \coordinate (l) at (0,0.6);
     \draw[shift={(0,-0.7)}] (-5, 0) -- (5,0) -- (5, 1) -- (-5, 1) -- cycle;
     \draw[shift={(l)}, latex-latex] (-5,0)-- (5,0) node [midway, above] {$L$};
     \draw[shift={(l)}] (5,0.2)-- (5,-0.2);
     \draw[shift={(l)}] (-5,0.2)-- (-5,-0.2);
 
     \coordinate (h) at (5.3,-0.7);
     \draw[shift={(h)}, latex-latex] (0,0)-- (0,1) node [midway, right] {$h$};
     \draw[shift={(h)}] (-0.2,1)-- (0.2,1);
     \draw[shift={(h)}] (-0.2,0)-- (0.2,0);
   \end{tikzpicture}
 
   \caption{Numerical setup \label{fig:smm:explicit}}
 \end{figure}
 
 The length and height of the beam are $L=\SI{10}{\metre}$ and
 $h = \SI{1}{\metre}$, respectively.  The material is linear elastic,
 homogeneous and isotropic (density:
 \SI{7800}{\kilo\gram\per\cubic\metre}, Young's modulus:
 \SI{210}{\giga\pascal} and Poisson's ratio: $0.3$).  The imposed
 displacement follow a Gaussian function with a maximum amplitude of $A = \SI{0.01}{\meter}$. The
 potential, kinetic and total energies are computed.  The safety factor
 is equal to $0.8$.
 
 \input{manual-constitutive-laws}
 
 \section{Adding a New Constitutive Law}\index{Material!create a new
 material}
 
 There are several constitutive laws in \akantu as described in the
 previous Section~\ref{sect:smm:CL}. It is also possible to use a
 user-defined material for the simulation. These materials are referred
 to as local materials since they are local to the example of the user
 and not part of the \akantu library.  To define a new local material,
 two files (\code {material\_XXX.hh} and \code{material\_XXX.cc}) have
 to be provided where \code{XXX} is the name of the new material. The
 header file \code {material\_XXX.hh} defines the interface of your
 custom material. Its implementation is provided in the
 \code{material\_XXX.cc}. The new law must inherit from the
 \code{Material} class or any other existing material class. It is
 therefore necessary to include the interface of the parent material
 in the header file of your local material and indicate the inheritance
 in the declaration of the class:
 \begin{cpp}
 /* ---------------------------------------------------------------------- */
 #include "material.hh"
 /* ---------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_XXX_HH__
 #define __AKANTU_MATERIAL_XXX_HH__
 
 namespace akantu {
 
 class MaterialXXX : public Material {
 
 /// declare here the interface of your material
 
 };
 \end{cpp}
 In the header file the user also needs to declare all the members of the new
 material. These include the parameters that a read from the
 material input file, as well as any other material parameters that will be
 computed during the simulation and internal variables.
 
 
 In the following the example of adding a new damage material will be
 presented. In this case the parameters in the material will consist of the
 Young's modulus, the Poisson coefficient, the resistance to damage and the
 damage threshold. The material will then from these values compute its Lam\'{e}
 coefficients and its bulk modulus. Furthermore, the user has to add a new
 internal variable \code{damage} in order to store the amount of damage at each
 quadrature point in each step of the simulation. For this specific material the
 member declaration inside the class will look as follows:
 \begin{cpp}
 class LocalMaterialDamage : public Material {
 
 /// declare constructors/destructors here
 
 /// declare methods and accessors here
 
   /* -------------------------------------------------------------------- */
   /* Class Members                                                        */
   /* -------------------------------------------------------------------- */
 
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Damage, damage, Real);
 private:
 
   /// the young modulus
   Real E;
 
   /// Poisson coefficient
   Real nu;
 
   /// First Lame coefficient
   Real lambda;
 
   /// Second Lame coefficient (shear modulus)
   Real mu;
 
   /// resistance to damage
   Real Yd;
 
   /// damage threshold
   Real Sd;
 
   /// Bulk modulus
   Real kpa;
 
   /// damage internal variable
   InternalField<Real> damage;
 
 };
 \end{cpp}
 In order to enable to print the material parameters at any point in
 the user's example file using the standard output stream by typing:
 \begin{cpp}
-for (UInt m = 0; m  < model.getNbMaterials(); ++m)
+for (Int m = 0; m  < model.getNbMaterials(); ++m)
   std::cout << model.getMaterial(m) << std::endl;
 \end{cpp}
 the standard output stream operator has to be redefined. This should be done at the end of the header file:
 \begin{cpp}
 class LocalMaterialDamage : public Material {
 
   /// declare here the interace of your material
 
 }:
 /* ---------------------------------------------------------------------- */
 /* inline functions                                                       */
 /* ---------------------------------------------------------------------- */
 /// standard output stream operator
 inline std::ostream & operator <<(std::ostream & stream, const LocalMaterialDamage & _this)
 {
   _this.printself(stream);
   return stream;
 }
 \end{cpp}
 However, the user still needs to register the material parameters that
 should be printed out. The registration is done during the call of the
 constructor. Like all definitions the implementation of the
 constructor has to be written in the \code{material\_XXX.cc}
 file. However, the declaration has to be provided in the
 \code{material\_XXX.hh} file:
 \begin{cpp}
 class LocalMaterialDamage : public Material {
   /* -------------------------------------------------------------------- */
   /* Constructors/Destructors                                             */
   /* -------------------------------------------------------------------- */
 public:
 
   LocalMaterialDamage(SolidMechanicsModel & model, const ID & id = "");
 };
 \end{cpp}
 The user can now define the implementation of the constructor in the
 \code{material\_XXX.cc} file:
 \begin{cpp}
 /* ---------------------------------------------------------------------- */
 #include "local_material_damage.hh"
 #include "solid_mechanics_model.hh"
 
 namespace akantu {
 
 /* ---------------------------------------------------------------------- */
 LocalMaterialDamage::LocalMaterialDamage(SolidMechanicsModel & model,
 					 const ID & id)  :
   Material(model, id),
   damage("damage", *this) {
   AKANTU_DEBUG_IN();
 
   this->registerParam("E", E, 0., _pat_parsable, "Young's modulus");
   this->registerParam("nu", nu, 0.5, _pat_parsable, "Poisson's ratio");
   this->registerParam("lambda", lambda, _pat_readable, "First Lame coefficient");
   this->registerParam("mu", mu, _pat_readable, "Second Lame coefficient");
   this->registerParam("kapa", kpa, _pat_readable, "Bulk coefficient");
   this->registerParam("Yd", Yd,   50., _pat_parsmod);
   this->registerParam("Sd", Sd, 5000., _pat_parsmod);
 
   damage.initialize(1);
 
   AKANTU_DEBUG_OUT();
 }
 \end{cpp}
 During the intializer list the reference to the model and the material id are
 assigned and the constructor of the internal field is called. Inside the scope
 of the constructor the internal values have to be initialized and the
 parameters, that should be printed out, are registered with the function:
 \code{registerParam}\index{Material!registerParam}:
 \begin{cpp}
 void registerParam(name of the parameter (key in the material file),
 		   member variable,
 		   default value (optional parameter),
 		   access permissions,
 		   description);
 \end{cpp}
 The available access permissions are as follows:
 \begin{itemize}
   \item \code{\_pat\_internal}: Parameter can only be output when the material is printed.
   \item \code{\_pat\_writable}: User can write into the parameter. The parameter is output when the material is printed.
   \item \code{\_pat\_readable}: User can read the parameter. The parameter is output when the material is printed.
   \item \code{\_pat\_modifiable}: Parameter is writable and readable.
   \item \code{\_pat\_parsable}: Parameter can be parsed, \textit{i.e.} read from the input file.
   \item \code{\_pat\_parsmod}: Parameter is modifiable and parsable.
 \end{itemize}
 
 In order to implement the new constitutive law the user needs to
 specify how the additional material parameters, that are not
 defined in the input material file, should be calculated. Furthermore,
 it has to be defined how stresses and the stable time step should be
 computed for the new local material. In the case of implicit
 simulations, in addition, the computation of the tangent stiffness needs
 to be defined. Therefore, the user needs to redefine the following
 functions of the parent material:
 \begin{cpp}
 void initMaterial();
 
 // for explicit and implicit simulations void
 computeStress(ElementType el_type, GhostType ghost_type = _not_ghost);
 
 // for implicit simulations
 void computeTangentStiffness(ElementType el_type,
 			     Array<Real> & tangent_matrix,
 			     GhostType ghost_type = _not_ghost);
 
 // for explicit and implicit simulations
 Real getStableTimeStep(Real h, const Element & element);
 \end{cpp}
 In the following a detailed description of these functions is provided:
 \begin{itemize}
 
 \item \code{initMaterial}:~ This method is called after the material
   file is fully read and the elements corresponding to each material
   are assigned. Some of the frequently used constant parameters are
   calculated in this method. For example, the Lam\'{e} constants of
   elastic materials can be considered as such parameters.
 
 \item \code{computeStress}:~ In this method, the stresses are
   computed based on the constitutive law as a function of the  strains of the
   quadrature points.  For example, the stresses for the elastic
   material are calculated based on the following formula:
   \begin{equation}
     \label{eqn:smm:constitutive_elastic}
     \mat{\sigma }  =\lambda\mathrm{tr}(\mat{\varepsilon})\mat{I}+2 \mu \mat{\varepsilon}
   \end{equation}
 
   Therefore, this method contains a loop on all quadrature points
   assigned to the material using the two macros:\par
   \code{MATERIAL\_STRESS\_QUADRATURE\_POINT\_LOOP\_BEGIN}\par
   \code{MATERIAL\_STRESS\_QUADRATURE\_POINT\_LOOP\_END}
 
   \begin{cpp}
     MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(element_type);
 
     // sigma <- f(grad_u)
 
     MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
   \end{cpp}
 
   \note{The strain vector in \akantu contains the values of $\nabla
 \vec{u}$, i.e. it is really the \emph{displacement gradient},}
 
 \item \code{computeTangentStiffness}:~ This method is called when
   the tangent to the stress-strain curve is desired (see Fig \ref
   {fig:smm:AL:K}).  For example, it is called in the implicit solver
   when the stiffness matrix for the regular elements is assembled
   based on the following formula:
   \begin{equation}
     \label{eqn:smm:constitutive_elasc} \mat{K }
     =\int{\mat{B^T}\mat{D(\varepsilon)}\mat{B}}
   \end{equation}
 
   Therefore, in this method, the \code{tangent} matrix (\mat{D}) is
   computed for a given strain.
 
   \note{ The \code{tangent} matrix is a $4^{th}$ order tensor which is
     stored as a matrix in Voigt notation.}
 
   \begin{figure}[!htb]
     \begin{center}
       \includegraphics[width=0.4\textwidth,keepaspectratio=true]{figures/tangent.pdf}
       \caption{Tangent to the stress-strain curve.}
       \label{fig:smm:AL:K}
     \end{center}
   \end{figure}
 
 \item \code{getCelerity}:~The stability criterion of the explicit integration scheme depend on the fastest wave celerity~\eqref{eqn:smm:explicit:stabletime}. This celerity depend on the material, and therefore the value of this velocity should be defined in this method for each new material. By default, the fastest wave speed is the compressive wave whose celerity can be defined in~\code{getPushWaveSpeed}.
 \end{itemize}
 Once the declaration and implementation of the new material has been
 completed, this material can be used in the user's example by including the header file:
 \begin{cpp}
 #include "material_XXX.hh"
 \end{cpp}
 For existing materials, as mentioned in Section~\ref{sect:smm:CL}, by
 default, the materials are initialized inside the method
 \code{initFull}. If a local material should be used instead, the
 initialization of the material has to be postponed until the local
 material is registered in the model. Therefore, the model is
 initialized with the boolean for skipping the material initialization
 equal to true:
 \begin{cpp}
 /// model initialization
 model.initFull(_analysis_method = _explicit_lumped_mass);
 \end{cpp}
 Once the model has been initialized, the local material needs
 to be registered in the model:
 \begin{cpp}
 model.registerNewCustomMaterials<XXX>("name_of_local_material");
 \end{cpp}
 Only at this point the material can be initialized:
 \begin{cpp}
 model.initMaterials();
 \end{cpp}
 A full example for adding a new damage law can be found in
 \shellcode{\examplesdir/new\_material}.
 
 \subsection{Adding a New Non-Local Constitutive Law}\index{Material!create a new non-local material}
 
 In order to add a new non-local material we first have to add the local constitutive law in \akantu (see above). We can then add the non-local version of the constitutive law by adding the two files (\code{material\_XXX\_non\_local.hh} and \code{material\_XXX\_non\_local.cc}) where \code{XXX} is the name of the corresponding local material. The new law must inherit from the two classes, non-local parent class, such as the \code{MaterialNonLocal} class, and from the local version of the constitutive law, \textit{i.e.} \code{MaterialXXX}. It is therefore necessary to include the interface of those classes in the header file of your custom material and indicate the inheritance in the declaration of the class:
 \begin{cpp}
 /* ---------------------------------------------------------------------- */
 #include "material_non_local.hh" // the non-local parent
 #include "material_XXX.hh"
 /* ---------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_XXX_HH__
 #define __AKANTU_MATERIAL_XXX_HH__
 
 namespace akantu {
 
 class MaterialXXXNonLocal : public MaterialXXX,
                             public MaterialNonLocal {
 
 /// declare here the interface of your material
 
 };
 \end{cpp}
 As members of the class we only need to add the internal fields to store the non-local quantities, which are obtained from the averaging process:
 \begin{cpp}
 /* -------------------------------------------------------------------------- */
 /* Class members                                                              */
 /* -------------------------------------------------------------------------- *
 protected:
   InternalField<Real> grad_u_nl;
 \end{cpp}
 The following four functions need to be implemented in the non-local material:
 \begin{cpp}
   /// initialization of the material
   void initMaterial();
   /// loop over all element and invoke stress computation
   virtual void computeNonLocalStresses(GhostType ghost_type);
   /// compute stresses after local quantities have been averaged
   virtual void computeNonLocalStress(ElementType el_type, GhostType ghost_type)
   /// compute all local quantities
   void computeStress(ElementType el_type, GhostType ghost_type);
 \end{cpp}
 In the intialization of the non-local material we need to register the local quantity for the averaging process. In our example the internal field \emph{grad\_u\_nl} is the non-local counterpart of the gradient of the displacement field (\emph{grad\_u\_nl}):
 \begin{cpp}
   void MaterialXXXNonLocal::initMaterial() {
     MaterialXXX::initMaterial();
     MaterialNonLocal::initMaterial();
     /// register the non-local variable in the manager
     this->model->getNonLocalManager().registerNonLocalVariable(this->grad_u.getName(), this->grad_u_nl.getName(), spatial_dimension * spatial_dimension);
 
 }
 \end{cpp}
 The function to register the non-local variable takes as parameters the name of the local internal field, the name of the non-local counterpart and the number of components of the field we want to average.
 In the \emph{computeStress} we now need to compute all the quantities we want to average. We can then write a loop for the stress computation in the function \emph{computeNonLocalStresses} and then provide the constitutive law on each integration point in the function \emph{computeNonLocalStress}.
 
 
 
 %%% Local Variables: %%% mode: latex %%% TeX-master: "manual" %%% End:
diff --git a/doc/manual/manual-structuralmechanicsmodel.tex b/doc/manual/manual-structuralmechanicsmodel.tex
index bcf89724e..2703454f4 100644
--- a/doc/manual/manual-structuralmechanicsmodel.tex
+++ b/doc/manual/manual-structuralmechanicsmodel.tex
@@ -1,250 +1,250 @@
 \chapter{Structural  Mechanics   Model}
 Static structural mechanics problems can be handled using the
 class \code{StructuralMechanicsModel}.  So far, \akantu provides 2D and 3D
 Bernoulli beam elements \cite{frey2009}.  This model is instantiated for a given
 \code{Mesh}, as for the \code{SolidMechanicsModel}.  The model will create its own \code{FEEngine} object to
 compute the interpolation, gradient, integration and assembly
 operations.  The \code{StructuralMechanicsModel} constructor is called
 in the following way:
 
 \begin{cpp}
   StructuralMechanicsModel model(mesh, spatial_dimension);
 \end{cpp}
 where \code{mesh} is a \code{Mesh} object defining the structure for
 which the equations of statics are to be solved, and
 \code{spatial\_dimension} is the dimensionality of the problem.  If
 \code{spatial\_dimension} is omitted, the problem is assumed to have
 the same dimensionality as the one specified by the mesh.
 
 \note[\ 1]{Dynamic computations are not supported to date.}
 
 \note[\ 2]{Structural meshes are created and loaded as described in
   Section~\ref{sect:common:mesh} with \code{\_miot\_gmsh\_struct} instead  of \code{\_miot\_gmsh}:}
 
 \begin{cpp}
   Mesh mesh;
   mesh.read("structural_mesh.msh", _miot_gmsh_struct);
 \end{cpp}
 
 This model contains at least the following \code{Arrays}:
 \begin{description}
 \item[blocked\_dofs] contains a Boolean value for each degree of
   freedom specifying whether that degree is blocked or not. A
   Dirichlet boundary condition can be prescribed by setting the
   \textbf{blocked\_dofs} value of a degree of freedom to
   \code{true}. The \textbf{displacement} is computed for all degrees
   of freedom for which the \textbf{blocked\_dofs} value is set to
   \code{false}. For the remaining degrees of freedom, the imposed
   values (zero by default after initialization) are kept.
 
 
 
 \item[displacement\_rotation] contains the generalized displacements
   (\textit{i.e.} displacements and rotations) of all degrees of freedom. It can be
   either a computed displacement for free degrees of freedom or an
   imposed displacement in case of blocked ones ($\vec{u}$ in the
   following).
 
 \item[external\_force] contains the generalized external forces (forces
   and moments) applied to the nodes ($\vec{f_{\st{ext}}}$ in the
   following).
 
 \item[internal\_force] contains the generalized internal forces (forces
   and moments) applied to the nodes ($\vec{f_{\st{int}}}$ in the
   following).
 \end{description}
 
 An example to help understand how  to use this model will be presented in the
 next section.
 
 \section{Model Setup}
 \label{sec:structMechMod:setup}
 
 \subsection{Initialization}
 The easiest way to initialize the structural mechanics model is:
 
 \begin{cpp}
   model.initFull();
 \end{cpp}
 The method \code{initFull} computes the shape functions, initializes
 the internal vectors mentioned above and allocates the memory for the
 stiffness matrix, unlike the solid mechanics model, its default argument is \code{\_static}.
 
 Material properties are defined using the \code{StructuralMaterial}
 structure described in
 Table~\ref{tab:structMechMod:strucMaterial}. Such a definition could,
 for instance, look like
 \begin{cpp}
   StructuralMaterial mat1;
   mat.E=3e10;
   mat.I=0.0025;
   mat.A=0.01;
 \end{cpp}
 
 \begin{table}[htb] \centering
   \begin{tabular}{cl}
     \toprule
     Field  & Description \\
     \midrule
     \code{E} & Young's  modulus  \\
     \code{A}  & Cross  section  area  \\
     \code{I} & Second cross sectional  moment of inertia (for 2D elements)\\
     \code{Iy} & \code{I}  around beam $y$--axis (for 3D elements)\\
     \code{Iz} & \code{I}  around beam $z$--axis (for 3D elements)\\
     \code{GJ}  & Polar  moment of inertia  of beam  cross section (for 3D elements)\\
     \bottomrule
   \end{tabular}
   \caption{Material properties  for structural elements  defined in
 the class \code{StructuralMaterial}.}
   \label{tab:structMechMod:strucMaterial}
 \end{table}
 Materials can be added to the model's \code{element\_material} vector using
 \begin{cpp}
   model.addMaterial(mat1);
 \end{cpp}
 
 They are successively numbered and then assigned to specific elements.
 \begin{cpp}
-for (UInt i = 0; i < nb_element_mat_1; ++i) {
+for (Int i = 0; i < nb_element_mat_1; ++i) {
     model.getElementMaterial(_bernoulli_beam_2)(i,0) = 1;
   }
 \end{cpp}
 
 
 \subsection{Setting Boundary Conditions}\label{sect:structMechMod:boundary}
 
 As explained before, the Dirichlet boundary conditions are applied through the
 array \textbf{blocked\_dofs}. Two options exist to define Neumann conditions.
 If a nodal force is applied, it has to be directly set in the array
 \textbf{force\_momentum}. For loads distributed along the beam length, the
 method \code{computeForcesFromFunction} integrates them into nodal forces.  The
 method takes as input a function describing the distribution of loads along the
 beam and a functor \code{BoundaryFunctionType} specifing if the function is
 expressed in the local coordinates (\code{\_bft\_traction\_local}) or in the
 global system of coordinates (\code{\_bft\_traction}).
 \begin{cpp}
  static void lin_load(double * position, double * load,
-		      Real * normal, UInt surface_id){
+		      Real * normal, Int surface_id){
   memset(load,0,sizeof(Real)*3);
   load[1] = position[0]*position[0]-250;
 }
 int main(int argc, char *argv[]){
 ...
 model.computeForcesFromFunction<_bernoulli_beam_2>(lin_load,
                                                    _bft_traction_local);
 ...}
 \end{cpp}
 
 
 \section{Static Analysis\label{sect:structMechMod:static}}
 
 The \code{StructuralMechanicsModel} class can perform static analyses
 of structures.  In this case, the equation to solve is the same as for
 the \code{SolidMechanicsModel} used for static analyses
 \begin{equation}\label{eqn:structMechMod:static}
   \mat{K} \vec{u} = \vec{f_{\st{ext}}}~,
 \end{equation}
 where $\mat{K}$ is the global stiffness matrix, $\vec{u}$ the
 generalized displacement vector and $\vec{f_{\st{ext}}}$ the vector of
 generalized external forces applied to the system.
 
 To solve such a problem, the static solver of the
 \code{StructuralMechanicsModel}\index{StructuralMechanicsModel} object
 is used.  First a model has to be created and initialized.
 
 \begin{cpp}
   StructuralMechanicsModel model(mesh);
   model.initFull();
 \end{cpp}
 
 
 \begin{itemize}
 \item \code{model.initFull} initializes all internal vectors to zero.
 \end{itemize}
 
 
 Once the model is created and initialized, the boundary conditions can
 be set as explained in Section~\ref{sect:structMechMod:boundary}.
 Boundary conditions will prescribe the external forces or moments for
 the free degrees of freedom $\vec{f_{\st{ext}}}$ and displacements or
 rotations for the others.  To completely define the system represented
 by equation (\ref{eqn:structMechMod:static}), the global stiffness
 matrix $\mat{K}$ must be assembled.
 \index{StructuralMechanicsModel!assembleStiffnessMatrix}
 
 \begin{cpp}
   model.assembleStiffnessMatrix();
 \end{cpp}
 
 The computation of the static equilibrium is performed using the same
 Newton-Raphson algorithm as described in
 Section~\ref{sect:smm:static}.
 
 \note{To date,
 \code{StructuralMechanicsModel} handles only constitutively and
 geometrically linear problems, the algorithm is therefore guaranteed
 to converge in two iterations.}
 
 \begin{cpp}
   model.updateResidual();
   model.solve();
 \end{cpp}
 \index{StructuralMechanicsModel!updateResidual}
 \index{StructuralMechanicsModel!solve}
 
 \begin{itemize}
 
 \item \code{model.updateResidual} assembles the internal forces and
   removes them from the external forces.
 \item \code{model.solve} solves the Equation (\ref{eqn:structMechMod:static}).
   The \textbf{increment} vector of the model will contain the new
   increment of displacements, and the \textbf{displacement\_rotation}
   vector is also updated to the new displacements.
 
 \end{itemize}
 
 %At the end of the analysis, the final solution is stored in the
 %\textbf{displacement} vector.  A full example of how to solve a
 %structural mechanics problem is presented in the code
 %\shellcode{\examplesdir/structural\_mechanics/test\_structural\_mechanics\_model\_bernoulli\_beam\_2\_exemple\_1\_1.cc}.
 %This example is composed of a 2D beam, clamped at the left end and
 %supported by two rollers as shown in Figure
 %\ref{fig:structMechMod:exem1_1}.  The problem is defined by the
 %applied load $q=\SI{6}{\kilo\newton\per\metre}$, moment $\bar{M} =
 %\SI{3.6}{\kilo\newton\metre}$, moments of inertia $I_1 =
 %\SI{250\,000}{\power{\centi\metre}{4}}$ and $I_2 =
 %\SI{128\,000}{\power{\centi\metre}{4}}$ and lengths $L_1 =
 %\SI{10}{\metre}$ and $L_2 = \SI{8}{\metre}$.  The resulting
 %rotations at node two and three are $ \varphi_2 = 0.001\,167\
 %\mbox{and}\ \varphi_3 = -0.000\,771.$
 
 At the end of the analysis, the final solution is stored in the
 \textbf{displacement\_rotation} vector.  A full example of how to
 solve a structural mechanics problem is presented in the code
 \shellcode{\examplesdir/structural\_mechanics/bernoulli\_beam\_2\_example.cc}.
 This example is composed of a 2D beam, clamped at the left end and
 supported by two rollers as shown in Figure
 \ref{fig:structMechMod:exem1_1}.  The problem is defined by the
 applied load $q=\SI{6}{\kilo\newton\per\metre}$, moment $\bar{M} =
 \SI{3.6}{\kilo\newton\metre}$, moments of inertia $I_1 =
 \SI{250\,000}{\centi\metre\tothe{4}}$ and $I_2 =
 \SI{128\,000}{\centi\metre\tothe{4}}$ and lengths $L_1 =
 \SI{10}{\metre}$ and $L_2 = \SI{8}{\metre}$.  The resulting
 rotations at node two and three are $ \varphi_2 = 0.001\,167\
 \mbox{and}\ \varphi_3 = -0.000\,771.$
 
  \begin{figure}[htb]
    \centering
    \includegraphics[scale=1.1]{figures/beam_example}
    \caption{2D beam example}
    \label{fig:structMechMod:exem1_1}
  \end{figure}
 
 
 
 
 
 %%% Local Variables:
 %%% mode: latex
 %%% TeX-master: "manual"
 %%% End:
diff --git a/src/common/aka_array_tmpl.hh b/src/common/aka_array_tmpl.hh
index cac962af7..ef7b989fc 100644
--- a/src/common/aka_array_tmpl.hh
+++ b/src/common/aka_array_tmpl.hh
@@ -1,1167 +1,1167 @@
 /**
  * @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__
 /* -------------------------------------------------------------------------- */
 
 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(Int new_size,
                                                    Int 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.array()[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 size_type = typename ArrayBase::size_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.derived().data(), new_elem.size(),
-                values + this->nb_component * (this->size_ - 1));
+    make_view(*this, nb_component).begin()[this->size_].array() =
+        new_elem.array();
   }
 
   /// 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 size_type 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(Idx 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();
 }
 
 /* ------------------------------------------------------------------------ */
 template <class T, bool is_scal>
 template <typename R>
 inline auto Array<T, is_scal>::erase(const view_iterator<R> & it) {
   auto && curr = it.data();
   Idx pos = (curr - this->values) / this->nb_component;
   erase(pos);
   view_iterator<R> rit = it;
   return --rit;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Subtract another array entry by entry from this array in place. Both arrays
  * must
  * have the same size and nb_component. If the arrays have different shapes,
  * code compiled in debug mode will throw an expeption and optimised code
  * will behave in an unpredicted manner
  * @param other array to subtract from this
  * @return reference to modified this
  */
 template <class T, bool is_scal>
 Array<T, is_scal> &
 Array<T, is_scal>::operator-=(const Array<T, is_scal> & vect) {
   AKANTU_DEBUG_ASSERT((this->size_ == vect.size_) &&
                           (this->nb_component == vect.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> & vect) {
   AKANTU_DEBUG_ASSERT((this->size_ == vect.size()) &&
                           (this->nb_component == vect.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>
 auto Array<T, is_scal>::operator*=(const T & alpha) -> Array & {
   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 & 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 == other.data()) {
     return true;
   }
 
   return std::equal(this->values,
                     this->values + this->size_ * this->nb_component,
                     other.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 <typename C, std::enable_if_t<aka::is_tensor<C>::value> *>
 inline void Array<T, is_scal>::set(const C & elem) {
   AKANTU_DEBUG_ASSERT(
       this->nb_component == elem.array().size(),
       "The size of the object does not match the number of components");
 
   for (auto && v : make_view(*this, this->nb_component)) {
     v = elem.array();
   }
 }
 
 /* ------------------------------------------------------------------------ */
 template <class T, bool is_scal>
 void Array<T, is_scal>::append(const Array & 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>
 auto Array<T, is_scal>::operator=(const Array & other) -> Array & {
   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>
 template <typename V, std::enable_if_t<aka::is_tensor<V>::value> *>
 inline Idx Array<T, is_scal>::find(const V & elem) {
   AKANTU_DEBUG_ASSERT(elem.size() == this->nb_component,
                       "Cannot find an element with a wrong size ("
                           << elem.size() << ") != " << this->nb_component);
   auto && view = make_view(*this, elem.size());
 
   auto begin = view.begin();
   auto end = view.end();
   auto it = std::find(begin, end, elem);
 
   return (it != end) ? it - begin : Idx(-1);
 }
 
 /* ------------------------------------------------------------------------ */
 /**
  * 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(other.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;
 }
 
 /* ------------------------------------------------------------------------ */
 /* ArrayFilter                                                              */
 /* ------------------------------------------------------------------------ */
 template <typename T> class ArrayFilter {
 public:
   /// const iterator
   template <class original_iterator, typename filter_iterator>
   class const_iterator {
   public:
     Idx getCurrentIndex() {
       return (*this->filter_it * this->nb_item_per_elem +
               this->sub_element_counter);
     }
 
     inline const_iterator() = default;
     inline const_iterator(original_iterator origin_it,
                           filter_iterator filter_it, Int nb_item_per_elem)
         : origin_it(std::move(origin_it)), filter_it(std::move(filter_it)),
           nb_item_per_elem(nb_item_per_elem), sub_element_counter(0){};
 
     inline bool operator!=(const_iterator & other) const {
       return !((*this) == other);
     }
     inline bool operator==(const_iterator & other) const {
       return (this->origin_it == other.origin_it &&
               this->filter_it == other.filter_it &&
               this->sub_element_counter == other.sub_element_counter);
     }
 
     inline bool operator!=(const const_iterator & other) const {
       return !((*this) == other);
     }
     inline bool operator==(const const_iterator & other) const {
       return (this->origin_it == other.origin_it &&
               this->filter_it == other.filter_it &&
               this->sub_element_counter == other.sub_element_counter);
     }
 
     inline const_iterator & operator++() {
       ++sub_element_counter;
       if (sub_element_counter == nb_item_per_elem) {
         sub_element_counter = 0;
         ++filter_it;
       }
       return *this;
     };
 
     inline decltype(auto) operator*() {
       return origin_it[nb_item_per_elem * (*filter_it) + sub_element_counter];
     };
 
   private:
     original_iterator origin_it;
     filter_iterator filter_it;
     /// the number of item per element
     Int nb_item_per_elem;
     /// counter for every sub element group
     Int sub_element_counter;
   };
 
   using vector_iterator = void; // iterator<Vector<T>>;
   using array_type = Array<T>;
   using const_vector_iterator =
       const_iterator<typename array_type::const_vector_iterator,
                      Array<Idx>::const_scalar_iterator>;
   using value_type = typename array_type::value_type;
 
 private:
   /* ---------------------------------------------------------------------- */
   /* Constructors/Destructors                                               */
   /* ---------------------------------------------------------------------- */
 public:
   ArrayFilter(const Array<T> & array, const Array<Idx> & filter,
               Int nb_item_per_elem)
       : array(array), filter(filter), nb_item_per_elem(nb_item_per_elem){};
 
   decltype(auto) begin_reinterpret(Int n, Int new_size) const {
     Int new_nb_item_per_elem = this->nb_item_per_elem;
     if (new_size != 0 && n != 0)
       new_nb_item_per_elem = this->array.getNbComponent() *
                              this->filter.size() * this->nb_item_per_elem /
                              (n * new_size);
 
     return const_vector_iterator(make_view(this->array, n).begin(),
                                  this->filter.begin(), new_nb_item_per_elem);
   };
 
   decltype(auto) end_reinterpret(Int n, Int new_size) const {
     Int new_nb_item_per_elem = this->nb_item_per_elem;
     if (new_size != 0 && n != 0)
       new_nb_item_per_elem = this->array.getNbComponent() *
                              this->filter.size() * this->nb_item_per_elem /
                              (n * new_size);
 
     return const_vector_iterator(make_view(this->array, n).begin(),
                                  this->filter.end(), new_nb_item_per_elem);
   };
 
   // vector_iterator begin_reinterpret(Int, Int) { throw; };
   // vector_iterator end_reinterpret(Int, Int) { throw; };
 
   /// return the size of the filtered array which is the filter size
   Int size() const { return this->filter.size() * this->nb_item_per_elem; };
   /// the number of components of the filtered array
   Int getNbComponent() const { return this->array.getNbComponent(); };
 
   /// tells if the container is empty
   bool empty() const [[gnu::warn_unused_result]] { return (size() == 0); }
   /* ---------------------------------------------------------------------- */
   /* Class Members                                                          */
   /* ---------------------------------------------------------------------- */
 private:
   /// reference to array of data
   const Array<T> & array;
   /// reference to the filter used to select elements
   const Array<Idx> & filter;
   /// the number of item per element
   Int nb_item_per_elem;
 };
 
 /* ------------------------------------------------------------------------ */
 /* 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...));
     }
 
     return aka::apply([&](auto... n) { return iterator(data, n...); },
                       take_front<sizeof...(Ns) - 1>(std::make_tuple(ns...)));
   }
 } // 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:
     using size_type = Idx;
 
     ~ArrayView() = default;
     constexpr ArrayView(Array && array, Ns... ns) noexcept
         : array(array), sizes(std::move(ns)...) {}
 
     constexpr ArrayView(const ArrayView & array_view) = default;
     constexpr ArrayView(ArrayView && array_view) noexcept = default;
 
     constexpr ArrayView & operator=(const ArrayView & array_view) = default;
     constexpr 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<decltype(ns)>(ns)...);
           },
           sizes);
     }
 
     auto begin() const {
       return aka::apply(
           [&](auto &&... ns) {
             return detail::get_iterator(array.get(), array.get().data(),
                                         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<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<decltype(ns)>(ns)...),
                 std::forward<decltype(ns)>(ns)...);
           },
           sizes);
     }
 
     auto cbegin() const { return this->begin(); }
     auto cend() const { return this->end(); }
 
     constexpr auto size() const {
       return std::get<std::tuple_size<tuple>::value - 1>(sizes);
     }
 
     constexpr auto dims() const { return std::tuple_size<tuple>::value - 1; }
 
   private:
     std::reference_wrapper<std::remove_reference_t<Array>> array;
     tuple sizes;
   };
 
   /* ---------------------------------------------------------------------- */
   template <typename T, typename... Ns>
   class ArrayView<const ArrayFilter<T> &, Ns...> {
     using tuple = std::tuple<Ns...>;
 
   public:
     constexpr ArrayView(const ArrayFilter<T> & array, Ns... ns)
         : array(array), sizes(std::move(ns)...) {}
 
     constexpr ArrayView(const ArrayView & array_view) = default;
     constexpr ArrayView(ArrayView && array_view) = default;
 
     constexpr ArrayView & operator=(const ArrayView & array_view) = default;
     constexpr ArrayView & operator=(ArrayView && array_view) = default;
 
     auto begin() const {
       return aka::apply(
           [&](auto &&... ns) {
             return array.get().begin_reinterpret(
                 std::forward<decltype(ns)>(ns)...);
           },
           sizes);
     }
 
     auto end() const {
       return aka::apply(
           [&](auto &&... ns) {
             return array.get().end_reinterpret(
                 std::forward<decltype(ns)>(ns)...);
           },
           sizes);
     }
 
     auto cbegin() const { return this->begin(); }
     auto cend() const { return this->end(); }
 
     constexpr auto size() const {
       return std::get<std::tuple_size<tuple>::value - 1>(sizes);
     }
 
     constexpr auto dims() const { return std::tuple_size<tuple>::value - 1; }
 
   private:
     std::reference_wrapper<const ArrayFilter<T>> 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);
 }
 
 } // namespace akantu
 
 //#endif /* __AKANTU_AKA_ARRAY_TMPL_HH__ */
diff --git a/src/common/aka_common.cc b/src/common/aka_common.cc
index 4dca7b03b..35a14e8ec 100644
--- a/src/common/aka_common.cc
+++ b/src/common/aka_common.cc
@@ -1,156 +1,156 @@
 /**
  * @file   aka_common.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Jun 14 2010
  * @date last modification: Wed Dec 09 2020
  *
  * @brief  Initialization of global variables
  *
  *
  * @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_random_generator.hh"
 #include "communicator.hh"
 
 #include "cppargparse.hh"
 #include "parser.hh"
 
 #include "communication_tag.hh"
 /* -------------------------------------------------------------------------- */
 #include <cmath>
 #include <ctime>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 void initialize(int & argc, char **& argv) {
   AKANTU_DEBUG_IN();
 
   initialize("", argc, argv);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void initialize(const std::string & input_file, int & argc, char **& argv) {
   AKANTU_DEBUG_IN();
   Communicator & comm = Communicator::getStaticCommunicator(argc, argv);
 
   Tag::setMaxTag(comm.getMaxTag());
 
   debug::debugger.setParallelContext(comm.whoAmI(), comm.getNbProc());
   debug::setDebugLevel(dblError);
 
   static_argparser.setParallelContext(comm.whoAmI(), comm.getNbProc());
   static_argparser.setExternalExitFunction(debug::exit);
   static_argparser.addArgument("--aka_input_file", "Akantu's input file", 1,
                                cppargparse::_string, std::string());
   static_argparser.addArgument(
       "--aka_debug_level",
       std::string("Akantu's overall debug level") +
           std::string(" (0: error, 1: exceptions, 4: warnings, 5: info, ..., "
                       "100: dump") +
           std::string(" more info on levels can be foind in aka_error.hh)"),
       1, cppargparse::_integer, (long int)(dblWarning));
 
   static_argparser.addArgument(
       "--aka_print_backtrace",
       "Should Akantu print a backtrace in case of error", 0,
       cppargparse::_boolean, false, true);
 
   static_argparser.addArgument("--aka_seed", "The seed to use on prank 0", 1,
                                cppargparse::_integer);
 
   static_argparser.parse(argc, argv, cppargparse::_remove_parsed);
 
   std::string infile = static_argparser["aka_input_file"];
   if (infile.empty()) {
     infile = input_file;
   }
   debug::debugger.printBacktrace(static_argparser["aka_print_backtrace"]);
 
   if (not infile.empty()) {
     readInputFile(infile);
   }
 
   long int seed;
   if (static_argparser.has("aka_seed")) {
     seed = static_argparser["aka_seed"];
   } else {
     seed =
         static_parser.getParameter("seed", time(nullptr), _ppsc_current_scope);
   }
 
   seed *= (comm.whoAmI() + 1);
-  RandomGenerator<UInt>::seed(seed);
+  RandomGenerator<Idx>::seed(seed);
 
   long int dbl_level = static_argparser["aka_debug_level"];
   debug::setDebugLevel(DebugLevel(dbl_level));
 
   AKANTU_DEBUG_INFO("Random seed set to " << seed);
 
   std::atexit(finalize);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void finalize() {}
 
 /* -------------------------------------------------------------------------- */
 void readInputFile(const std::string & input_file) {
   static_parser.parse(input_file);
 }
 
 /* -------------------------------------------------------------------------- */
 cppargparse::ArgumentParser & getStaticArgumentParser() {
   return static_argparser;
 }
 
 /* -------------------------------------------------------------------------- */
 Parser & getStaticParser() { return static_parser; }
 
 /* -------------------------------------------------------------------------- */
 const ParserSection & getUserParser() {
   return *(static_parser.getSubSections(ParserType::_user).first);
 }
 
 std::unique_ptr<Communicator> Communicator::static_communicator;
 
 std::ostream & operator<<(std::ostream & stream, NodeFlag flag) {
   using under = std::underlying_type_t<NodeFlag>;
   auto digits = static_cast<int>(
       std::log(std::numeric_limits<under>::max() + 1) / std::log(16));
   std::ios_base::fmtflags ff;
   ff = stream.flags();
   auto value = static_cast<std::common_type_t<under, unsigned int>>(flag);
   stream << "0x" << std::hex << std::setw(digits) << std::setfill('0') << value;
   stream.flags(ff);
   return stream;
 }
 
 } // namespace akantu
diff --git a/src/common/aka_extern.cc b/src/common/aka_extern.cc
index d71f98cf3..e5d0913c0 100644
--- a/src/common/aka_extern.cc
+++ b/src/common/aka_extern.cc
@@ -1,98 +1,101 @@
 /**
  * @file   aka_extern.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Jun 14 2010
  * @date last modification: Tue Oct 27 2020
  *
  * @brief  initialisation of all global variables
  * to insure the order of creation
  *
  *
  * @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 "aka_common.hh"
 #include "aka_math.hh"
 #include "aka_named_argument.hh"
 #include "aka_random_generator.hh"
 #include "communication_tag.hh"
 #include "cppargparse.hh"
 #include "parser.hh"
 #include "solid_mechanics_model.hh"
 #if defined(AKANTU_COHESIVE_ELEMENT)
 #include "solid_mechanics_model_cohesive.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 #include <limits>
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* error.hpp variables                                                        */
 /* -------------------------------------------------------------------------- */
 namespace debug {
   /** \todo write function to get this
    *   values from the environment or a config file
    */
   /// standard output for debug messages
   std::ostream * _akantu_debug_cout = &std::cerr;
 
   /// standard output for normal messages
   std::ostream & _akantu_cout = std::cout;
 
   /// parallel context used in debug messages
   std::string _parallel_context;
 
   Debugger debugger;
 
 } // namespace debug
 
 /* -------------------------------------------------------------------------- */
 /// Paser for commandline arguments
 ::cppargparse::ArgumentParser static_argparser;
 
 /// Parser containing the information parsed by the input file given to initFull
 Parser static_parser;
 
 bool Parser::permissive_parser = false;
 
 /* -------------------------------------------------------------------------- */
 Real Math::tolerance = 1e2 * std::numeric_limits<Real>::epsilon();
 
 /* -------------------------------------------------------------------------- */
 const Int _all_dimensions [[gnu::unused]] = Int(-1);
 
 /* -------------------------------------------------------------------------- */
 const Array<Int> empty_filter(0, 1, "empty_filter");
 
 /* -------------------------------------------------------------------------- */
+template <> long int RandomGenerator<Idx>::_seed = 5489;
+template <> std::default_random_engine RandomGenerator<Idx>::generator(5489);
 template <> long int RandomGenerator<UInt>::_seed = 5489U;
 template <> std::default_random_engine RandomGenerator<UInt>::generator(5489U);
+
 /* -------------------------------------------------------------------------- */
 int Tag::max_tag = 0;
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/common/aka_random_generator.hh b/src/common/aka_random_generator.hh
index 0312f2bd8..28e8bdb12 100644
--- a/src/common/aka_random_generator.hh
+++ b/src/common/aka_random_generator.hh
@@ -1,285 +1,285 @@
 /**
  * @file   aka_random_generator.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Feb 21 2013
  * @date last modification: Tue Sep 29 2020
  *
  * @brief  generic random generator
  *
  *
  * @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_array.hh"
 /* -------------------------------------------------------------------------- */
 #include <random>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_AKA_RANDOM_GENERATOR_HH_
 #define AKANTU_AKA_RANDOM_GENERATOR_HH_
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* List of available distributions                                            */
 /* -------------------------------------------------------------------------- */
 // clang-format off
 #define AKANTU_RANDOM_DISTRIBUTION_TYPES                \
   ((uniform      , std::uniform_real_distribution ))    \
   ((exponential  , std::exponential_distribution  ))    \
   ((gamma        , std::gamma_distribution        ))    \
   ((weibull      , std::weibull_distribution      ))    \
   ((extreme_value, std::extreme_value_distribution))    \
   ((normal       , std::normal_distribution       ))    \
   ((lognormal    , std::lognormal_distribution    ))    \
   ((chi_squared  , std::chi_squared_distribution  ))    \
   ((cauchy       , std::cauchy_distribution       ))    \
   ((fisher_f     , std::fisher_f_distribution     ))    \
   ((student_t    , std::student_t_distribution    ))
 // clang-format on
 
 #define AKANTU_RANDOM_DISTRIBUTION_TYPES_PREFIX(elem) BOOST_PP_CAT(_rdt_, elem)
 #define AKANTU_RANDOM_DISTRIBUTION_PREFIX(s, data, elem)                       \
   AKANTU_RANDOM_DISTRIBUTION_TYPES_PREFIX(BOOST_PP_TUPLE_ELEM(2, 0, elem))
 
 enum RandomDistributionType {
   BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(AKANTU_RANDOM_DISTRIBUTION_PREFIX, _,
                                            AKANTU_RANDOM_DISTRIBUTION_TYPES)),
   _rdt_not_defined
 };
 
 /* -------------------------------------------------------------------------- */
 /* Generator                                                                  */
 /* -------------------------------------------------------------------------- */
 template <typename T> class RandomGenerator {
   /* ------------------------------------------------------------------------ */
 private:
   static long int _seed;                       // NOLINT
   static std::default_random_engine generator; // NOLINT
   /* ------------------------------------------------------------------------ */
 public:
   inline T operator()() { return generator(); }
 
   /// function to print the contain of the class
   void printself(std::ostream & stream, int /* indent */) const {
     stream << "RandGenerator [seed=" << _seed << "]";
   }
 
   /* ------------------------------------------------------------------------ */
 public:
   static void seed(long int s) {
     _seed = s;
     generator.seed(_seed);
   }
   static long int seed() { return _seed; }
 
   static constexpr T min() { return std::default_random_engine::min(); }
   static constexpr T max() { return std::default_random_engine::max(); }
 };
 
 #if defined(__clang__)
 template <typename T> long int RandomGenerator<T>::_seed; // NOLINT
 template <typename T> std::default_random_engine RandomGenerator<T>::generator;
 #endif
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 #undef AKANTU_RANDOM_DISTRIBUTION_PREFIX
 
 #define AKANTU_RANDOM_DISTRIBUTION_TYPE_PRINT_CASE(r, data, elem)              \
   case AKANTU_RANDOM_DISTRIBUTION_TYPES_PREFIX(                                \
       BOOST_PP_TUPLE_ELEM(2, 0, elem)): {                                      \
     stream << BOOST_PP_STRINGIZE(AKANTU_RANDOM_DISTRIBUTION_TYPES_PREFIX(      \
         BOOST_PP_TUPLE_ELEM(2, 0, elem)));                                     \
     break;                                                                     \
   }
 
 inline std::ostream & operator<<(std::ostream & stream,
                                  RandomDistributionType type) {
   switch (type) {
     BOOST_PP_SEQ_FOR_EACH(AKANTU_RANDOM_DISTRIBUTION_TYPE_PRINT_CASE, _,
                           AKANTU_RANDOM_DISTRIBUTION_TYPES)
   default:
     stream << UInt(type) << " not a RandomDistributionType";
     break;
   }
   return stream;
 }
 #undef AKANTU_RANDOM_DISTRIBUTION_TYPE_PRINT_CASE
 
 /* -------------------------------------------------------------------------- */
 /* Some Helper                                                                */
 /* -------------------------------------------------------------------------- */
 template <typename T, class Distribution> class RandomDistributionTypeHelper {
   enum { value = _rdt_not_defined };
 };
 
 /* -------------------------------------------------------------------------- */
 #define AKANTU_RANDOM_DISTRIBUTION_TYPE_GET_TYPE(r, data, elem)                \
   template <typename T>                                                        \
       struct RandomDistributionTypeHelper<T, BOOST_PP_TUPLE_ELEM(2, 1, elem) < \
                                                  T> > {                        \
     enum {                                                                     \
       value = AKANTU_RANDOM_DISTRIBUTION_TYPES_PREFIX(                         \
           BOOST_PP_TUPLE_ELEM(2, 0, elem))                                     \
     };                                                                         \
                                                                                \
     static void printself(std::ostream & stream) {                             \
       stream << BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(2, 0, elem));           \
     }                                                                          \
   };
 
 BOOST_PP_SEQ_FOR_EACH(AKANTU_RANDOM_DISTRIBUTION_TYPE_GET_TYPE, _,
                       AKANTU_RANDOM_DISTRIBUTION_TYPES)
 
 #undef AKANTU_RANDOM_DISTRIBUTION_TYPE_GET_TYPE
 
 /* -------------------------------------------------------------------------- */
 template <class T> class RandomDistribution {
 public:
   virtual ~RandomDistribution() = default;
 
   RandomDistribution() = default;
   RandomDistribution(const RandomDistribution & other) = default;
   RandomDistribution(RandomDistribution && other) noexcept = default;
   RandomDistribution & operator=(const RandomDistribution & other) = default;
   RandomDistribution &
   operator=(RandomDistribution && other) noexcept = default;
 
-  virtual T operator()(RandomGenerator<UInt> & gen) = 0;
+  virtual T operator()(RandomGenerator<Idx> & gen) = 0;
   virtual std::unique_ptr<RandomDistribution<T>> make_unique() const = 0;
   virtual void printself(std::ostream & stream, int = 0) const = 0;
 };
 
 template <class T, class Distribution>
 class RandomDistributionProxy : public RandomDistribution<T> {
 public:
   explicit RandomDistributionProxy(Distribution dist)
       : distribution(std::move(dist)) {}
 
-  T operator()(RandomGenerator<UInt> & gen) override {
+  T operator()(RandomGenerator<Idx> & gen) override {
     return distribution(gen);
   }
 
   std::unique_ptr<RandomDistribution<T>> make_unique() const override {
     return std::make_unique<RandomDistributionProxy<T, Distribution>>(
         distribution);
   }
 
   void printself(std::ostream & stream, int /* indent */ = 0) const override {
     RandomDistributionTypeHelper<T, Distribution>::printself(stream);
     stream << " [ " << distribution << " ]";
   }
 
 private:
   Distribution distribution;
 };
 
 /* -------------------------------------------------------------------------- */
 /* RandomParameter                                                            */
 /* -------------------------------------------------------------------------- */
 template <typename T> class RandomParameter {
 public:
   template <class Distribution>
   explicit RandomParameter(T base_value, Distribution dist)
       : base_value(base_value),
         type(RandomDistributionType(
             RandomDistributionTypeHelper<T, Distribution>::value)),
         distribution_proxy(
             std::make_unique<RandomDistributionProxy<T, Distribution>>(
                 std::move(dist))) {}
 
   explicit RandomParameter(T base_value)
       : base_value(base_value),
         type(RandomDistributionType(
             RandomDistributionTypeHelper<
                 T, std::uniform_real_distribution<T>>::value)),
         distribution_proxy(
             std::make_unique<
                 RandomDistributionProxy<T, std::uniform_real_distribution<T>>>(
                 std::uniform_real_distribution<T>(0., 0.))) {}
 
   RandomParameter(const RandomParameter & other)
       : base_value(other.base_value), type(other.type),
         distribution_proxy(other.distribution_proxy->make_unique()) {}
 
   RandomParameter & operator=(const RandomParameter & other) {
     distribution_proxy = other.distribution_proxy->make_unique();
     base_value = other.base_value;
     type = other.type;
     return *this;
   }
 
   RandomParameter(RandomParameter && other) noexcept = default;
   RandomParameter & operator=(RandomParameter && other) noexcept = default;
 
   virtual ~RandomParameter() = default;
 
   inline void setBaseValue(const T & value) { this->base_value = value; }
   inline T getBaseValue() const { return this->base_value; }
 
   template <template <typename> class Generator, class iterator>
   void setValues(iterator it, iterator end) {
-    RandomGenerator<UInt> gen;
+    RandomGenerator<Idx> gen;
     for (; it != end; ++it) {
       *it = this->base_value + (*distribution_proxy)(gen);
     }
   }
 
   virtual void printself(std::ostream & stream,
                          __attribute__((unused)) int indent = 0) const {
     stream << base_value;
     stream << " + " << *distribution_proxy;
   }
 
 private:
   /// Value with no random variations
   T base_value;
 
   /// Random distribution type
   RandomDistributionType type;
 
   /// Proxy to store a std random distribution
   std::unique_ptr<RandomDistribution<T>> distribution_proxy;
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline std::ostream & operator<<(std::ostream & stream,
                                  RandomDistribution<T> & _this) {
   _this.printself(stream);
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline std::ostream & operator<<(std::ostream & stream,
                                  RandomParameter<T> & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #endif /* AKANTU_AKA_RANDOM_GENERATOR_HH_ */
diff --git a/src/common/aka_types_eigen_matrix_base_plugin.hh b/src/common/aka_types_eigen_matrix_base_plugin.hh
index 4b1b01eba..d3f053016 100644
--- a/src/common/aka_types_eigen_matrix_base_plugin.hh
+++ b/src/common/aka_types_eigen_matrix_base_plugin.hh
@@ -1,257 +1,263 @@
 using size_type = Index;
 
 template <bool _is_vector = IsVectorAtCompileTime,
           std::enable_if_t<_is_vector> * = nullptr>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 MatrixBase(std::initializer_list<Scalar> list)
     : MatrixBase() {
   Index i = 0;
   for (auto val : list) {
     this->operator()(i++) = val;
   }
 }
 
 template <bool _is_vector = IsVectorAtCompileTime,
           std::enable_if_t<not _is_vector> * = nullptr>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 MatrixBase(std::initializer_list<std::initializer_list<Scalar>> list)
     : MatrixBase() {
   static_assert(std::is_trivially_copyable<Scalar>{},
                 "Cannot create a tensor on non trivial types");
   Index m = list.size();
   Index n = 0;
   for (auto row : list) {
     n = std::max(n, row.size());
   }
 
   if (RowsAtCompileTime != -1 and RowsAtCompileTime != m) {
     AKANTU_EXCEPTION(
         "The size of the matrix does not correspond to the initializer_list");
   }
 
   if (ColsAtCompileTime != -1 and ColsAtCompileTime != n) {
     AKANTU_EXCEPTION(
         "The size of the matrix does not correspond to the initializer_list");
   }
 
   if (RowsAtCompileTime != -1 or ColsAtCompileTime != -1) {
     this->resize(m, n);
   }
 
   Index i = 0, j = 0;
   for (auto & row : list) {
     for (auto & val : row) {
       this->operator()(i, j++) = val;
     }
     ++i;
     j = 0;
   }
 }
 
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void zero();
 
 template <bool _is_vector = IsVectorAtCompileTime,
           std::enable_if_t<not _is_vector> * = nullptr>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE auto operator()(Index c) {
   auto & d = this->derived();
   return Map<Matrix<Scalar, RowsAtCompileTime, 1>>(
       d.data() + c * d.outerStride(), d.outerStride());
 }
 
 template <bool _is_vector = IsVectorAtCompileTime,
           std::enable_if_t<not _is_vector> * = nullptr>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE auto operator()(Index c) const {
   const auto & d = this->derived();
   return d.col(c);
 }
 
 template <bool _is_vector = IsVectorAtCompileTime,
           std::enable_if_t<_is_vector> * = nullptr>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto) operator()(Index c) {
   return Base::operator()(c);
 }
 
 template <bool _is_vector = IsVectorAtCompileTime,
           std::enable_if_t<_is_vector> * = nullptr>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto) operator()(Index c) const {
   return Base::operator()(c);
 }
 
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto) operator()(Index i,
                                                                 Index j) {
   return Base::operator()(i, j);
 }
 
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto) operator()(Index i,
                                                                 Index j) const {
   return Base::operator()(i, j);
 }
 
 template <
     typename ED = Derived,
     typename T = std::remove_reference_t<decltype(*std::declval<ED>().data())>,
     std::enable_if_t<not std::is_const<T>::value and
                      ED::IsVectorAtCompileTime> * = nullptr>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto) begin();
 template <
     typename ED = Derived,
     typename T = std::remove_reference_t<decltype(*std::declval<ED>().data())>,
     std::enable_if_t<not std::is_const<T>::value and
                      ED::IsVectorAtCompileTime> * = nullptr>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto) end();
 
 template <typename ED = Derived,
           std::enable_if_t<ED::IsVectorAtCompileTime> * = nullptr>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto) begin() const;
 template <typename ED = Derived,
           std::enable_if_t<ED::IsVectorAtCompileTime> * = nullptr>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto) end() const;
 
 template <
     typename ED = Derived,
     typename T = std::remove_reference_t<decltype(*std::declval<ED>().data())>,
     std::enable_if_t<not std::is_const<T>::value and
                      not ED::IsVectorAtCompileTime> * = nullptr>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto) begin();
 template <
     typename ED = Derived,
     typename T = std::remove_reference_t<decltype(*std::declval<ED>().data())>,
     std::enable_if_t<not std::is_const<T>::value and
                      not ED::IsVectorAtCompileTime> * = nullptr>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto) end();
 
 template <typename ED = Derived,
           std::enable_if_t<not ED::IsVectorAtCompileTime> * = nullptr>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto) begin() const;
 template <typename ED = Derived,
           std::enable_if_t<not ED::IsVectorAtCompileTime> * = nullptr>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE decltype(auto) end() const;
 
 // clang-format off
 [[deprecated("use data instead to be stl compatible")]]
 Scalar * storage() {
   return this->data();
 }
 
 [[deprecated("use data instead to be stl compatible")]]
 const Scalar * storage() const {
   return this->data();
 }
 // clang-format on
 
 template <bool _is_vector = IsVectorAtCompileTime,
           std::enable_if_t<_is_vector> * = nullptr>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE auto size() const {
   return this->cols();
 }
 
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE auto size(Index i) const {
-  AKANTU_DEBUG_ASSERT(i < 1, "This tensor has only " << 1 << " dimensions, not "
+  AKANTU_DEBUG_ASSERT(i < 2, "This tensor has only " << 2 << " dimensions, not "
                                                      << (i + 1));
-  return this->cols();
+  return (i == 0) ? this->rows() : this->cols();
 }
 
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void set(const Scalar & t) {
   this->fill(t);
 }
 
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void eye(const Scalar & t = Scalar()) {
+  (*this) = t * Matrix<Scalar, Derived::RowsAtCompileTime,
+                       Derived::ColsAtCompileTime>::Identity(this->rows(),
+                                                             this->cols());
+}
+
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void clear() { this->fill(Scalar()); };
 
 template <typename OtherDerived>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE auto
 distance(const MatrixBase<OtherDerived> & other) const {
   return (*this - other).norm();
 }
 
 template <typename OtherDerived>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar
 doubleDot(const MatrixBase<OtherDerived> & other) const {
   Scalar sum = 0;
   eigen_assert(rows() == cols() and rows() == other.rows() and
                cols() == other.cols());
 
   this->cwiseProduct(other).sum();
 }
 
 template <typename OtherDerived>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
 eig(const MatrixBase<OtherDerived> & other) const;
 
 template <typename D1, typename D2>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
 eig(const MatrixBase<D1> & values, const MatrixBase<D2> & vectors) const;
 
 template <typename OtherDerived>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
 eigh(const MatrixBase<OtherDerived> & other) const;
 
 template <typename D1, typename D2>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
 eigh(const MatrixBase<D1> & values, const MatrixBase<D2> & vectors) const;
 /*
 public:
 */
 // template <bool ip, typename R = T,
 //           std::enable_if_t<std::is_floating_point<R>::value, int> = 0>
 // inline bool equal(const VectorBase<R, ip> & v,
 //                   R tolerance = Math::getTolerance()) const {
 //   T * a = this->data();
 //   T * b = v.data();
 //   idx_t i = 0;
 //   while (i < this->_size && (std::abs(*(a++) - *(b++)) < tolerance))
 //     ++i;
 //   return i == this->_size;
 // }
 
 // template <bool ip, typename R = T,
 //           std::enable_if_t<std::is_floating_point<R>::value, int> = 0>
 // inline short compare(const TensorBase<R, 1, ip> & v,
 //                      Real tolerance = Math::getTolerance()) const {
 //   T * a = this->data();
 //   T * b = v.data();
 //   for (UInt i(0); i < this->_size; ++i, ++a, ++b) {
 //     if (std::abs(*a - *b) > tolerance)
 //       return (((*a - *b) > tolerance) ? 1 : -1);
 //   }
 //   return 0;
 // }
 
 // template <bool ip, typename R = T,
 //           std::enable_if_t<not std::is_floating_point<R>::value, int> = 0>
 // inline bool equal(const TensorBase<R, 1, ip> & v) const {
 //   return std::equal(this->values, this->values + this->_size, v.data());
 // }
 
 // template <bool ip, typename R = T,
 //           std::enable_if_t<not std::is_floating_point<R>::value, int> = 0>
 // inline short compare(const TensorBase<R, 1, ip> & v) const {
 //   T * a = this->data();
 //   T * b = v.data();
 //   for (idx_t i(0); i < this->_size; ++i, ++a, ++b) {
 //     if (*a > *b)
 //       return 1;
 //     else if (*a < *b)
 //       return -1;
 //   }
 //   return 0;
 // }
 
 template <typename OtherDerived>
 inline bool operator<=(const MatrixBase<OtherDerived> & v) const {
   return this->isMuchSmallerThan(v);
 }
 
 template <typename OtherDerived>
 inline bool operator>=(const MatrixBase<OtherDerived> & v) const {
   return v.isMuchSmallerThan(*this);
 }
 
 template <typename OtherDerived>
 inline bool operator<(const MatrixBase<OtherDerived> & v) const {
   return (*this <= v) and (*this != v);
 }
 
 template <typename OtherDerived>
 inline bool operator>(const MatrixBase<OtherDerived> & v) const {
   return (*this >= v) and (*this != v);
 }
diff --git a/src/fe_engine/element_class_structural.hh b/src/fe_engine/element_class_structural.hh
index 23a64958f..b106c0d5c 100644
--- a/src/fe_engine/element_class_structural.hh
+++ b/src/fe_engine/element_class_structural.hh
@@ -1,287 +1,287 @@
 /**
  * @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"
+#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 constexpr InterpolationKind kind{_itk_structural};                  \
     static constexpr Int nb_nodes_per_element{                                 \
         InterpolationProperty<itp_geom_type>::nb_nodes_per_element};           \
     static constexpr InterpolationType itp_geometry_type{itp_geom_type};       \
     static constexpr Int natural_space_dimension{                              \
         InterpolationProperty<itp_geom_type>::natural_space_dimension};        \
     static constexpr Int nb_degree_of_freedom{ndof};                           \
     static constexpr Int nb_stress_components{nb_stress};                      \
     static constexpr Int 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 point in natural coordinates
   template <class D1, class D2, class D3>
   static inline void computeShapes(const Eigen::MatrixBase<D1> & natural_coord,
                                    const Eigen::MatrixBase<D2> & real_coord,
                                    Eigen::MatrixBase<D3> & N);
 
   /// compute the shape values for a given set of points in natural coordinates
   template <class D1, class D2, class D3>
   static inline void computeShapes(const Eigen::MatrixBase<D1> & Xs,
                                    const Eigen::MatrixBase<D2> & x,
                                    const Eigen::MatrixBase<D3> & T,
                                    TensorBase<Real, 3> & Ns) {
     Matrix<Real> N(Ns.size(1), Ns.size(2));
     for (auto && data : zip(Xs, Ns)) {
       auto && X = std::get<0>(data);
       auto && N_T = std::get<1>(data);
 
       computeShapes(X, x, N);
       N_T = N * T;
     }
   }
 
   template <class D1, class D2, class D3>
   static inline void computeShapesMass(const Eigen::MatrixBase<D1> & Xs,
                                        const Eigen::MatrixBase<D2> & x,
                                        const Eigen::MatrixBase<D3> & T,
                                        TensorBase<Real, 3> & Ns) {
     for (int i = 0; i < Xs.cols(); ++i) {
       auto N_T = Ns(i);
 
       Matrix<Real> N(interpolation_property::nb_degree_of_freedom, N_T.cols());
       computeShapes(Xs(i), x, N);
 
       N_T = N.block(0, 0, N_T.rows(), N_T.cols()) * T;
     }
   }
 
   /// compute shape derivatives (input is dxds) for a set of points
   template <class D>
   static inline void computeShapeDerivatives(const TensorBase<Real, 3> & Js,
                                              const TensorBase<Real, 3> & DNDSs,
                                              const Eigen::MatrixBase<D> & R,
                                              TensorBase<Real, 3> & Bs) {
     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)                                             \
+    elem_type, geom_type, interp_type, parent_el_type, sp, gauss_int_type,     \
+    min_int_order)                                                             \
   template <> struct ElementClassProperty<elem_type> {                         \
     static constexpr GeometricalType geometrical_type{geom_type};              \
     static constexpr InterpolationType interpolation_type{interp_type};        \
     static constexpr ElementType parent_element_type{parent_el_type};          \
-    static constexpr ElementKind element_kind{elem_kind};                      \
+    static constexpr ElementKind element_kind{_ek_structural};                 \
     static constexpr Int spatial_dimension{sp};                                \
     static constexpr GaussIntegrationType gauss_integration_type{              \
         gauss_int_type};                                                       \
     static constexpr Int 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, typename D3,
             std::enable_if_t<aka::is_vector<D3>::value> * = nullptr>
   static inline void computeJacobian(const Eigen::MatrixBase<D1> & Xs,
                                      const Eigen::MatrixBase<D2> & xs,
                                      Eigen::MatrixBase<D3> & 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 constexpr AKANTU_GET_MACRO_AUTO_NOT_CONST(Kind, _ek_structural);
   static constexpr AKANTU_GET_MACRO_AUTO_NOT_CONST(P1ElementType, _not_defined);
   static constexpr AKANTU_GET_MACRO_AUTO_NOT_CONST(FacetType, _not_defined);
   static constexpr auto getFacetType(__attribute__((unused)) Int t = 0) {
     return _not_defined;
   }
   static constexpr AKANTU_GET_MACRO_AUTO_NOT_CONST(
       SpatialDimension, ElementClassProperty<element_type>::spatial_dimension);
   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_classes/element_class_bernoulli_beam_inline_impl.hh b/src/fe_engine/element_classes/element_class_bernoulli_beam_inline_impl.hh
index af2c7ec9a..8f3a290a4 100644
--- a/src/fe_engine/element_classes/element_class_bernoulli_beam_inline_impl.hh
+++ b/src/fe_engine/element_classes/element_class_bernoulli_beam_inline_impl.hh
@@ -1,246 +1,245 @@
 /**
  * @file   element_class_bernoulli_beam_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 Jul 15 2011
  * @date last modification: Fri Feb 05 2021
  *
  * @brief  Specialization of the element_class class for the type
  * _bernoulli_beam_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
    --x-----q1----|----q2-----x---> x
     -1          0            1
  @endverbatim
  *
  */
 
 /* -------------------------------------------------------------------------- */
 //#include "element_class_structural.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_ELEMENT_CLASS_BERNOULLI_BEAM_INLINE_IMPL_HH_
 #define AKANTU_ELEMENT_CLASS_BERNOULLI_BEAM_INLINE_IMPL_HH_
 
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_STRUCTURAL_INTERPOLATION_TYPE_PROPERTY(_itp_bernoulli_beam_2,
                                                      _itp_lagrange_segment_2, 3,
                                                      2, 6);
 
 AKANTU_DEFINE_STRUCTURAL_INTERPOLATION_TYPE_PROPERTY(_itp_bernoulli_beam_3,
                                                      _itp_lagrange_segment_2, 6,
                                                      4, 6);
 
 AKANTU_DEFINE_STRUCTURAL_ELEMENT_CLASS_PROPERTY(_bernoulli_beam_2,
                                                 _gt_segment_2,
                                                 _itp_bernoulli_beam_2,
-                                                _segment_2, _ek_structural, 2,
-                                                _git_segment, 3);
+                                                _segment_2, 2, _git_segment, 3);
 
 AKANTU_DEFINE_STRUCTURAL_ELEMENT_CLASS_PROPERTY(_bernoulli_beam_3,
                                                 _gt_segment_2,
                                                 _itp_bernoulli_beam_3,
-                                                _segment_2, _ek_structural, 3,
-                                                _git_segment, 3);
+                                                _segment_2, 3, _git_segment, 3);
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <typename D1, typename D2, typename D3>
 inline void
 InterpolationElement<_itp_bernoulli_beam_2, _itk_structural>::computeShapes(
     const Eigen::MatrixBase<D1> & natural_coords,
     const Eigen::MatrixBase<D2> & real_coord, Eigen::MatrixBase<D3> & N) {
   Eigen::Matrix<Real, 2, 1> L;
   InterpolationElement<_itp_lagrange_segment_2, _itk_lagrangian>::computeShapes(
       natural_coords, L);
   Eigen::Matrix<Real, 2, 4> H;
   InterpolationElement<_itp_hermite_2, _itk_structural>::computeShapes(
       natural_coords, real_coord, H);
 
   // clang-format off
   //    u1   v1      t1      u2   v2      t2
   N << L(0), 0      , 0      , L(1), 0      , 0      ,  // u
        0   , H(0, 0), H(0, 1), 0   , H(0, 2), H(0, 3),  // v
        0   , H(1, 0), H(1, 1), 0   , H(1, 2), H(1, 3); // theta
   // clang-format on
 }
 
 template <>
 template <typename D1, typename D2, typename D3>
 inline void
 InterpolationElement<_itp_bernoulli_beam_3, _itk_structural>::computeShapes(
     const Eigen::MatrixBase<D1> & natural_coords,
     const Eigen::MatrixBase<D2> & real_coord, Eigen::MatrixBase<D3> & N) {
   Eigen::Matrix<Real, 2, 1> L;
   InterpolationElement<_itp_lagrange_segment_2, _itk_lagrangian>::computeShapes(
       natural_coords, L);
   Eigen::Matrix<Real, 2, 4> H;
   InterpolationElement<_itp_hermite_2, _itk_structural>::computeShapes(
       natural_coords, real_coord, H);
 
   // clang-format off
   //    u1    v1       w1       tx1   ty1       tz1    u2      v2       w2       tx2   ty2       tz2
   N << L(0), 0      , 0      , 0   , 0       , 0      , L(1), 0      , 0      , 0   , 0       , 0      ,  // u
        0   , H(0, 0), 0      , 0   , 0       , H(0, 1), 0   , H(0, 2), 0      , 0   , 0       , H(0, 3),  // v
        0   , 0      , H(0, 0), 0   , -H(0, 1), 0      , 0   , 0      , H(0, 2), 0   , -H(0, 3), 0      ,  // w
        0   , 0      , 0      , L(0), 0       , 0      , 0   , 0      , 0      , L(1), 0       , 0      ,  // thetax
        0   , 0      , H(1, 0), 0   , -H(1, 1), 0      , 0   , 0      , H(1, 2), 0   , -H(1, 3), 0      ,  // thetay
        0   , H(1, 0), 0      , 0   , 0       , H(1, 1), 0   , H(1, 2), 0      , 0   , 0       , H(1, 3); // thetaz
   // clang-format on
 }
 
 /* -------------------------------------------------------------------------- */
 #if 0
 template <>
 inline void
 InterpolationElement<_itp_bernoulli_beam_3, _itk_structural>::computeShapesDisplacements(
     const Vector<Real> & natural_coords, const Matrix<Real> & real_coord,
     Matrix<Real> & N) {
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2, class D3>
 inline void
 InterpolationElement<_itp_bernoulli_beam_2, _itk_structural>::computeDNDS(
     const Eigen::MatrixBase<D1> & Xs, const Eigen::MatrixBase<D2> & xs,
     Eigen::MatrixBase<D3> & dnds) {
   Eigen::Matrix<Real, 1, 2> L;
   InterpolationElement<_itp_lagrange_segment_2, _itk_lagrangian>::computeDNDS(
       Xs, L);
   Eigen::Matrix<Real, 1, 4> H;
   InterpolationElement<_itp_hermite_2, _itk_structural>::computeDNDS(Xs, xs, H);
 
   // Storing the derivatives in dnds
   dnds.block(0, 0, L.rows(), L.cols()) = L;
   dnds.block(0, 2, H.rows(), H.cols()) = H;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2>
 inline void
 InterpolationElement<_itp_bernoulli_beam_2, _itk_structural>::arrangeInVoigt(
     const Eigen::MatrixBase<D1> & dnds, Eigen::MatrixBase<D2> & B) {
   auto L = dnds.block(0, 0, 1, 2); // Lagrange shape derivatives
   auto H = dnds.block(0, 2, 1, 4); // Hermite shape derivatives
   // clang-format off
   //    u1       v1       t1        u2        v2        t2
   B << L(0, 0), 0,       0,        L(0, 1),  0,        0      ,
        0,      -H(0, 0), -H(0, 1), 0,       -H(0, 2), -H(0, 3);
   // clang-format on
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2, class D3>
 inline void
 InterpolationElement<_itp_bernoulli_beam_3, _itk_structural>::computeDNDS(
     const Eigen::MatrixBase<D1> & natural_coords,
     const Eigen::MatrixBase<D2> & real_coord, Eigen::MatrixBase<D3> & dnds) {
   InterpolationElement<_itp_bernoulli_beam_2, _itk_structural>::computeDNDS(
       natural_coords, real_coord, dnds);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2>
 inline void
 InterpolationElement<_itp_bernoulli_beam_3, _itk_structural>::arrangeInVoigt(
     const Eigen::MatrixBase<D1> & dnds, Eigen::MatrixBase<D2> & B) {
   auto L = dnds.block(0, 0, 1, 2); // Lagrange shape derivatives
   auto H = dnds.block(0, 2, 1, 4); // Hermite shape derivatives
 
   // clang-format off
   //    u1       v1        w1        x1       y1        z1        u2       v2        w2         x2       y2       z2
   B << L(0, 0), 0       , 0       , 0      , 0       , 0       , L(0, 1), 0       , 0        , 0      , 0        , 0      ,  // eps
        0      , -H(0, 0), 0       , 0      , 0       , -H(0, 1), 0      , -H(0, 2), 0        , 0      , 0        ,-H(0, 3),  // chi strong axis
        0      , 0       , -H(0, 0), 0      , H(0, 1) , 0       , 0      , 0       , -H(0, 2) , 0      , H(0, 3)  , 0      ,  // chi weak axis
        0      , 0       , 0       , L(0, 0), 0       , 0       , 0      , 0       , 0        , L(0, 1), 0        , 0      ; // chi torsion
   // clang-format on
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2, class D3>
 inline void ElementClass<_bernoulli_beam_2>::computeRotationMatrix(
     Eigen::MatrixBase<D1> & R, const Eigen::MatrixBase<D2> & X,
     const Eigen::MatrixBase<D3> &) {
   auto && x2 = X(1); // X2
   auto && x1 = X(0); // X1
 
   auto cs = (x2 - x1) / (x2 - x1).norm();
 
   auto c = cs(0);
   auto s = cs(1);
 
   // clang-format off
   /// Definition of the rotation matrix
   R << c,  s,  0.,
       -s,  c,  0.,
        0., 0., 1.;
   // clang-format on
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2, class D3>
 inline void ElementClass<_bernoulli_beam_3>::computeRotationMatrix(
     Eigen::MatrixBase<D1> & R, const Eigen::MatrixBase<D2> & X,
     const Eigen::MatrixBase<D3> & n) {
   Vector<Real> x2 = X(1); // X2
   Vector<Real> x1 = X(0); // X1
   auto dim = X.rows();
   Eigen::Matrix<Real, 1, 3> x = (x2 - x1), nv = n;
 
   x.normalize();
   auto x_n = x.cross(nv);
 
   Matrix<Real> Pe(dim, dim);
   Pe << 1., 0., 0., 0., -1., 0., 0., 0., 1.;
 
   Matrix<Real> Pg(dim, dim);
   Pg(0) = x;
   Pg(1) = x_n;
   Pg(2) = n;
 
   Pe *= Pg.inverse();
 
   R.zero();
   /// Definition of the rotation matrix
   for (Int i = 0; i < dim; ++i) {
     for (Int j = 0; j < dim; ++j) {
       R(i + dim, j + dim) = R(i, j) = Pe(i, j);
     }
   }
 }
 
 } // namespace akantu
+
 #endif /* AKANTU_ELEMENT_CLASS_BERNOULLI_BEAM_INLINE_IMPL_HH_ */
diff --git a/src/fe_engine/element_classes/element_class_kirchhoff_shell_inline_impl.hh b/src/fe_engine/element_classes/element_class_kirchhoff_shell_inline_impl.hh
index 2d5927f40..bb428d127 100644
--- a/src/fe_engine/element_classes/element_class_kirchhoff_shell_inline_impl.hh
+++ b/src/fe_engine/element_classes/element_class_kirchhoff_shell_inline_impl.hh
@@ -1,230 +1,229 @@
 /**
  * @file   element_class_kirchhoff_shell_inline_impl.hh
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Damien Spielmann <damien.spielmann@epfl.ch>
  *
  * @date creation: Fri Jul 04 2014
  * @date last modification: Tue Sep 29 2020
  *
  * @brief  Element class Kirchhoff Shell
  *
  *
  * @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_structural.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_ELEMENT_CLASS_KIRCHHOFF_SHELL_INLINE_IMPL_HH_
 #define AKANTU_ELEMENT_CLASS_KIRCHHOFF_SHELL_INLINE_IMPL_HH_
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_STRUCTURAL_INTERPOLATION_TYPE_PROPERTY(
     _itp_discrete_kirchhoff_triangle_18, _itp_lagrange_triangle_3, 6, 6, 21);
 
 AKANTU_DEFINE_STRUCTURAL_ELEMENT_CLASS_PROPERTY(
     _discrete_kirchhoff_triangle_18, _gt_triangle_3,
-    _itp_discrete_kirchhoff_triangle_18, _triangle_3, _ek_structural, 3,
-    _git_triangle, 2);
+    _itp_discrete_kirchhoff_triangle_18, _triangle_3, 3, _git_triangle, 2);
 
 /* -------------------------------------------------------------------------- */
 namespace detail {
   template <class D>
   inline decltype(auto)
   computeBasisChangeMatrix(const Eigen::MatrixBase<D> & X) {
     auto && X1 = X(0);
     auto && X2 = X(1);
     auto && X3 = X(2);
 
     Eigen::Matrix<Real, 1, 3> a1 = X2 - X1;
     Eigen::Matrix<Real, 1, 3> a2 = X3 - X1;
 
     a1.normalized();
     auto && e3 = a1.cross(a2).normalized();
     auto && e2 = e3.cross(a1);
 
     Eigen::Matrix<Real, 3, 3> P;
     P(0) = a1;
     P(1) = e2;
     P(2) = e3;
 
     return P.transpose();
   }
 } // namespace detail
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class D1, class D2, class D3>
 inline void
 ElementClass<_discrete_kirchhoff_triangle_18>::computeRotationMatrix(
     Eigen::MatrixBase<D1> & R, const Eigen::MatrixBase<D2> & X,
     const Eigen::MatrixBase<D3> &) {
   auto dim = X.rows();
 
   auto && P = detail::computeBasisChangeMatrix(X);
 
   R.zero();
   for (Int i = 0; i < dim; ++i) {
     for (Int j = 0; j < dim; ++j) {
       R(i + dim, j + dim) = R(i, j) = P(i, j);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <typename D1, typename D2, typename D3>
 inline void
 InterpolationElement<_itp_discrete_kirchhoff_triangle_18>::computeShapes(
     const Eigen::MatrixBase<D1> & /*natural_coords*/,
     const Eigen::MatrixBase<D2> & /*real_coord*/,
     Eigen::MatrixBase<D3> & /*N*/) {}
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <typename D1, typename D2, typename D3>
 inline void
 InterpolationElement<_itp_discrete_kirchhoff_triangle_18>::computeDNDS(
     const Eigen::MatrixBase<D1> & natural_coords,
     const Eigen::MatrixBase<D2> & real_coordinates, Eigen::MatrixBase<D3> & B) {
 
   auto && P = detail::computeBasisChangeMatrix(real_coordinates);
 
   auto && X = P * real_coordinates;
   auto && X1 = X(0);
   auto && X2 = X(1);
   auto && X3 = X(2);
 
   std::array<Vector<Real>, 3> A = {X2 - X1, X3 - X2, X1 - X3};
   std::array<Real, 3> L;
   std::array<Real, 3> C;
   std::array<Real, 3> S;
 
   // Setting all last coordinates to 0
   std::for_each(A.begin(), A.end(), [](auto & a) { a(2) = 0; });
   // Computing lengths
   std::transform(A.begin(), A.end(), L.begin(),
                  [](auto & a) { return a.norm(); });
   // Computing cosines
   std::transform(A.begin(), A.end(), L.begin(), C.begin(),
                  [](auto & a, auto & l) { return a(0) / l; });
   // Computing sines
   std::transform(A.begin(), A.end(), L.begin(), S.begin(),
                  [](auto & a, auto & l) { return a(1) / l; });
 
   // Natural coordinates
   Real xi = natural_coords(0);
   Real eta = natural_coords(1);
 
   // Derivative of quadratic interpolation functions
   Eigen::Matrix<Real, 2, 3> dP;
   dP << 4 * (1 - 2 * xi - eta), 4 * eta, -4 * eta, -4 * xi, 4 * xi,
       4 * (1 - xi - 2 * eta);
 
   Eigen::Matrix<Real, 2, 3> dNx1;
   dNx1 << 3. / 2 * (dP(0, 0) * C[0] / L[0] - dP(0, 2) * C[2] / L[2]),
       3. / 2 * (dP(0, 1) * C[1] / L[1] - dP(0, 0) * C[0] / L[0]),
       3. / 2 * (dP(0, 2) * C[2] / L[2] - dP(0, 1) * C[1] / L[1]),
       3. / 2 * (dP(1, 0) * C[0] / L[0] - dP(1, 2) * C[2] / L[2]),
       3. / 2 * (dP(1, 1) * C[1] / L[1] - dP(1, 0) * C[0] / L[0]),
       3. / 2 * (dP(1, 2) * C[2] / L[2] - dP(1, 1) * C[1] / L[1]);
   Eigen::Matrix<Real, 2, 3> dNx2;
   dNx2 << -1 - 3. / 4 * (dP(0, 0) * C[0] * C[0] + dP(0, 2) * C[2] * C[2]),
       1 - 3. / 4 * (dP(0, 1) * C[1] * C[1] + dP(0, 0) * C[0] * C[0]),
       -3. / 4 * (dP(0, 2) * C[2] * C[2] + dP(0, 1) * C[1] * C[1]),
       -1 - 3. / 4 * (dP(1, 0) * C[0] * C[0] + dP(1, 2) * C[2] * C[2]),
       -3. / 4 * (dP(1, 1) * C[1] * C[1] + dP(1, 0) * C[0] * C[0]),
       1 - 3. / 4 * (dP(1, 2) * C[2] * C[2] + dP(1, 1) * C[1] * C[1]);
 
   Eigen::Matrix<Real, 2, 3> dNx3;
   dNx3 << -3. / 4 * (dP(0, 0) * C[0] * S[0] + dP(0, 2) * C[2] * S[2]),
       -3. / 4 * (dP(0, 1) * C[1] * S[1] + dP(0, 0) * C[0] * S[0]),
       -3. / 4 * (dP(0, 2) * C[2] * S[2] + dP(0, 1) * C[1] * S[1]),
       -3. / 4 * (dP(1, 0) * C[0] * S[0] + dP(1, 2) * C[2] * S[2]),
       -3. / 4 * (dP(1, 1) * C[1] * S[1] + dP(1, 0) * C[0] * S[0]),
       -3. / 4 * (dP(1, 2) * C[2] * S[2] + dP(1, 1) * C[1] * S[1]);
   Eigen::Matrix<Real, 2, 3> dNy1;
   dNy1 << 3. / 2 * (dP(0, 0) * S[0] / L[0] - dP(0, 2) * S[2] / L[2]),
       3. / 2 * (dP(0, 1) * S[1] / L[1] - dP(0, 0) * S[0] / L[0]),
       3. / 2 * (dP(0, 2) * S[2] / L[2] - dP(0, 1) * S[1] / L[1]),
       3. / 2 * (dP(1, 0) * S[0] / L[0] - dP(1, 2) * S[2] / L[2]),
       3. / 2 * (dP(1, 1) * S[1] / L[1] - dP(1, 0) * S[0] / L[0]),
       3. / 2 * (dP(1, 2) * S[2] / L[2] - dP(1, 1) * S[1] / L[1]);
   auto dNy2 = dNx3;
 
   Eigen::Matrix<Real, 2, 3> dNy3;
   dNy3 << -1 - 3. / 4 * (dP(0, 0) * S[0] * S[0] + dP(0, 2) * S[2] * S[2]),
       1 - 3. / 4 * (dP(0, 1) * S[1] * S[1] + dP(0, 0) * S[0] * S[0]),
       -3. / 4 * (dP(0, 2) * S[2] * S[2] + dP(0, 1) * S[1] * S[1]),
       -1 - 3. / 4 * (dP(1, 0) * S[0] * S[0] + dP(1, 2) * S[2] * S[2]),
       -3. / 4 * (dP(1, 1) * S[1] * S[1] + dP(1, 0) * S[0] * S[0]),
       1 - 3. / 4 * (dP(1, 2) * S[2] * S[2] + dP(1, 1) * S[1] * S[1]);
 
   // Derivative of linear (membrane mode) functions
   Eigen::Matrix<Real, 2, 3> dNm;
   InterpolationElement<_itp_lagrange_triangle_3, _itk_lagrangian>::computeDNDS(
       natural_coords, dNm);
 
   UInt i = 0;
   for (auto && mat : {dNm, dNx1, dNx2, dNx3, dNy1, dNy2, dNy3}) {
     B.block(2, 3, 0, i) = mat;
     i += mat.cols();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <typename D1, typename D2>
 inline void
 InterpolationElement<_itp_discrete_kirchhoff_triangle_18, _itk_structural>::
     arrangeInVoigt(const Eigen::MatrixBase<D1> & dnds,
                    Eigen::MatrixBase<D2> & B) {
   Eigen::Matrix<Real, 2, 3> dNm, dNx1, dNx2, dNx3, dNy1, dNy2, dNy3;
 
   UInt i = 0;
   for (auto && mat : {&dNm, &dNx1, &dNx2, &dNx3, &dNy1, &dNy2, &dNy3}) {
     *mat = dnds.block(2, 3, 0, i);
     i += mat->cols();
   }
 
   for (UInt i = 0; i < 3; ++i) {
     // clang-format off
     Eigen::Matrix<Real, 3, 6> Bm;
     Bm << dNm(0, i), 0,         0, 0, 0, 0,
           0,         dNm(1, i), 0, 0, 0, 0,
           dNm(1, i), dNm(0, i), 0, 0, 0, 0;
     Eigen::Matrix<Real, 3, 6> Bf;
     Bf << 0, 0, dNx1(0, i),              -dNx3(0, i),              dNx2(0, i),              0,
           0, 0, dNy1(1, i),              -dNy3(1, i),              dNy2(1, i),              0,
           0, 0, dNx1(1, i) + dNy1(0, i), -dNx3(1, i) - dNy3(0, i), dNx2(1, i) + dNy2(0, i), 0;
     // clang-format on
     B.block(3, 6, 0, i * 6) = Bm;
     B.block(3, 6, 3, i * 6) = Bf;
   }
 }
 
 } // namespace akantu
 
 #endif /* AKANTU_ELEMENT_CLASS_KIRCHHOFF_SHELL_INLINE_IMPL_HH_ */
diff --git a/src/fe_engine/shape_structural_inline_impl.hh b/src/fe_engine/shape_structural_inline_impl.hh
index cc7c206ca..6762ad811 100644
--- a/src/fe_engine/shape_structural_inline_impl.hh
+++ b/src/fe_engine/shape_structural_inline_impl.hh
@@ -1,515 +1,515 @@
 /**
  * @file   shape_structural_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: Wed Oct 11 2017
  * @date last modification: Mon Feb 01 2021
  *
  * @brief  ShapeStructural inline implementation
  *
  *
  * @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 "mesh_iterators.hh"
 #include "shape_structural.hh"
 /* -------------------------------------------------------------------------- */
 
 //#ifndef AKANTU_SHAPE_STRUCTURAL_INLINE_IMPL_HH_
 //#define AKANTU_SHAPE_STRUCTURAL_INLINE_IMPL_HH_
 
 namespace akantu {
 
 namespace {
   /// Extract nodal coordinates per elements
   template <ElementType type>
   std::unique_ptr<Array<Real>> getNodesPerElement(const Mesh & mesh,
                                                   const Array<Real> & nodes,
                                                   GhostType ghost_type) {
     const auto dim = ElementClass<type>::getSpatialDimension();
     const auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
     auto nodes_per_element =
         std::make_unique<Array<Real>>(0, dim * nb_nodes_per_element);
     FEEngine::extractNodalToElementField(mesh, nodes, *nodes_per_element, type,
                                          ghost_type);
     return nodes_per_element;
   }
 } // namespace
 
 template <ElementKind kind>
 inline void ShapeStructural<kind>::initShapeFunctions(
     const Array<Real> & /* unused */, const Matrix<Real> & /* unused */,
     ElementType /* unused */, GhostType /* unused */) {
   AKANTU_TO_IMPLEMENT();
 }
 
 template <>
 inline void ShapeStructural<_ek_structural>::initShapeFunctions(
     const Array<Real> & nodes, const Matrix<Real> & integration_points,
     ElementType type, GhostType ghost_type) {
   tuple_dispatch<ElementTypes_t<_ek_structural>>(
       [&](auto && enum_type) {
         constexpr ElementType type = std::decay_t<decltype(enum_type)>::value;
         setIntegrationPointsByType<type>(integration_points, ghost_type);
         precomputeRotationMatrices<type>(nodes, ghost_type);
         precomputeShapesOnIntegrationPoints<type>(nodes, ghost_type);
         precomputeShapeDerivativesOnIntegrationPoints<type>(nodes, ghost_type);
       },
       type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeStructural<kind>::computeShapesOnIntegrationPointsInternal(
     const Array<Real> & nodes, const Matrix<Real> & integration_points,
     Array<Real> & shapes, GhostType ghost_type,
     const Array<Idx> & filter_elements, bool mass) const {
 
   auto nb_points = integration_points.cols();
   auto nb_element = mesh.getConnectivity(type, ghost_type).size();
   auto nb_nodes_per_element = ElementClass<type>::getNbNodesPerElement();
 
   shapes.resize(nb_element * nb_points);
 
   auto nb_dofs = ElementClass<type>::getNbDegreeOfFreedom();
   auto nb_rows = nb_dofs;
   if (mass) {
     nb_rows = ElementClass<type>::getNbStressComponents();
   }
 
 #if !defined(AKANTU_NDEBUG)
   UInt size_of_shapes = nb_rows * nb_dofs * nb_nodes_per_element;
   AKANTU_DEBUG_ASSERT(shapes.getNbComponent() == size_of_shapes,
                       "The shapes array does not have the correct "
                           << "number of component");
 #endif
 
   auto shapes_it =
       make_view(shapes, nb_rows,
                 ElementClass<type>::getNbNodesPerInterpolationElement() *
                     nb_dofs,
                 nb_points)
           .begin();
 
   auto shapes_begin = shapes_it;
   if (filter_elements != empty_filter) {
     nb_element = filter_elements.size();
   }
 
   auto nodes_per_element = getNodesPerElement<type>(mesh, nodes, ghost_type);
   auto nodes_it = nodes_per_element->begin(mesh.getSpatialDimension(),
                                            Mesh::getNbNodesPerElement(type));
   auto nodes_begin = nodes_it;
   auto rot_matrix_it =
       make_view(rotation_matrices(type, ghost_type), nb_dofs, nb_dofs).begin();
   auto rot_matrix_begin = rot_matrix_it;
 
   for (Int elem = 0; elem < nb_element; ++elem) {
     if (filter_elements != empty_filter) {
       shapes_it = shapes_begin + filter_elements(elem);
       nodes_it = nodes_begin + filter_elements(elem);
       rot_matrix_it = rot_matrix_begin + filter_elements(elem);
     }
 
     Tensor3<Real> N = *shapes_it;
     auto & real_coord = *nodes_it;
 
     auto & RDOFs = *rot_matrix_it;
 
     Matrix<Real> T(N.size(1), N.size(1));
     T.zero();
 
     for (Int i = 0; i < nb_nodes_per_element; ++i) {
       T.block(i * RDOFs.rows(), i * RDOFs.cols(), RDOFs.rows(), RDOFs.cols()) =
           RDOFs;
     }
 
     if (not mass) {
       ElementClass<type>::computeShapes(integration_points, real_coord, T, N);
     } else {
       ElementClass<type>::computeShapesMass(integration_points, real_coord, T,
                                             N);
     }
     if (filter_elements == empty_filter) {
       ++shapes_it;
       ++nodes_it;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeStructural<kind>::precomputeRotationMatrices(
     const Array<Real> & nodes, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   const auto spatial_dimension = mesh.getSpatialDimension();
   const auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   const auto nb_element = mesh.getNbElement(type, ghost_type);
   const auto nb_dof = ElementClass<type>::getNbDegreeOfFreedom();
 
   if (not this->rotation_matrices.exists(type, ghost_type)) {
     this->rotation_matrices.alloc(0, nb_dof * nb_dof, type, ghost_type);
   }
 
   auto & rot_matrices = this->rotation_matrices(type, ghost_type);
   rot_matrices.resize(nb_element);
 
   Array<Real> x_el(0, spatial_dimension * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, nodes, x_el, type, ghost_type);
 
   bool has_extra_normal = mesh.hasData<Real>("extra_normal", type, ghost_type);
   Array<Real>::const_vector_iterator extra_normal;
   if (has_extra_normal) {
     extra_normal = mesh.getData<Real>("extra_normal", type, ghost_type)
                        .begin(spatial_dimension);
   }
 
   for (auto && tuple :
        zip(make_view(x_el, spatial_dimension, nb_nodes_per_element),
            make_view(rot_matrices, nb_dof, nb_dof))) {
     // compute shape derivatives
     auto & X = std::get<0>(tuple);
     auto & R = std::get<1>(tuple);
 
     if (has_extra_normal) {
       ElementClass<type>::computeRotationMatrix(R, X, *extra_normal);
       ++extra_normal;
     } else {
       ElementClass<type>::computeRotationMatrix(
           R, X, Vector<Real>(spatial_dimension));
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <ElementKind kind>
 template <ElementType type>
 void ShapeStructural<kind>::precomputeShapesOnIntegrationPoints(
     const Array<Real> & nodes, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   const auto & natural_coords = integration_points(type, ghost_type);
   auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   auto nb_points = integration_points(type, ghost_type).cols();
   auto nb_element = mesh.getNbElement(type, ghost_type);
   auto nb_dof = ElementClass<type>::getNbDegreeOfFreedom();
   const auto dim = ElementClass<type>::getSpatialDimension();
   const auto spatial_dimension = mesh.getSpatialDimension();
   const auto natural_spatial_dimension =
       ElementClass<type>::getNaturalSpaceDimension();
 
   auto itp_type = FEEngine::getInterpolationType(type);
   if (not shapes.exists(itp_type, ghost_type)) {
     auto size_of_shapes = this->getShapeSize(type);
     this->shapes.alloc(0, size_of_shapes, itp_type, ghost_type);
   }
 
   auto & rot_matrices = this->rotation_matrices(type, ghost_type);
   auto & shapes_ = this->shapes(itp_type, ghost_type);
   shapes_.resize(nb_element * nb_points);
 
   auto nodes_per_element = getNodesPerElement<type>(mesh, nodes, ghost_type);
 
   for (auto && tuple :
        zip(make_view(shapes_, nb_dof, nb_dof * nb_nodes_per_element, nb_points),
            make_view(*nodes_per_element, dim, nb_nodes_per_element),
            make_view(rot_matrices, nb_dof, nb_dof))) {
     auto && N = std::get<0>(tuple);
     auto && X = std::get<1>(tuple);
     auto && RDOFs = std::get<2>(tuple);
 
     Matrix<Real> T(N.size(1), N.size(1));
     T.zero();
 
     for (Idx i = 0; i < nb_nodes_per_element; ++i) {
       T.block(i * RDOFs.rows(), i * RDOFs.cols(), RDOFs.rows(), RDOFs.cols()) =
           RDOFs;
     }
 
     auto R = RDOFs.block(0, 0, spatial_dimension, spatial_dimension);
     // Rotate to local basis
     auto x =
         (R * X).block(0, 0, natural_spatial_dimension, nb_nodes_per_element);
 
     ElementClass<type>::computeShapes(natural_coords, x, T, N);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeStructural<kind>::precomputeShapeDerivativesOnIntegrationPoints(
     const Array<Real> & nodes, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   const auto & natural_coords = integration_points(type, ghost_type);
   const auto spatial_dimension = mesh.getSpatialDimension();
   const auto natural_spatial_dimension =
       ElementClass<type>::getNaturalSpaceDimension();
   const auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   const auto nb_points = natural_coords.cols();
   const auto nb_dof = ElementClass<type>::getNbDegreeOfFreedom();
   const auto nb_element = mesh.getNbElement(type, ghost_type);
   const auto nb_stress_components = ElementClass<type>::getNbStressComponents();
 
   auto itp_type = FEEngine::getInterpolationType(type);
   if (not this->shapes_derivatives.exists(itp_type, ghost_type)) {
     auto size_of_shapesd = this->getShapeDerivativesSize(type);
     this->shapes_derivatives.alloc(0, size_of_shapesd, itp_type, ghost_type);
   }
 
   auto & rot_matrices = this->rotation_matrices(type, ghost_type);
 
   Array<Real> x_el(0, spatial_dimension * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, nodes, x_el, type, ghost_type);
 
   auto & shapesd = this->shapes_derivatives(itp_type, ghost_type);
   shapesd.resize(nb_element * nb_points);
 
   for (auto && tuple :
        zip(make_view(x_el, spatial_dimension, nb_nodes_per_element),
            make_view(shapesd, nb_stress_components,
                      nb_nodes_per_element * nb_dof, nb_points),
            make_view(rot_matrices, nb_dof, nb_dof))) {
     // compute shape derivatives
     auto & X = std::get<0>(tuple);
     auto & B = std::get<1>(tuple);
     auto & RDOFs = std::get<2>(tuple);
 
     Tensor3<Real> dnds(natural_spatial_dimension,
                        ElementClass<type>::interpolation_property::dnds_columns,
                        B.size(2));
     ElementClass<type>::computeDNDS(natural_coords, X, dnds);
 
     Tensor3<Real> J(natural_spatial_dimension, natural_spatial_dimension,
                     natural_coords.cols());
 
     // Computing the coordinates of the element in the natural space
     auto && R = RDOFs.block(0, 0, spatial_dimension, spatial_dimension);
     Matrix<Real> T(B.size(1), B.size(1));
     T.fill(0);
 
     for (Int i = 0; i < nb_nodes_per_element; ++i) {
       T.block(i * RDOFs.rows(), i * RDOFs.rows(), RDOFs.rows(), RDOFs.cols()) =
           RDOFs;
     }
 
     // Rotate to local basis
     auto x =
         (R * X).block(0, 0, natural_spatial_dimension, nb_nodes_per_element);
 
     ElementClass<type>::computeJMat(natural_coords, x, J);
     ElementClass<type>::computeShapeDerivatives(J, dnds, T, B);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeStructural<kind>::interpolateOnIntegrationPoints(
     const Array<Real> & in_u, Array<Real> & out_uq, Int nb_dof,
     GhostType ghost_type, const Array<Idx> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(out_uq.getNbComponent() == nb_dof,
                       "The output array shape is not correct");
 
   auto itp_type = FEEngine::getInterpolationType(type);
   const auto & shapes_ = shapes(itp_type, ghost_type);
 
   auto nb_element = mesh.getNbElement(type, ghost_type);
   auto nb_nodes_per_element = ElementClass<type>::getNbNodesPerElement();
   auto nb_quad_points_per_element = integration_points(type, ghost_type).cols();
 
   Array<Real> u_el(0, nb_nodes_per_element * nb_dof);
   FEEngine::extractNodalToElementField(mesh, in_u, u_el, type, ghost_type,
                                        filter_elements);
 
   auto nb_quad_points = nb_quad_points_per_element * u_el.size();
   out_uq.resize(nb_quad_points);
 
   auto out_it =
       make_view(out_uq, nb_dof, 1, nb_quad_points_per_element).begin();
   auto shapes_it = make_view(shapes_, nb_dof, nb_dof * nb_nodes_per_element,
                              nb_quad_points_per_element)
                        .begin();
   auto u_it = make_view(u_el, nb_dof * nb_nodes_per_element, 1,
                         nb_quad_points_per_element)
                   .begin();
 
   for_each_element(nb_element, filter_elements, [&](auto && el) {
     auto & uq = *out_it;
     const auto & u = *u_it;
     auto && N = shapes_it[el];
 
     for (auto && q : arange(uq.size(2))) {
       uq(q) = N(q) * u(q);
     }
 
     ++out_it;
     ++u_it;
   });
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeStructural<kind>::gradientOnIntegrationPoints(
     const Array<Real> & in_u, Array<Real> & out_nablauq, Int nb_dof,
     GhostType ghost_type, const Array<Idx> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   auto itp_type = FEEngine::getInterpolationType(type);
   const auto & shapesd = shapes_derivatives(itp_type, ghost_type);
 
   auto nb_element = mesh.getNbElement(type, ghost_type);
   auto element_dimension = ElementClass<type>::getSpatialDimension();
   auto nb_quad_points_per_element = integration_points(type, ghost_type).cols();
   auto nb_nodes_per_element = ElementClass<type>::getNbNodesPerElement();
 
   Array<Real> u_el(0, nb_nodes_per_element * nb_dof);
   FEEngine::extractNodalToElementField(mesh, in_u, u_el, type, ghost_type,
                                        filter_elements);
 
   auto nb_quad_points = nb_quad_points_per_element * u_el.size();
   out_nablauq.resize(nb_quad_points);
 
   auto out_it =
       make_view(out_nablauq, element_dimension, 1, nb_quad_points_per_element)
           .begin();
   auto shapesd_it =
       make_view(shapesd, element_dimension, nb_dof * nb_nodes_per_element,
                 nb_quad_points_per_element)
           .begin();
   auto u_it = make_view(u_el, nb_dof * nb_nodes_per_element, 1,
                         nb_quad_points_per_element)
                   .begin();
 
   for_each_element(nb_element, filter_elements, [&](auto && el) {
     auto & nablau = *out_it;
     const auto & u = *u_it;
     auto B = shapesd_it[el];
 
     for (auto && q : arange(nablau.size(2))) {
       nablau(q) = B(q) * u(q);
     }
 
     ++out_it;
     ++u_it;
   });
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <ElementType type>
 void ShapeStructural<_ek_structural>::computeBtD(
     const Array<Real> & Ds, Array<Real> & BtDs, GhostType ghost_type,
     const Array<Idx> & filter_elements) const {
   auto itp_type = ElementClassProperty<type>::interpolation_type;
 
   auto nb_stress = ElementClass<type>::getNbStressComponents();
   auto nb_dof_per_element = ElementClass<type>::getNbDegreeOfFreedom() *
                             mesh.getNbNodesPerElement(type);
 
   const auto & shapes_derivatives =
       this->shapes_derivatives(itp_type, ghost_type);
 
   Array<Real> shapes_derivatives_filtered(0,
                                           shapes_derivatives.getNbComponent());
   auto && view = make_view(shapes_derivatives, nb_stress, nb_dof_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, nb_stress, nb_dof_per_element);
     B_it = view.begin();
     B_end = view.end();
   }
 
   for (auto && values : zip(range(B_it, B_end), make_view(Ds, nb_stress),
                             make_view(BtDs, BtDs.getNbComponent()))) {
     const auto & B = std::get<0>(values);
     const auto & D = std::get<1>(values);
     auto & Bt_D = std::get<2>(values);
     Bt_D = B.transpose() * D;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <ElementType type>
 void ShapeStructural<_ek_structural>::computeNtb(
     const Array<Real> & bs, Array<Real> & Ntbs, GhostType ghost_type,
     const Array<Idx> & filter_elements) const {
-  auto itp_type = ElementClassProperty<type>::interpolation_type;
+  constexpr auto itp_type = ElementClassProperty<type>::interpolation_type;
+  constexpr auto nb_dof = ElementClass<type>::getNbDegreeOfFreedom();
 
-  auto nb_dof = ElementClass<type>::getNbDegreeOfFreedom();
   auto nb_nodes_per_element = mesh.getNbNodesPerElement(type);
 
   const auto & shapes = this->shapes(itp_type, ghost_type);
 
   Array<Real> shapes_filtered(0, shapes.getNbComponent());
   auto && view = make_view(shapes, nb_dof, nb_dof * nb_nodes_per_element);
   auto N_it = view.begin();
   auto N_end = view.end();
 
   if (filter_elements != empty_filter) {
     FEEngine::filterElementalData(this->mesh, shapes, shapes_filtered, type,
                                   ghost_type, filter_elements);
     auto && view =
         make_view(shapes_filtered, nb_dof, nb_dof * nb_nodes_per_element);
     N_it = view.begin();
     N_end = view.end();
   }
 
   for (auto && values : zip(range(N_it, N_end), make_view(bs, nb_dof),
                             make_view(Ntbs, nb_dof * nb_nodes_per_element))) {
     const auto & N = std::get<0>(values);
     const auto & b = std::get<1>(values);
     auto & Nt_b = std::get<2>(values);
     Nt_b = N.transpose() * b;
   }
 }
 
 } // namespace akantu
 
 //#endif /* AKANTU_SHAPE_STRUCTURAL_INLINE_IMPL_HH_ */
diff --git a/src/io/mesh_io/mesh_io_diana.cc b/src/io/mesh_io/mesh_io_diana.cc
index 994637d15..c53730f1f 100644
--- a/src/io/mesh_io/mesh_io_diana.cc
+++ b/src/io/mesh_io/mesh_io_diana.cc
@@ -1,606 +1,606 @@
 /**
  * @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) {
           auto first = *it;
           ++it;
           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) {
       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 {
       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, 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);
+    Vector<Idx> local_connect(node_per_element);
 
     // used if element is written on two lines
-    UInt j_last = 0;
+    Int j_last = 0;
 
-    for (UInt j = 0; j < node_per_element; ++j) {
-      UInt node_index;
+    for (Int j = 0; j < node_per_element; ++j) {
+      Int 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 (auto j = (j_last + 1); j < node_per_element; ++j) {
 
-        UInt node_index;
+        Int 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) {
   std::string line;
 
   for (auto type : mesh.elementTypes()) {
     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<Int> temp_id(0, 2);
     Int mat;
     while (true) {
       std::stringstream sstr_intervals_elements(line);
       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.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;
         }
         auto elem = element.element;
         auto type = element.type;
         auto & data = mesh.getDataPointer<Int>("material", type, _not_ghost);
         data(elem) = mat;
       }
     }
 
     my_getline(infile, line);
   }
 
   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;
 
   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;
 
       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 b34090f7c..30c577c07 100644
--- a/src/io/mesh_io/mesh_io_msh.cc
+++ b/src/io/mesh_io/mesh_io_msh.cc
@@ -1,1124 +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;
+    Int 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;
+        Int nb_tags;
         sstr_elem >> nb_tags;
-        for (UInt j = 0; j < nb_tags; ++j) {
+        for (Int 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);
+      Vector<Idx> local_connect(node_per_element);
       for (Int j = 0; j < node_per_element; ++j) {
-        UInt node_index;
+        Int 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 &) {
     Int nb_periodic_entities;
     file.read_line(nb_periodic_entities);
 
     file.mesh_accessor.getNodesFlags().resize(file.mesh.getNbNodes(),
                                               NodeFlag::_normal);
 
     for (Int p = 0; p < nb_periodic_entities; ++p) {
       // dimension slave-tag master-tag
       Int dimension;
       file.read_line(dimension);
 
       // transformation
       file.get_line();
 
       // nb nodes
       Int nb_nodes;
       file.read_line(nb_nodes);
 
       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) {
           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());
+      Vector<Idx> local_connect(connectivity.getNbComponent());
       auto && read_order = this->_read_order[akantu_type];
 
       auto & data0 =
-          file.mesh_accessor.template getData<UInt>("tag_0", akantu_type);
+          file.mesh_accessor.template getData<Idx>("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;
+        std::size_t elem_tag;
         sstr_elem >> elem_tag;
         for (auto && c : arange(connectivity.getNbComponent())) {
-          size_t node_tag;
+          std::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 (Int i = 0; i < nodes.size(); ++i) {
     auto offset = i * nodes.getNbComponent();
     outfile << i + 1;
     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 auto & connectivity = mesh.getConnectivity(type, _not_ghost);
     nb_elements += connectivity.size();
   }
   outfile << nb_elements << "\n";
 
   std::map<Element, size_t> element_to_msh_element;
 
   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
diff --git a/src/mesh/mesh.hh b/src/mesh/mesh.hh
index 74af542fb..2427a59b3 100644
--- a/src/mesh/mesh.hh
+++ b/src/mesh/mesh.hh
@@ -1,727 +1,733 @@
 /**
  * @file   mesh.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Nov 12 2020
  *
  * @brief  the class representing the 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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef AKANTU_MESH_HH_
 #define AKANTU_MESH_HH_
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "aka_bbox.hh"
 #include "aka_event_handler_manager.hh"
 #include "communicator.hh"
 #include "dumpable.hh"
 #include "element.hh"
 #include "element_class.hh"
 #include "element_type_map.hh"
 #include "group_manager.hh"
 #include "mesh_data.hh"
 #include "mesh_events.hh"
 /* -------------------------------------------------------------------------- */
 #include <functional>
 #include <set>
 #include <unordered_map>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 class ElementSynchronizer;
 class NodeSynchronizer;
 class PeriodicNodeSynchronizer;
 class MeshGlobalDataUpdater;
 } // namespace akantu
 
 namespace akantu {
 
 namespace {
   DECLARE_NAMED_ARGUMENT(communicator);
   DECLARE_NAMED_ARGUMENT(edge_weight_function);
   DECLARE_NAMED_ARGUMENT(vertex_weight_function);
 } // namespace
 
 /* -------------------------------------------------------------------------- */
 /* Mesh                                                                       */
 /* -------------------------------------------------------------------------- */
 
 /**
  * @class  Mesh mesh.hh
  *
  * This class contaisn the coordinates of the nodes in the Mesh.nodes
  * akant::Array, and the connectivity. The connectivity are stored in by element
  * types.
  *
  * In order to loop on all element you have to loop on all types like this :
  * @code{.cpp}
  for(auto & type : mesh.elementTypes()) {
    UInt nb_element  = mesh.getNbElement(type);
    const Array<UInt> & conn = mesh.getConnectivity(type);
    for(UInt e = 0; e < nb_element; ++e) {
      ...
    }
  }
 
  or
 
  for_each_element(mesh, [](Element & element) {
     std::cout << element << std::endl
   });
  @endcode
 */
 class Mesh : public EventHandlerManager<MeshEventHandler>,
              public GroupManager,
              public MeshData,
              public Dumpable {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 private:
   /// default constructor used for chaining, the last parameter is just to
   /// differentiate constructors
   Mesh(Int spatial_dimension, const ID & id, Communicator & communicator);
 
 public:
   /// constructor that create nodes coordinates array
   Mesh(Int spatial_dimension, const ID & id = "mesh");
 
   /// mesh not distributed and not using the default communicator
   Mesh(Int spatial_dimension, Communicator & communicator,
        const ID & id = "mesh");
 
   /**
    * constructor that use an existing nodes coordinates
    * array, by getting the vector of coordinates
    */
   Mesh(Int spatial_dimension, const std::shared_ptr<Array<Real>> & nodes,
        const ID & id = "mesh");
 
   ~Mesh() override;
 
   /// read the mesh from a file
   void read(const std::string & filename,
             const MeshIOType & mesh_io_type = _miot_auto);
   /// write the mesh to a file
   void write(const std::string & filename,
              const MeshIOType & mesh_io_type = _miot_auto);
 
 protected:
   void makeReady();
 
 private:
   /// initialize the connectivity to NULL and other stuff
   void init();
 
   /// function that computes the bounding box (fills xmin, xmax)
   void computeBoundingBox();
 
   /* ------------------------------------------------------------------------ */
   /* Distributed memory methods and accessors                                 */
   /* ------------------------------------------------------------------------ */
 public:
 protected:
   /// patitionate the mesh among the processors involved in their computation
   virtual void distributeImpl(
       Communicator & communicator,
       const std::function<Int(const Element &, const Element &)> &
           edge_weight_function,
       const std::function<Int(const Element &)> & vertex_weight_function);
 
 public:
   /// with the arguments to pass to the partitionner
   template <typename... pack>
   std::enable_if_t<are_named_argument<pack...>::value>
   distribute(pack &&... _pack) {
     distributeImpl(
         OPTIONAL_NAMED_ARG(communicator, Communicator::getStaticCommunicator()),
         OPTIONAL_NAMED_ARG(edge_weight_function,
                            [](auto &&, auto &&) { return 1; }),
         OPTIONAL_NAMED_ARG(vertex_weight_function, [](auto &&) { return 1; }));
   }
 
   /// defines is the mesh is distributed or not
   inline bool isDistributed() const { return this->is_distributed; }
 
   /* ------------------------------------------------------------------------ */
   /* Periodicity methods and accessors                                        */
   /* ------------------------------------------------------------------------ */
 public:
   /// set the periodicity in a given direction
   void makePeriodic(const SpatialDirection & direction);
   void makePeriodic(const SpatialDirection & direction, const ID & list_1,
                     const ID & list_2);
 
 protected:
   void makePeriodic(const SpatialDirection & direction,
                     const Array<Idx> & list_1, const Array<Idx> & list_2);
 
   /// Removes the face that the mesh is periodic
   void wipePeriodicInfo();
 
   inline void addPeriodicSlave(Idx slave, Idx master);
 
   template <typename T>
   void synchronizePeriodicSlaveDataWithMaster(Array<T> & data);
 
   // update the periodic synchronizer (creates it if it does not exists)
   void updatePeriodicSynchronizer();
 
 public:
   /// defines if the mesh is periodic or not
   inline bool isPeriodic() const { return this->is_periodic; }
 
   inline bool isPeriodic(const SpatialDirection & /*direction*/) const {
     return this->is_periodic;
   }
 
   class PeriodicSlaves;
 
   /// get the master node for a given slave nodes, except if node not a slave
   inline Idx getPeriodicMaster(Idx slave) const;
 
   /// get an iterable list of slaves for a given master node
   inline decltype(auto) getPeriodicSlaves(Idx master) const;
 
   /* ------------------------------------------------------------------------ */
   /* General Methods                                                          */
   /* ------------------------------------------------------------------------ */
 public:
   /// function to print the containt of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
   /// extract coordinates of nodes from an element
   template <typename T>
   inline void extractNodalValuesFromElement(const Array<T> & nodal_values,
                                             T * elemental_values,
                                             Idx * connectivity, Int n_nodes,
                                             Int nb_degree_of_freedom) const;
 
   // /// extract coordinates of nodes from a reversed element
   // inline void extractNodalCoordinatesFromPBCElement(Real * local_coords,
   //                                                   UInt * connectivity,
   //                                                   UInt n_nodes);
 
   /// add a Array of connectivity for the given ElementType and GhostType .
   inline void addConnectivityType(ElementType type,
                                   GhostType ghost_type = _not_ghost);
 
   /* ------------------------------------------------------------------------ */
   template <class Event> inline void sendEvent(Event & event) {
     //    if(event.getList().size() != 0)
     EventHandlerManager<MeshEventHandler>::sendEvent<Event>(event);
   }
 
   /// prepare the  event to remove the elements listed
   void eraseElements(const Array<Element> & elements);
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void removeNodesFromArray(Array<T> & vect,
                                    const Array<Int> & new_numbering);
 
   /// init facets' mesh
   Mesh & initMeshFacets(const ID & id = "mesh_facets");
 
   /// define parent mesh
   void defineMeshParent(const Mesh & mesh);
 
   /// get global connectivity array
   void getGlobalConnectivity(ElementTypeMapArray<Int> & global_connectivity);
 
 public:
   void getAssociatedElements(const Array<Int> & node_list,
                              Array<Element> & elements);
 
   void getAssociatedElements(const UInt & node,
                              Array<Element> & elements) const;
 
 public:
   /// fills the nodes_to_elements for given dimension elements
   void fillNodesToElements(UInt dimension = _all_dimensions);
 
 private:
   /// update the global ids, nodes type, ...
   std::tuple<Int, Int> updateGlobalData(NewNodesEvent & nodes_event,
                                         NewElementsEvent & elements_event);
 
   void registerGlobalDataUpdater(
       std::unique_ptr<MeshGlobalDataUpdater> && global_data_updater);
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the id of the mesh
   AKANTU_GET_MACRO(ID, id, const ID &);
 
   /// get the spatial dimension of the mesh = number of component of the
   /// coordinates
   AKANTU_GET_MACRO(SpatialDimension, spatial_dimension, Int);
 
   /// get the nodes Array aka coordinates
   AKANTU_GET_MACRO(Nodes, *nodes, const Array<Real> &);
   AKANTU_GET_MACRO_NOT_CONST(Nodes, *nodes, Array<Real> &);
 
   /// get the number of nodes
   auto getNbNodes() const { return nodes->size(); }
 
   /// get the Array of global ids of the nodes (only used in parallel)
   AKANTU_GET_MACRO_AUTO(GlobalNodesIds, *nodes_global_ids);
   // AKANTU_GET_MACRO_NOT_CONST(GlobalNodesIds, *nodes_global_ids, Array<UInt>
   // &);
 
   /// get the global id of a node
   inline auto getNodeGlobalId(Idx local_id) const;
 
   /// get the global id of a node
   inline auto getNodeLocalId(Idx global_id) const;
 
   /// get the global number of nodes
   inline auto getNbGlobalNodes() const;
 
   /// get the nodes type Array
   AKANTU_GET_MACRO(NodesFlags, *nodes_flags, const Array<NodeFlag> &);
 
 protected:
   AKANTU_GET_MACRO_NOT_CONST(NodesFlags, *nodes_flags, Array<NodeFlag> &);
 
 public:
   inline NodeFlag getNodeFlag(Idx local_id) const;
   inline auto getNodePrank(Idx local_id) const;
 
   /// say if a node is a pure ghost node
   inline bool isPureGhostNode(Idx n) const;
 
   /// say if a node is pur local or master node
   inline bool isLocalOrMasterNode(Idx n) const;
 
   inline bool isLocalNode(Idx n) const;
   inline bool isMasterNode(Idx n) const;
   inline bool isSlaveNode(Idx n) const;
 
   inline bool isPeriodicSlave(Idx n) const;
   inline bool isPeriodicMaster(Idx n) const;
 
   const Vector<Real> & getLowerBounds() const { return bbox.getLowerBounds(); }
   const Vector<Real> & getUpperBounds() const { return bbox.getUpperBounds(); }
   AKANTU_GET_MACRO(BBox, bbox, const BBox &);
 
   const Vector<Real> & getLocalLowerBounds() const {
     return bbox_local.getLowerBounds();
   }
   const Vector<Real> & getLocalUpperBounds() const {
     return bbox_local.getUpperBounds();
   }
   AKANTU_GET_MACRO(LocalBBox, bbox_local, const BBox &);
 
   /// get the connectivity Array for a given type
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Connectivity, connectivities, Idx);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(Connectivity, connectivities, Idx);
   AKANTU_GET_MACRO(Connectivities, connectivities,
                    const ElementTypeMapArray<Idx> &);
 
   /// get the number of element of a type in the mesh
   inline auto getNbElement(ElementType type,
                            GhostType ghost_type = _not_ghost) const;
 
   /// get the number of element for a given ghost_type and a given dimension
   inline auto getNbElement(const Int spatial_dimension = _all_dimensions,
                            GhostType ghost_type = _not_ghost,
                            ElementKind kind = _ek_not_defined) const;
 
   /// compute the barycenter of a given element
   template <class D, std::enable_if_t<aka::is_vector<D>::value> * = nullptr>
   inline void getBarycenter(const Element & element,
                             Eigen::MatrixBase<D> & barycenter) const;
 
   void getBarycenters(Array<Real> & barycenter, ElementType type,
                       GhostType ghost_type) const;
 
   /// get the element connected to a subelement (element of lower dimension)
   decltype(auto) getElementToSubelement() const;
 
   /// get the element connected to a subelement
   const auto & getElementToSubelement(ElementType el_type,
                                       GhostType ghost_type = _not_ghost) const;
 
   /// get the elements connected to a subelement
   decltype(auto) getElementToSubelement(const Element & element) const;
 
   /// get the subelement (element of lower dimension) connected to a element
   decltype(auto) getSubelementToElement() const;
 
   /// get the subelement connected to an element
   const auto & getSubelementToElement(ElementType el_type,
                                       GhostType ghost_type = _not_ghost) const;
 
   /// get the subelement (element of lower dimension) connected to a element
   decltype(auto) getSubelementToElement(const Element & element) const;
 
   /// get connectivity of a given element
   inline decltype(auto) getConnectivity(const Element & element) const;
   inline decltype(auto)
   getConnectivityWithPeriodicity(const Element & element) const;
 
 protected:
   /// get the element connected to a subelement (element of lower dimension)
   auto & getElementToSubelementNC();
   auto & getSubelementToElementNC();
   inline auto & getElementToSubelementNC(const Element & element);
   inline decltype(auto) getSubelementToElementNC(const Element & element) const;
   /// get the element connected to a subelement
   auto & getElementToSubelementNC(ElementType el_type,
                                   GhostType ghost_type = _not_ghost);
   /// get the subelement connected to an element
   auto & getSubelementToElementNC(ElementType el_type,
                                   GhostType ghost_type = _not_ghost);
 
   inline decltype(auto) getConnectivityNC(const Element & element);
 
 public:
   /// get a name field associated to the mesh
   template <typename T>
   inline decltype(auto) getData(const ID & data_name, ElementType el_type,
                                 GhostType ghost_type = _not_ghost) const;
 
   /// get a name field associated to the mesh
   template <typename T>
   inline decltype(auto) getData(const ID & data_name, ElementType el_type,
                                 GhostType ghost_type = _not_ghost);
 
   /// get a name field associated to the mesh
   template <typename T>
   inline decltype(auto) getData(const ID & data_name) const;
 
   /// get a name field associated to the mesh
   template <typename T> inline decltype(auto) getData(const ID & data_name);
 
   template <typename T>
   auto getNbDataPerElem(ElementTypeMapArray<T> & array) -> ElementTypeMap<Int>;
 
   template <typename T>
   std::shared_ptr<dumpers::Field>
   createFieldFromAttachedData(const std::string & field_id,
                               const std::string & group_name,
                               ElementKind element_kind);
 
   /// templated getter returning the pointer to data in MeshData (modifiable)
   template <typename T>
   inline decltype(auto)
   getDataPointer(const std::string & data_name, ElementType el_type,
                  GhostType ghost_type = _not_ghost, Int nb_component = 1,
                  bool size_to_nb_element = true,
                  bool resize_with_parent = false);
 
   template <typename T>
   inline decltype(auto)
   getDataPointer(const ID & data_name, ElementType el_type,
                  GhostType ghost_type, Int nb_component,
                  bool size_to_nb_element, bool resize_with_parent,
                  const T & defaul_);
 
   /// Facets mesh accessor
   inline auto getMeshFacets() const -> const Mesh &;
   inline auto getMeshFacets() -> Mesh &;
 
   inline auto hasMeshFacets() const { return mesh_facets != nullptr; }
 
   /// Parent mesh accessor
   inline auto getMeshParent() const -> const Mesh &;
 
   inline auto isMeshFacets() const { return this->is_mesh_facets; }
 
   /// return the dumper from a group and and a dumper name
   auto getGroupDumper(const std::string & dumper_name,
                       const std::string & group_name) -> DumperIOHelper &;
 
   /* ------------------------------------------------------------------------ */
   /* Wrappers on ElementClass functions                                       */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the number of nodes per element for a given element type
-  static inline constexpr auto getNbNodesPerElement(ElementType type);
+  static inline constexpr auto getNbNodesPerElement(ElementType type) -> Int;
 
   /// get the number of nodes per element for a given element type considered as
   /// a first order element
-  static inline constexpr auto getP1ElementType(ElementType type);
+  static inline constexpr auto getP1ElementType(ElementType type)
+      -> ElementType;
 
   /// get the kind of the element type
-  static inline constexpr auto getKind(ElementType type);
+  static inline constexpr auto getKind(ElementType type) -> ElementKind;
 
   /// get spatial dimension of a type of element
-  static inline constexpr auto getSpatialDimension(ElementType type);
+  static inline constexpr auto getSpatialDimension(ElementType type) -> Int;
 
   /// get the natural space dimension of a type of element
-  static inline constexpr auto getNaturalSpaceDimension(ElementType type);
+  static inline constexpr auto getNaturalSpaceDimension(ElementType type)
+      -> Int;
 
   /// get number of facets of a given element type
-  static inline constexpr auto getNbFacetsPerElement(ElementType type);
+  static inline constexpr auto getNbFacetsPerElement(ElementType type) -> Int;
 
   /// get number of facets of a given element type
-  static inline constexpr auto getNbFacetsPerElement(ElementType type, Idx t);
+  static inline constexpr auto getNbFacetsPerElement(ElementType type, Idx t)
+      -> Int;
 
   /// get local connectivity of a facet for a given facet type
   static inline decltype(auto) getFacetLocalConnectivity(ElementType type,
                                                          Idx t = 0);
 
   /// get connectivity of facets for a given element
-  inline decltype(auto) getFacetConnectivity(const Element & element,
-                                             Idx t = 0) const;
+  inline auto getFacetConnectivity(const Element & element, Idx t = 0) const
+      -> Matrix<Idx>;
 
   /// get the number of type of the surface element associated to a given
   /// element type
-  static inline constexpr auto getNbFacetTypes(ElementType type, Idx t = 0);
+  static inline constexpr auto getNbFacetTypes(ElementType type, Idx t = 0)
+      -> Int;
 
   /// get the type of the surface element associated to a given element
-  static inline constexpr auto getFacetType(ElementType type, Idx t = 0);
+  static inline constexpr auto getFacetType(ElementType type, Idx t = 0)
+      -> ElementType;
 
   /// get all the type of the surface element associated to a given element
   static inline decltype(auto) getAllFacetTypes(ElementType type);
 
   /// get the number of nodes in the given element list
-  static inline auto getNbNodesPerElementList(const Array<Element> & elements);
+  static inline auto getNbNodesPerElementList(const Array<Element> & elements)
+      -> Int;
 
   /* ------------------------------------------------------------------------ */
   /* Element type Iterator                                                    */
   /* ------------------------------------------------------------------------ */
 
   using type_iterator [[deprecated]] =
       ElementTypeMapArray<Idx, ElementType>::type_iterator;
   using ElementTypesIteratorHelper =
       ElementTypeMapArray<Idx, ElementType>::ElementTypesIteratorHelper;
 
   template <typename... pack>
   auto elementTypes(pack &&... _pack) const -> ElementTypesIteratorHelper;
 
   [[deprecated("Use elementTypes instead")]] inline decltype(auto)
   firstType(Int dim = _all_dimensions, GhostType ghost_type = _not_ghost,
             ElementKind kind = _ek_regular) const {
     return connectivities.elementTypes(dim, ghost_type, kind).begin();
   }
 
   [[deprecated("Use elementTypes instead")]] inline decltype(auto)
   lastType(Int dim = _all_dimensions, GhostType ghost_type = _not_ghost,
            ElementKind kind = _ek_regular) const {
     return connectivities.elementTypes(dim, ghost_type, kind).end();
   }
 
   AKANTU_GET_MACRO_DEREF_PTR(ElementSynchronizer, element_synchronizer);
   AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(ElementSynchronizer,
                                        element_synchronizer);
   AKANTU_GET_MACRO_DEREF_PTR(NodeSynchronizer, node_synchronizer);
   AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(NodeSynchronizer, node_synchronizer);
   AKANTU_GET_MACRO_DEREF_PTR(PeriodicNodeSynchronizer,
                              periodic_node_synchronizer);
   AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(PeriodicNodeSynchronizer,
                                        periodic_node_synchronizer);
 
   // AKANTU_GET_MACRO_NOT_CONST(Communicator, *communicator, StaticCommunicator
   // &);
   AKANTU_GET_MACRO_DEREF_PTR(Communicator, communicator);
   AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(Communicator, communicator);
   AKANTU_GET_MACRO_AUTO(PeriodicMasterSlaves, periodic_master_slave);
 
   /* ------------------------------------------------------------------------ */
   /* Private methods for friends                                              */
   /* ------------------------------------------------------------------------ */
 private:
   friend class MeshAccessor;
   friend class MeshUtils;
 
   AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(NodesPointer, nodes);
 
   /// get a pointer to the nodes_global_ids Array<UInt> and create it if
   /// necessary
   inline auto getNodesGlobalIdsPointer() -> Array<Idx> &;
 
   /// get a pointer to the nodes_type Array<Int> and create it if necessary
   inline auto getNodesFlagsPointer() -> Array<NodeFlag> &;
 
   /// get a pointer to the connectivity Array for the given type and create it
   /// if necessary
   inline auto getConnectivityPointer(ElementType type,
                                      GhostType ghost_type = _not_ghost)
       -> Array<Idx> &;
 
   /// get the ghost element counter
   inline auto getGhostsCounters(ElementType type, GhostType ghost_type = _ghost)
       -> Array<Idx> & {
     AKANTU_DEBUG_ASSERT(ghost_type != _not_ghost,
                         "No ghost counter for _not_ghost elements");
     return ghosts_counters(type, ghost_type);
   }
 
   /// get a pointer to the element_to_subelement Array for the given type and
   /// create it if necessary
   inline decltype(auto)
   getElementToSubelementPointer(ElementType type,
                                 GhostType ghost_type = _not_ghost);
 
   /// get a pointer to the subelement_to_element Array for the given type and
   /// create it if necessary
   inline decltype(auto)
   getSubelementToElementPointer(ElementType type,
                                 GhostType ghost_type = _not_ghost);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   ID id;
 
   /// array of the nodes coordinates
   std::shared_ptr<Array<Real>> nodes;
 
   /// global node ids
   std::shared_ptr<Array<Idx>> nodes_global_ids;
 
   /// node flags (shared/periodic/...)
   std::shared_ptr<Array<NodeFlag>> nodes_flags;
 
   /// processor handling the node when not local or master
   std::unordered_map<Idx, Int> nodes_prank;
 
   /// global number of nodes;
   Int nb_global_nodes{0};
 
   /// all class of elements present in this mesh (for heterogenous meshes)
   ElementTypeMapArray<Idx> connectivities;
 
   /// count the references on ghost elements
   ElementTypeMapArray<Idx> ghosts_counters;
 
   /// the spatial dimension of this mesh
   Idx spatial_dimension{0};
 
   /// size covered by the mesh on each direction
   Vector<Real> size;
 
   /// global bounding box
   BBox bbox;
 
   /// local bounding box
   BBox bbox_local;
 
   /// Extra data loaded from the mesh file
   // MeshData mesh_data;
 
   /// facets' mesh
   std::unique_ptr<Mesh> mesh_facets;
 
   /// parent mesh (this is set for mesh_facets meshes)
   const Mesh * mesh_parent{nullptr};
 
   /// defines if current mesh is mesh_facets or not
   bool is_mesh_facets{false};
 
   /// defines if the mesh is centralized or distributed
   bool is_distributed{false};
 
   /// defines if the mesh is periodic
   bool is_periodic{false};
 
   /// Communicator on which mesh is distributed
   Communicator * communicator;
 
   /// Element synchronizer
   std::unique_ptr<ElementSynchronizer> element_synchronizer;
 
   /// Node synchronizer
   std::unique_ptr<NodeSynchronizer> node_synchronizer;
 
   /// Node synchronizer for periodic nodes
   std::unique_ptr<PeriodicNodeSynchronizer> periodic_node_synchronizer;
 
   using NodesToElements = std::vector<std::unique_ptr<std::set<Element>>>;
 
   /// class to update global data using external knowledge
   std::unique_ptr<MeshGlobalDataUpdater> global_data_updater;
 
   /// This info is stored to simplify the dynamic changes
   NodesToElements nodes_to_elements;
 
   /// periodicity local info
   std::unordered_map<Idx, Idx> periodic_slave_master;
   std::unordered_multimap<Idx, Idx> periodic_master_slave;
 };
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream, const Mesh & _this) {
   _this.printself(stream);
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
-inline constexpr auto Mesh::getNbNodesPerElement(ElementType type) {
+inline constexpr auto Mesh::getNbNodesPerElement(ElementType type) -> Int {
   Int nb_nodes_per_element = 0;
 
 #define GET_NB_NODES_PER_ELEMENT(type)                                         \
   nb_nodes_per_element = ElementClass<type>::getNbNodesPerElement()
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH_CONSTEXPR(GET_NB_NODES_PER_ELEMENT);
 #undef GET_NB_NODES_PER_ELEMENT
   return nb_nodes_per_element;
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::getNbElement(ElementType type, GhostType ghost_type) const {
   try {
     const auto & conn = connectivities(type, ghost_type);
     return conn.size();
   } catch (...) {
     return 0;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::getNbElement(const Int spatial_dimension,
                                GhostType ghost_type, ElementKind kind) const {
   AKANTU_DEBUG_ASSERT(spatial_dimension <= 3 || spatial_dimension == Int(-1),
                       "spatial_dimension is " << spatial_dimension
                                               << " and is greater than 3 !");
   Int nb_element = 0;
 
   for (auto type : elementTypes(spatial_dimension, ghost_type, kind))
     nb_element += getNbElement(type, ghost_type);
 
   return nb_element;
 }
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 /* Inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 #include "element_type_map_tmpl.hh"
 #include "mesh_inline_impl.hh"
 
 #endif /* AKANTU_MESH_HH_ */
diff --git a/src/mesh/mesh_inline_impl.hh b/src/mesh/mesh_inline_impl.hh
index 0050b9f00..0f3286a05 100644
--- a/src/mesh/mesh_inline_impl.hh
+++ b/src/mesh/mesh_inline_impl.hh
@@ -1,709 +1,714 @@
 /**
  * @file   mesh_inline_impl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@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: Thu Jul 15 2010
  * @date last modification: Fri Dec 11 2020
  *
  * @brief  Implementation of the inline functions of the mesh 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 "aka_iterators.hh"
 #include "element_class.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 
 // #ifndef __AKANTU_MESH_INLINE_IMPL_CC__
 // #define __AKANTU_MESH_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-inline constexpr auto Mesh::getKind(ElementType type) {
-  return tuple_dispatch<AllElementTypes>(
-      [&](auto && enum_type) {
-        constexpr ElementType type = std::decay_t<decltype(enum_type)>::value;
-        return ElementClass<type>::getKind();
-      },
-      type);
-}
 
 /* -------------------------------------------------------------------------- */
-inline constexpr auto Element::kind() const -> ElementKind {
-  return Mesh::getKind(type);
-}
-
-/* -------------------------------------------------------------------------- */
-inline constexpr auto Mesh::getNbFacetsPerElement(ElementType type) {
+inline constexpr auto Mesh::getNbFacetsPerElement(ElementType type) -> Int {
   return tuple_dispatch<AllElementTypes>(
       [&](auto && enum_type) {
         constexpr ElementType type = std::decay_t<decltype(enum_type)>::value;
         return ElementClass<type>::getNbFacetsPerElement();
       },
       type);
 }
 
 /* -------------------------------------------------------------------------- */
-inline constexpr auto Mesh::getNbFacetsPerElement(ElementType type, Idx t) {
+inline constexpr auto Mesh::getNbFacetsPerElement(ElementType type, Idx t)
+    -> Int {
   return tuple_dispatch<AllElementTypes>(
       [&](auto && enum_type) {
         constexpr ElementType type = std::decay_t<decltype(enum_type)>::value;
         return ElementClass<type>::getNbFacetsPerElement(t);
       },
       type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename... pack>
 auto Mesh::elementTypes(pack &&... _pack) const -> ElementTypesIteratorHelper {
   return connectivities.elementTypes(_pack...);
 }
 
 /* -------------------------------------------------------------------------- */
 inline decltype(auto) Mesh::getConnectivity(const Element & element) const {
   return connectivities.get(element);
 }
 
 /* -------------------------------------------------------------------------- */
 inline RemovedNodesEvent::RemovedNodesEvent(const Mesh & mesh,
                                             const std::string & origin)
     : MeshEvent<Idx>(origin),
       new_numbering(mesh.getNbNodes(), 1, "new_numbering") {}
 
 /* -------------------------------------------------------------------------- */
 inline RemovedElementsEvent::RemovedElementsEvent(const Mesh & mesh,
                                                   const ID & new_numbering_id,
                                                   const std::string & origin)
     : MeshEvent<Element>(origin),
       new_numbering(new_numbering_id, mesh.getID()) {}
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void Mesh::sendEvent<NewElementsEvent>(NewElementsEvent & event) {
   this->fillNodesToElements();
   EventHandlerManager<MeshEventHandler>::sendEvent(event);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> inline void Mesh::sendEvent<NewNodesEvent>(NewNodesEvent & event) {
   this->computeBoundingBox();
   this->nodes_flags->resize(this->nodes->size(), NodeFlag::_normal);
   EventHandlerManager<MeshEventHandler>::sendEvent(event);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 Mesh::sendEvent<RemovedElementsEvent>(RemovedElementsEvent & event) {
   this->connectivities.onElementsRemoved(event.getNewNumbering());
   this->fillNodesToElements();
   this->computeBoundingBox();
 
   EventHandlerManager<MeshEventHandler>::sendEvent(event);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void Mesh::sendEvent<RemovedNodesEvent>(RemovedNodesEvent & event) {
   const auto & new_numbering = event.getNewNumbering();
   this->removeNodesFromArray(*nodes, new_numbering);
   if (nodes_global_ids and not is_mesh_facets) {
     this->removeNodesFromArray(*nodes_global_ids, new_numbering);
   }
   if (not is_mesh_facets) {
     this->removeNodesFromArray(*nodes_flags, new_numbering);
   }
 
   if (not nodes_to_elements.empty()) {
     std::vector<std::unique_ptr<std::set<Element>>> tmp(
         nodes_to_elements.size());
     auto it = nodes_to_elements.begin();
 
     Int new_nb_nodes = 0;
     for (auto new_i : new_numbering) {
       if (new_i != Int(-1)) {
         tmp[new_i] = std::move(*it);
         ++new_nb_nodes;
       }
       ++it;
     }
 
     tmp.resize(new_nb_nodes);
     std::move(tmp.begin(), tmp.end(), nodes_to_elements.begin());
   }
 
   computeBoundingBox();
 
   EventHandlerManager<MeshEventHandler>::sendEvent(event);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Mesh::removeNodesFromArray(Array<T> & vect,
                                        const Array<Idx> & new_numbering) {
   Array<T> tmp(vect.size(), vect.getNbComponent());
   auto nb_component = vect.getNbComponent();
   auto new_nb_nodes = 0;
   for (Int i = 0; i < new_numbering.size(); ++i) {
     auto new_i = new_numbering(i);
     if (new_i != Int(-1)) {
       T * to_copy = vect.data() + i * nb_component;
       std::uninitialized_copy(to_copy, to_copy + nb_component,
                               tmp.data() + new_i * nb_component);
       ++new_nb_nodes;
     }
   }
 
   tmp.resize(new_nb_nodes);
   vect.copy(tmp);
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::getNodesGlobalIdsPointer() -> Array<Idx> & {
   AKANTU_DEBUG_IN();
   if (not nodes_global_ids) {
     nodes_global_ids = std::make_shared<Array<Idx>>(
         nodes->size(), 1, getID() + ":nodes_global_ids");
 
     for (auto && global_ids : enumerate(*nodes_global_ids)) {
       std::get<1>(global_ids) = std::get<0>(global_ids);
     }
   }
 
   AKANTU_DEBUG_OUT();
   return *nodes_global_ids;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline decltype(auto)
 Mesh::getDataPointer(const ID & data_name, ElementType el_type,
                      GhostType ghost_type, Int nb_component,
                      bool size_to_nb_element, bool resize_with_parent) {
   Array<T> & tmp = this->getElementalDataArrayAlloc<T>(
       data_name, el_type, ghost_type, nb_component);
 
   if (size_to_nb_element) {
     if (resize_with_parent) {
       tmp.resize(mesh_parent->getNbElement(el_type, ghost_type));
     } else {
       tmp.resize(this->getNbElement(el_type, ghost_type));
     }
   }
 
   return tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline decltype(auto)
 Mesh::getDataPointer(const ID & data_name, ElementType el_type,
                      GhostType ghost_type, Int nb_component,
                      bool size_to_nb_element, bool resize_with_parent,
                      const T & defaul_) {
   Array<T> & tmp = this->getElementalDataArrayAlloc<T>(
       data_name, el_type, ghost_type, nb_component);
 
   if (size_to_nb_element) {
     if (resize_with_parent) {
       tmp.resize(mesh_parent->getNbElement(el_type, ghost_type), defaul_);
     } else {
       tmp.resize(this->getNbElement(el_type, ghost_type), defaul_);
     }
   }
 
   return tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline decltype(auto) Mesh::getData(const ID & data_name, ElementType el_type,
                                     GhostType ghost_type) const {
   return this->getElementalDataArray<T>(data_name, el_type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline decltype(auto) Mesh::getData(const ID & data_name, ElementType el_type,
                                     GhostType ghost_type) {
   return this->getElementalDataArray<T>(data_name, el_type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline decltype(auto) Mesh::getData(const ID & data_name) const {
   return this->getElementalData<T>(data_name);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline decltype(auto) Mesh::getData(const ID & data_name) {
   return this->getElementalData<T>(data_name);
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::getConnectivityPointer(ElementType type, GhostType ghost_type)
     -> Array<Idx> & {
   if (connectivities.exists(type, ghost_type)) {
     return connectivities(type, ghost_type);
   }
 
   if (ghost_type != _not_ghost) {
     ghosts_counters.alloc(0, 1, type, ghost_type, 1);
   }
 
   AKANTU_DEBUG_INFO("The connectivity vector for the type " << type
                                                             << " created");
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   return connectivities.alloc(0, nb_nodes_per_element, type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline decltype(auto)
 Mesh::getElementToSubelementPointer(ElementType type, GhostType ghost_type) {
   return getDataPointer<std::vector<Element>>("element_to_subelement", type,
                                               ghost_type, 1, true);
 }
 
 /* -------------------------------------------------------------------------- */
 inline decltype(auto)
 Mesh::getSubelementToElementPointer(ElementType type, GhostType ghost_type) {
   auto & array = getDataPointer<Element>(
       "subelement_to_element", type, ghost_type, getNbFacetsPerElement(type),
       false, is_mesh_facets, ElementNull);
   return array;
 }
 
 /* -------------------------------------------------------------------------- */
 inline decltype(auto) Mesh::getElementToSubelement() const {
   return getData<std::vector<Element>>("element_to_subelement");
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto & Mesh::getElementToSubelementNC() {
   return getData<std::vector<Element>>("element_to_subelement");
 }
 
 /* -------------------------------------------------------------------------- */
 inline const auto & Mesh::getElementToSubelement(ElementType type,
                                                  GhostType ghost_type) const {
   return getData<std::vector<Element>>("element_to_subelement", type,
                                        ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto & Mesh::getElementToSubelementNC(ElementType type,
                                              GhostType ghost_type) {
   return getData<std::vector<Element>>("element_to_subelement", type,
                                        ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline decltype(auto)
 Mesh::getElementToSubelement(const Element & element) const {
   return getData<std::vector<Element>>("element_to_subelement")(element, 0);
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto & Mesh::getElementToSubelementNC(const Element & element) {
   return getData<std::vector<Element>>("element_to_subelement")(element, 0);
 }
 
 /* -------------------------------------------------------------------------- */
 inline decltype(auto) Mesh::getSubelementToElement() const {
   return getData<Element>("subelement_to_element");
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto & Mesh::getSubelementToElementNC() {
   return getData<Element>("subelement_to_element");
 }
 
 /* -------------------------------------------------------------------------- */
 inline const auto & Mesh::getSubelementToElement(ElementType type,
                                                  GhostType ghost_type) const {
   return getData<Element>("subelement_to_element", type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto & Mesh::getSubelementToElementNC(ElementType type,
                                              GhostType ghost_type) {
   return getData<Element>("subelement_to_element", type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline decltype(auto)
 Mesh::getSubelementToElement(const Element & element) const {
   return this->getSubelementToElement().get(element);
 }
 
 /* -------------------------------------------------------------------------- */
 inline decltype(auto)
 Mesh::getSubelementToElementNC(const Element & element) const {
   return this->getSubelementToElement().get(element);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class D, std::enable_if_t<aka::is_vector<D>::value> *>
 inline void Mesh::getBarycenter(const Element & element,
                                 Eigen::MatrixBase<D> & barycenter) const {
   const auto && conn = getConnectivity(element);
   Matrix<Real> local_coord(spatial_dimension, conn.size());
   auto node_begin = make_view(*nodes, spatial_dimension).begin();
 
   for (auto && data : enumerate(conn)) {
     local_coord(std::get<0>(data)) = node_begin[std::get<1>(data)];
   }
 
   Math::barycenter(local_coord, barycenter);
 }
 
 /* -------------------------------------------------------------------------- */
-inline constexpr auto Mesh::getP1ElementType(ElementType type) {
+inline constexpr auto Mesh::getKind(ElementType type) -> ElementKind {
+  return tuple_dispatch<AllElementTypes>(
+      [&](auto && enum_type) {
+        constexpr ElementType type = std::decay_t<decltype(enum_type)>::value;
+        return ElementClass<type>::getKind();
+      },
+      type);
+}
+
+/* -------------------------------------------------------------------------- */
+inline constexpr auto Element::kind() const -> ElementKind {
+  return Mesh::getKind(type);
+}
+
+/* -------------------------------------------------------------------------- */
+inline constexpr auto Mesh::getP1ElementType(ElementType type) -> ElementType {
   return tuple_dispatch<AllElementTypes>(
       [&](auto && enum_type) {
         constexpr ElementType type = std::decay_t<decltype(enum_type)>::value;
         return ElementClass<type>::getP1ElementType();
       },
       type);
 }
 
 /* -------------------------------------------------------------------------- */
-inline constexpr auto Mesh::getSpatialDimension(ElementType type) {
+inline constexpr auto Mesh::getSpatialDimension(ElementType type) -> Int {
   return tuple_dispatch<AllElementTypes>(
       [&](auto && enum_type) {
         constexpr ElementType type = std::decay_t<decltype(enum_type)>::value;
         return ElementClass<type>::getSpatialDimension();
       },
       type);
 }
 
 /* -------------------------------------------------------------------------- */
-inline constexpr auto Mesh::getNaturalSpaceDimension(ElementType type) {
+inline constexpr auto Mesh::getNaturalSpaceDimension(ElementType type) -> Int {
   return tuple_dispatch<AllElementTypes>(
       [&](auto && enum_type) {
         constexpr ElementType type = std::decay_t<decltype(enum_type)>::value;
         return ElementClass<type>::getNaturalSpaceDimension();
       },
       type);
 }
 
 /* -------------------------------------------------------------------------- */
-inline constexpr auto Mesh::getNbFacetTypes(ElementType type, Idx /*t*/) {
+inline constexpr auto Mesh::getNbFacetTypes(ElementType type, Idx /*t*/)
+    -> Int {
   return tuple_dispatch<AllElementTypes>(
       [&](auto && enum_type) {
         constexpr ElementType type = std::decay_t<decltype(enum_type)>::value;
         return ElementClass<type>::getNbFacetTypes();
       },
       type);
 }
 
 /* -------------------------------------------------------------------------- */
-inline constexpr auto Mesh::getFacetType(ElementType type, Idx t) {
+inline constexpr auto Mesh::getFacetType(ElementType type, Idx t)
+    -> ElementType {
   return tuple_dispatch<AllElementTypes>(
       [&](auto && enum_type) {
         constexpr ElementType type = std::decay_t<decltype(enum_type)>::value;
         return ElementClass<type>::getFacetType(t);
       },
       type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline decltype(auto) Mesh::getAllFacetTypes(ElementType type) {
   return tuple_dispatch<AllElementTypes>(
       [&](auto && enum_type) {
         constexpr ElementType type = std::decay_t<decltype(enum_type)>::value;
         auto && map = ElementClass<type>::getFacetTypes();
         return Eigen::Map<const Eigen::Matrix<ElementType, Eigen::Dynamic, 1>>(
             map.data(), map.rows(), map.cols());
       },
       type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline decltype(auto) Mesh::getFacetLocalConnectivity(ElementType type, Idx t) {
   return tuple_dispatch<AllElementTypes>(
       [&](auto && enum_type) {
         constexpr ElementType type = std::decay_t<decltype(enum_type)>::value;
         return ElementClass<type>::getFacetLocalConnectivityPerElement(t);
       },
       type);
 }
 
 /* -------------------------------------------------------------------------- */
-inline decltype(auto) Mesh::getFacetConnectivity(const Element & element,
-                                                 Idx t) const {
+inline auto Mesh::getFacetConnectivity(const Element & element, Idx t) const
+    -> Matrix<Idx> {
   auto local_facets = getFacetLocalConnectivity(element.type, t);
   Matrix<Idx> facets(local_facets.rows(), local_facets.cols());
 
   const auto & conn = connectivities(element.type, element.ghost_type);
 
   for (Int f = 0; f < facets.rows(); ++f) {
     for (Int n = 0; n < facets.cols(); ++n) {
       facets(f, n) = conn(element.element, local_facets(f, n));
     }
   }
 
   return facets;
 }
 
 /* -------------------------------------------------------------------------- */
 inline decltype(auto) Mesh::getConnectivityNC(const Element & element) {
   return connectivities.get(element);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Mesh::extractNodalValuesFromElement(
     const Array<T> & nodal_values, T * local_coord, Int * connectivity,
     Int n_nodes, Int nb_degree_of_freedom) const {
   for (Int n = 0; n < n_nodes; ++n) {
     memcpy(local_coord + n * nb_degree_of_freedom,
            nodal_values.data() + connectivity[n] * nb_degree_of_freedom,
            nb_degree_of_freedom * sizeof(T));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Mesh::addConnectivityType(ElementType type, GhostType ghost_type) {
   getConnectivityPointer(type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::isPureGhostNode(Idx n) const -> bool {
   return ((*nodes_flags)(n)&NodeFlag::_shared_mask) == NodeFlag::_pure_ghost;
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::isLocalOrMasterNode(Idx n) const -> bool {
   return ((*nodes_flags)(n)&NodeFlag::_local_master_mask) == NodeFlag::_normal;
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::isLocalNode(Idx n) const -> bool {
   return ((*nodes_flags)(n)&NodeFlag::_shared_mask) == NodeFlag::_normal;
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::isMasterNode(Idx n) const -> bool {
   return ((*nodes_flags)(n)&NodeFlag::_shared_mask) == NodeFlag::_master;
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::isSlaveNode(Idx n) const -> bool {
   return ((*nodes_flags)(n)&NodeFlag::_shared_mask) == NodeFlag::_slave;
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::isPeriodicSlave(Idx n) const -> bool {
   return ((*nodes_flags)(n)&NodeFlag::_periodic_mask) ==
          NodeFlag::_periodic_slave;
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::isPeriodicMaster(Idx n) const -> bool {
   return ((*nodes_flags)(n)&NodeFlag::_periodic_mask) ==
          NodeFlag::_periodic_master;
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::getNodeFlag(Idx local_id) const -> NodeFlag {
   return (*nodes_flags)(local_id);
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::getNodePrank(Idx local_id) const {
   auto it = nodes_prank.find(local_id);
   return it == nodes_prank.end() ? -1 : it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::getNodeGlobalId(Idx local_id) const {
   return nodes_global_ids ? (*nodes_global_ids)(local_id) : local_id;
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::getNodeLocalId(Idx global_id) const {
   if (nodes_global_ids == nullptr) {
     return global_id;
   }
   return nodes_global_ids->find(global_id);
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::getNbGlobalNodes() const {
   return nodes_global_ids ? nb_global_nodes : nodes->size();
 }
 
 /* -------------------------------------------------------------------------- */
-inline auto Mesh::getNbNodesPerElementList(const Array<Element> & elements) {
+inline auto Mesh::getNbNodesPerElementList(const Array<Element> & elements)
+    -> Int {
   Int nb_nodes_per_element = 0;
   Int nb_nodes = 0;
   ElementType current_element_type = _not_defined;
 
   for (const auto & el : elements) {
     if (el.type != current_element_type) {
       current_element_type = el.type;
       nb_nodes_per_element = Mesh::getNbNodesPerElement(current_element_type);
     }
 
     nb_nodes += nb_nodes_per_element;
   }
 
   return nb_nodes;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Mesh & Mesh::getMeshFacets() {
   if (this->mesh_facets == nullptr) {
     AKANTU_SILENT_EXCEPTION(
         "No facet mesh is defined yet! check the buildFacets functions");
   }
 
   return *this->mesh_facets;
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Mesh & Mesh::getMeshFacets() const {
   if (this->mesh_facets == nullptr) {
     AKANTU_SILENT_EXCEPTION(
         "No facet mesh is defined yet! check the buildFacets functions");
   }
 
   return *this->mesh_facets;
 }
 /* -------------------------------------------------------------------------- */
 inline const Mesh & Mesh::getMeshParent() const {
   if (this->mesh_parent == nullptr) {
     AKANTU_SILENT_EXCEPTION(
         "No parent mesh is defined! This is only valid in a mesh_facets");
   }
 
   return *this->mesh_parent;
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::addPeriodicSlave(Idx slave, Idx master) {
   if (master == slave) {
     return;
   }
 
   // if pair already registered
   auto master_slaves = periodic_master_slave.equal_range(master);
   auto slave_it =
       std::find_if(master_slaves.first, master_slaves.second,
                    [&](auto & pair) { return pair.second == slave; });
   if (slave_it == master_slaves.second) {
     // no duplicates
     periodic_master_slave.insert(std::make_pair(master, slave));
     AKANTU_DEBUG_INFO("adding periodic slave, slave gid:"
                       << getNodeGlobalId(slave) << " [lid: " << slave << "]"
                       << ", master gid:" << getNodeGlobalId(master)
                       << " [lid: " << master << "]");
     // std::cout << "adding periodic slave, slave gid:" <<
     // getNodeGlobalId(slave)
     //           << " [lid: " << slave << "]"
     //           << ", master gid:" << getNodeGlobalId(master)
     //           << " [lid: " << master << "]" << std::endl;
   }
 
   periodic_slave_master[slave] = master;
 
   auto set_flag = [&](auto node, auto flag) {
     (*nodes_flags)[node] &= ~NodeFlag::_periodic_mask; // clean periodic flags
     (*nodes_flags)[node] |= flag;
   };
 
   set_flag(slave, NodeFlag::_periodic_slave);
   set_flag(master, NodeFlag::_periodic_master);
 }
 
 /* -------------------------------------------------------------------------- */
 auto Mesh::getPeriodicMaster(Idx slave) const -> Idx {
   return periodic_slave_master.at(slave);
 }
 
 /* -------------------------------------------------------------------------- */
 class Mesh::PeriodicSlaves {
   using internal_iterator = std::unordered_multimap<Idx, Idx>::const_iterator;
   std::pair<internal_iterator, internal_iterator> pair;
 
 public:
   PeriodicSlaves(const Mesh & mesh, Idx master)
       : pair(mesh.getPeriodicMasterSlaves().equal_range(master)) {}
 
   PeriodicSlaves(const PeriodicSlaves & other) = default;
   PeriodicSlaves(PeriodicSlaves && other) noexcept = default;
   auto operator=(const PeriodicSlaves & other) -> PeriodicSlaves & = default;
 
   class const_iterator {
     internal_iterator it;
 
   public:
     const_iterator(internal_iterator it) : it(it) {}
 
     const_iterator operator++() {
       ++it;
       return *this;
     }
     bool operator!=(const const_iterator & other) { return other.it != it; }
     auto operator*() { return it->second; }
   };
 
   auto begin() const { return const_iterator(pair.first); }
   auto end() const { return const_iterator(pair.second); }
 };
 
 /* -------------------------------------------------------------------------- */
 inline decltype(auto) Mesh::getPeriodicSlaves(Idx master) const {
   return PeriodicSlaves(*this, master);
 }
 
 /* -------------------------------------------------------------------------- */
 inline decltype(auto)
 Mesh::getConnectivityWithPeriodicity(const Element & element) const {
   Vector<Idx> conn = getConnectivity(element);
   if (not isPeriodic()) {
     return conn;
   }
 
   for (auto && node : conn) {
     if (isPeriodicSlave(node)) {
       node = getPeriodicMaster(node);
     }
   }
 
   return conn;
 }
 
 } // namespace akantu
 
 //#endif /* __AKANTU_MESH_INLINE_IMPL_CC__ */
diff --git a/src/model/common/non_local_toolbox/neighborhood_base.cc b/src/model/common/non_local_toolbox/neighborhood_base.cc
index 72fa07178..0cefe1d14 100644
--- a/src/model/common/non_local_toolbox/neighborhood_base.cc
+++ b/src/model/common/non_local_toolbox/neighborhood_base.cc
@@ -1,306 +1,306 @@
 /**
  * @file   neighborhood_base.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sat Sep 26 2015
  * @date last modification: Fri Jul 24 2020
  *
  * @brief  Implementation of generic neighborhood base
  *
  *
  * @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 "neighborhood_base.hh"
 #include "grid_synchronizer.hh"
 #include "mesh_accessor.hh"
 #include "model.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 NeighborhoodBase::NeighborhoodBase(Model & model,
                                    const ElementTypeMapReal & quad_coordinates,
                                    const ID & id)
     : id(id), model(model), quad_coordinates(quad_coordinates),
       spatial_dimension(this->model.getMesh().getSpatialDimension()) {
 
   AKANTU_DEBUG_IN();
 
   this->registerDataAccessor(*this);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 NeighborhoodBase::~NeighborhoodBase() = default;
 
 /* -------------------------------------------------------------------------- */
 // void NeighborhoodBase::createSynchronizerRegistry(
 //     DataAccessor<Element> * data_accessor) {
 //   this->synch_registry = new SynchronizerRegistry(*data_accessor);
 // }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodBase::initNeighborhood() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Creating the grid");
   this->createGrid();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* ------------------------------------------------------------------------- */
 void NeighborhoodBase::createGrid() {
   AKANTU_DEBUG_IN();
 
   const Real safety_factor = 1.2; // for the cell grid spacing
   Mesh & mesh = this->model.getMesh();
 
   const auto & lower_bounds = mesh.getLocalLowerBounds();
   const auto & upper_bounds = mesh.getLocalUpperBounds();
   Vector<Real> center = 0.5 * (upper_bounds + lower_bounds);
   Vector<Real> spacing(spatial_dimension);
   spacing.fill(this->neighborhood_radius * safety_factor);
 
   spatial_grid = std::make_unique<SpatialGrid<IntegrationPoint>>(
       spatial_dimension, spacing, center);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodBase::updatePairList() {
   AKANTU_DEBUG_IN();
 
   //// loop over all quads -> all cells
   for (auto && cell_id : *spatial_grid) {
     AKANTU_DEBUG_INFO("Looping on next cell");
 
     for (auto && q1 : spatial_grid->getCell(cell_id)) {
       if (q1.ghost_type == _ghost) {
         break;
       }
       auto coords_type_1_it = this->quad_coordinates(q1.type, q1.ghost_type)
                                   .begin(spatial_dimension);
       auto q1_coords = Vector<Real>(coords_type_1_it[q1.global_num]);
 
       AKANTU_DEBUG_INFO("Current quadrature point in this cell: " << q1);
       auto cell_id = spatial_grid->getCellID(q1_coords);
 
       /// loop over all the neighboring cells of the current quad
       for (auto && neighbor_cell : cell_id.neighbors()) {
         // loop over the quadrature point in the current neighboring cell
         for (auto && q2 : spatial_grid->getCell(neighbor_cell)) {
           auto coords_type_2_it = this->quad_coordinates(q2.type, q2.ghost_type)
                                       .begin(spatial_dimension);
           auto q2_coords = Vector<Real>(coords_type_2_it[q2.global_num]);
 
           Real distance = q1_coords.distance(q2_coords);
 
           if (distance <= this->neighborhood_radius + Math::getTolerance() &&
               (q2.ghost_type == _ghost ||
                (q2.ghost_type == _not_ghost &&
                 q1.global_num <= q2.global_num))) { // storing only half lists
             pair_list[q2.ghost_type].push_back(std::make_pair(q1, q2));
           }
         }
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodBase::savePairs(const std::string & filename) const {
   std::stringstream sstr;
 
   const Communicator & comm = model.getMesh().getCommunicator();
   Int prank = comm.whoAmI();
   sstr << filename << "." << prank;
 
   std::ofstream pout;
   pout.open(sstr.str().c_str());
 
   for (auto && ghost_type : ghost_types) {
     for (const auto & pair : pair_list[ghost_type]) {
       const auto & q1 = pair.first;
       const auto & q2 = pair.second;
       pout << q1 << " " << q2 << " " << std::endl;
     }
   }
 
   pout.close();
 
   if (comm.getNbProc() != 1) {
     return;
   }
 
   Mesh mesh_out(spatial_dimension);
   MeshAccessor mesh_accessor(mesh_out);
   auto & connectivity = mesh_accessor.getConnectivity(_segment_2);
   auto & tag = mesh_accessor.getData<UInt>("tag_1", _segment_2);
   auto & nodes = mesh_accessor.getNodes();
 
   std::map<IntegrationPoint, UInt> quad_to_nodes;
   UInt node = 0;
 
   IntegrationPoint q1;
   IntegrationPoint q2;
   bool inserted;
   for (auto && ghost_type : ghost_types) {
     for (const auto & pair : pair_list[ghost_type]) {
       std::tie(q1, q2) = pair;
 
       auto add_node = [&](auto && q) {
         std::tie(std::ignore, inserted) =
             quad_to_nodes.insert(std::make_pair(q, node));
 
         if (not inserted) {
           return;
         }
 
         auto coords_it = this->quad_coordinates(q.type, q.ghost_type)
                              .begin(spatial_dimension);
         auto && coords = Vector<Real>(coords_it[q.global_num]);
         nodes.push_back(coords);
         ++node;
       };
 
       add_node(q1);
       add_node(q2);
     }
   }
 
   for (auto && ghost_type : ghost_types) {
     for (const auto & pair : pair_list[ghost_type]) {
       std::tie(q1, q2) = pair;
 
-      UInt node1 = quad_to_nodes[q1];
-      UInt node2 = quad_to_nodes[q2];
+      Idx node1 = quad_to_nodes[q1];
+      Idx node2 = quad_to_nodes[q2];
 
-      connectivity.push_back(Vector<UInt>{node1, node2});
+      connectivity.push_back(Vector<Idx>{node1, node2});
       tag.push_back(node1 + 1);
       if (node1 != node2) {
-        connectivity.push_back(Vector<UInt>{node2, node1});
+        connectivity.push_back(Vector<Idx>{node2, node1});
         tag.push_back(node2 + 1);
       }
     }
   }
 
   mesh_out.write(filename + ".msh");
 }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodBase::saveNeighborCoords(const std::string & filename) const {
   // this function is not optimized and only used for tests on small meshes
   // @todo maybe optimize this function for better performance?
   IntegrationPoint q2;
 
   std::stringstream sstr;
 
   const Communicator & comm = model.getMesh().getCommunicator();
   Int prank = comm.whoAmI();
   sstr << filename << "." << prank;
 
   std::ofstream pout;
   pout.open(sstr.str().c_str());
 
   /// loop over all the quads and write the position of their neighbors
   for (auto && cell_id : *spatial_grid) {
     for (auto && q1 : spatial_grid->getCell(cell_id)) {
       auto coords_type_1_it = this->quad_coordinates(q1.type, q1.ghost_type)
                                   .begin(spatial_dimension);
       auto && q1_coords = Vector<Real>(coords_type_1_it[q1.global_num]);
 
       pout << "#neighbors for quad " << q1.global_num << std::endl;
       pout << q1_coords << std::endl;
 
       for (auto && ghost_type2 : ghost_types) {
         for (auto && pair : pair_list[ghost_type2]) {
           if (q1 == pair.first && pair.second != q1) {
             q2 = pair.second;
           } else if (q1 == pair.second && pair.first != q1) {
             q2 = pair.first;
           } else {
             continue;
           }
 
           auto coords_type_2_it = this->quad_coordinates(q2.type, q2.ghost_type)
                                       .begin(spatial_dimension);
           auto && q2_coords = Vector<Real>(coords_type_2_it[q2.global_num]);
           pout << q2_coords << std::endl;
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodBase::onElementsRemoved(
     const Array<Element> & element_list,
     const ElementTypeMapArray<Idx> & new_numbering,
     const RemovedElementsEvent & event) {
   AKANTU_DEBUG_IN();
 
   auto & fem = this->model.getFEEngine();
   Int nb_quad = 0;
 
   auto cleanPoint = [&](auto && q) {
     if (new_numbering.exists(q.type, q.ghost_type)) {
       auto q_new_el = new_numbering(q.type, q.ghost_type)(q.element);
       AKANTU_DEBUG_ASSERT(q_new_el != Int(-1),
                           "A local quadrature_point "
                               << q
                               << " as been removed instead of "
                                  "just being renumbered: "
                               << id);
       q.element = q_new_el;
       nb_quad = fem.getNbIntegrationPoints(q.type, q.ghost_type);
       q.global_num = nb_quad * q.element + q.num_point;
     }
   };
 
   // Change the pairs in new global numbering
   for (auto ghost_type : ghost_types) {
     auto & pair_list = this->pair_list.at(ghost_type);
     for (auto && pair : pair_list) {
       if (pair.first.ghost_type == _ghost) {
         cleanPoint(pair.first);
       }
       if (pair.second.ghost_type == _ghost) {
         cleanPoint(pair.second);
       }
     }
   }
 
   this->grid_synchronizer->onElementsRemoved(element_list, new_numbering,
                                              event);
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/materials/material_plastic/material_linear_isotropic_hardening_inline_impl.hh b/src/model/solid_mechanics/materials/material_plastic/material_linear_isotropic_hardening_inline_impl.hh
index 1673e5265..bef33dbc2 100644
--- a/src/model/solid_mechanics/materials/material_plastic/material_linear_isotropic_hardening_inline_impl.hh
+++ b/src/model/solid_mechanics/materials/material_plastic/material_linear_isotropic_hardening_inline_impl.hh
@@ -1,214 +1,215 @@
 /**
  * @file   material_linear_isotropic_hardening_inline_impl.hh
  *
  * @author Ramin Aghababaei <ramin.aghababaei@epfl.ch>
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Benjamin Paccaud <benjamin.paccaud@epfl.ch>
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Apr 07 2014
  * @date last modification: Thu Feb 20 2020
  *
  * @brief  Implementation of the inline functions of the material plasticity
  *
  *
  * @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 "material_linear_isotropic_hardening.hh"
 
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 /// Infinitesimal deformations
 template <Int dim>
 template <class Args, std::enable_if_t<not tuple::has_t<"F"_h, Args>::value> *>
 inline void
-MaterialLinearIsotropicHardening<dim>::computeStressOnQuad(Args && arguments) {
-  auto && sigma_th = tuple::get<"sigma_th"_h>(arguments);
-  auto && previous_sigma_th = tuple::get<"previous_sigma_th"_h>(arguments);
+MaterialLinearIsotropicHardening<dim>::computeStressOnQuad(Args && args) {
 
-  auto delta_sigma_th = sigma_th - previous_sigma_th;
+  Real delta_sigma_th = 0.;
+  static_if(tuple::has_t<"sigma_th"_h, Args>())
+      .then([&delta_sigma_th](auto && args) {
+        delta_sigma_th = tuple::get<"previous_sigma_th"_h>(args) -
+                         tuple::get<"sigma_th"_h>(args);
+      })(std::forward<Args>(args));
 
-  auto && grad_u = tuple::get<"grad_u"_h>(arguments);
-  auto && previous_grad_u = tuple::get<"previous_grad_u"_h>(arguments);
+  auto && grad_u = tuple::get<"grad_u"_h>(args);
+  auto && previous_grad_u = tuple::get<"previous_grad_u"_h>(args);
   auto && grad_delta_u = grad_u - previous_grad_u;
 
   Matrix<Real, dim, dim> sigma_tr;
 
   // Compute trial stress, sigma_tr
   MaterialElastic<dim>::computeStressOnQuad(
       tuple::make_named_tuple(tuple::get<"grad_u"_h>() = grad_delta_u,
                               tuple::get<"sigma"_h>() = sigma_tr,
                               tuple::get<"sigma_th"_h>() = delta_sigma_th));
 
-  auto && previous_sigma = tuple::get<"previous_sigma"_h>(arguments);
+  auto && previous_sigma = tuple::get<"previous_sigma"_h>(args);
   sigma_tr += previous_sigma;
 
   // We need a full stress tensor, otherwise the VM stress is messed up
   Matrix<Real, 3, 3> sigma_tr_dev = Matrix<Real, 3, 3>::Zero();
   sigma_tr_dev.block<dim, dim>(0, 0) = sigma_tr;
 
   sigma_tr_dev -= Matrix<Real, 3, 3>::Identity() * sigma_tr.trace() / 3.0;
 
   // Compute effective deviatoric trial stress
   auto s = sigma_tr_dev.doubleDot(sigma_tr_dev);
   auto sigma_tr_dev_eff = std::sqrt(3. / 2. * s);
 
-  auto && iso_hardening = tuple::get<"iso_hardening"_h>(arguments);
+  auto && iso_hardening = tuple::get<"iso_hardening"_h>(args);
   auto initial_yielding =
       ((sigma_tr_dev_eff - iso_hardening - this->sigma_y) > 0);
 
-  auto && previous_iso_hardening =
-      tuple::get<"previous_iso_hardening"_h>(arguments);
+  auto && previous_iso_hardening = tuple::get<"previous_iso_hardening"_h>(args);
   auto dp = (initial_yielding)
                 ? (sigma_tr_dev_eff - this->sigma_y - previous_iso_hardening) /
                       (3 * this->mu + this->h)
                 : 0;
 
   iso_hardening = previous_iso_hardening + this->h * dp;
 
   // Compute inelastic strain (ignore last components in 1-2D)
   Matrix<Real, dim, dim> delta_inelastic_strain;
   if (std::abs(sigma_tr_dev_eff) > sigma_tr_dev.norm() * Math::getTolerance()) {
     delta_inelastic_strain =
         sigma_tr_dev.block<dim, dim>(0, 0) * 3. / 2. * dp / sigma_tr_dev_eff;
   }
 
-  MaterialPlastic<dim>::computeStressAndInelasticStrainOnQuad(
-      tuple::append(arguments, tuple::get<"delta_inelastic_strain"_h>() =
-                                   delta_inelastic_strain));
+  MaterialPlastic<dim>::computeStressAndInelasticStrainOnQuad(tuple::append(
+      args, tuple::get<"delta_inelastic_strain"_h>() = delta_inelastic_strain));
 }
 
 /* -------------------------------------------------------------------------- */
 /// Finite deformations
 template <Int dim>
 template <class Args, std::enable_if_t<tuple::has_t<"F"_h, Args>::value> *>
 inline void
-MaterialLinearIsotropicHardening<dim>::computeStressOnQuad(Args && arguments) {
+MaterialLinearIsotropicHardening<dim>::computeStressOnQuad(Args && args) {
   // Finite plasticity
   Real dp = 0.0;
   Real d_dp = 0.0;
   UInt n = 0;
 
-  auto && sigma_th = tuple::get<"sigma_th"_h>(arguments);
-  auto && previous_sigma_th = tuple::get<"previous_sigma_th"_h>(arguments);
+  Real delta_sigma_th = 0.;
+  static_if(tuple::has_t<"sigma_th"_h, Args>())
+      .then([&delta_sigma_th](auto && args) {
+        delta_sigma_th = tuple::get<"previous_sigma_th"_h>(args) -
+                         tuple::get<"sigma_th"_h>(args);
+      })(std::forward<Args>(args));
 
-  auto delta_sigma_th = sigma_th - previous_sigma_th;
-
-  auto && grad_u = tuple::get<"grad_u"_h>(arguments);
-  auto && previous_grad_u = tuple::get<"previous_grad_u"_h>(arguments);
+  auto && grad_u = tuple::get<"grad_u"_h>(args);
+  auto && previous_grad_u = tuple::get<"previous_grad_u"_h>(args);
   auto && grad_delta_u = grad_u - previous_grad_u;
 
   // Compute trial stress, sigma_tr
   Matrix<Real, dim, dim> sigma_tr;
   MaterialElastic<dim>::computeStressOnQuad(
       tuple::make_named_tuple(tuple::get<"grad_u"_h>() = grad_delta_u,
                               tuple::get<"sigma"_h>() = sigma_tr,
                               tuple::get<"sigma_th"_h>() = delta_sigma_th));
 
-  auto && previous_sigma = tuple::get<"previous_sigma"_h>(arguments);
+  auto && previous_sigma = tuple::get<"previous_sigma"_h>(args);
   sigma_tr += previous_sigma;
 
   // Compute deviatoric trial stress,  sigma_tr_dev
   auto && sigma_tr_dev =
       sigma_tr - Matrix<Real, dim, dim>::Identity() * sigma_tr.trace() / 3.0;
 
   // Compute effective deviatoric trial stress
   Real s = sigma_tr_dev.doubleDot(sigma_tr_dev);
   Real sigma_tr_dev_eff = std::sqrt(3. / 2. * s);
 
-  auto && F = tuple::get<"F"_h>(arguments);
+  auto && F = tuple::get<"F"_h>(args);
 
   // compute the cauchy stress to apply the Von-Mises criterion
   auto cauchy_stress = Material::StoCauchy<dim>(F, sigma_tr);
 
   auto && cauchy_stress_dev =
       cauchy_stress -
       Matrix<Real, dim, dim>::Identity() * cauchy_stress.trace() / 3.0;
   Real c = cauchy_stress_dev.doubleDot(cauchy_stress_dev);
   Real cauchy_stress_dev_eff = std::sqrt(3. / 2. * c);
 
-  auto && iso_hardening = tuple::get<"iso_hardening"_h>(arguments);
-  auto && previous_iso_hardening =
-      tuple::get<"previous_iso_hardening"_h>(arguments);
+  auto && iso_hardening = tuple::get<"iso_hardening"_h>(args);
+  auto && previous_iso_hardening = tuple::get<"previous_iso_hardening"_h>(args);
 
   const Real iso_hardening_t = previous_iso_hardening;
   iso_hardening = iso_hardening_t;
 
   // F is written in terms of cauchy stress
   bool initial_yielding =
       ((cauchy_stress_dev_eff - iso_hardening - this->sigma_y) > 0);
   while (initial_yielding && std::abs(cauchy_stress_dev_eff - iso_hardening -
                                       this->sigma_y) > Math::getTolerance()) {
 
     d_dp = (cauchy_stress_dev_eff - 3. * this->mu * dp - iso_hardening -
             this->sigma_y) /
            (3. * this->mu + this->h);
 
     // r = r +  h * dp;
     dp = dp + d_dp;
     iso_hardening = iso_hardening_t + this->h * dp;
 
     ++n;
     /// TODO : explicit this criterion with an error message
     if ((d_dp < 1e-5) || (n > 50)) {
       AKANTU_DEBUG_INFO("convergence of increment of plastic strain. d_dp:"
                         << d_dp << "\tNumber of iteration:" << n);
       break;
     }
   }
 
   // Update internal variable
   Matrix<Real, dim, dim> delta_inelastic_strain;
   if (std::abs(sigma_tr_dev_eff) > sigma_tr_dev.norm() * Math::getTolerance()) {
 
     // /// compute the direction of the plastic strain as \frac{\partial
     // F}{\partial S} = \frac{3}{2J\sigma_{effective}}} Ft \sigma_{dev} F
     Matrix<Real, dim, dim> cauchy_dev_F;
     cauchy_dev_F = F * cauchy_stress_dev;
     Real J = F.determinant();
     Real constant = not Math::are_float_equal(J, 0.) ? 1. / J : 0;
     constant *= 3. * dp / (2. * cauchy_stress_dev_eff);
     delta_inelastic_strain = F.transpose() * cauchy_dev_F * constant;
 
     // Direction given by the piola kirchhoff deviatoric tensor \frac{\partial
     // F}{\partial S} = \frac{3}{2\sigma_{effective}}}S_{dev}
     // delta_inelastic_strain.copy(sigma_tr_dev);
     // delta_inelastic_strain *= 3./2. * dp / sigma_tr_dev_eff;
   }
 
-  MaterialPlastic<dim>::computeStressAndInelasticStrainOnQuad(
-      tuple::append(arguments, tuple::get<"delta_inelastic_strain"_h>() =
-                                   delta_inelastic_strain));
+  MaterialPlastic<dim>::computeStressAndInelasticStrainOnQuad(tuple::append(
+      args, tuple::get<"delta_inelastic_strain"_h>() = delta_inelastic_strain));
 }
 
 /* -------------------------------------------------------------------------- */
 template <Int dim>
 template <class Args>
 inline void MaterialLinearIsotropicHardening<dim>::computeTangentModuliOnQuad(
-    Args && arguments) const {
+    Args && args) const {
   // Initial tangent
-  MaterialElastic<dim>::computeTangentModuliOnQuad(arguments);
+  MaterialElastic<dim>::computeTangentModuliOnQuad(args);
 }
 } // namespace akantu
diff --git a/src/model/structural_mechanics/structural_mechanics_model.hh b/src/model/structural_mechanics/structural_mechanics_model.hh
index 3534568e3..e5e2ee590 100644
--- a/src/model/structural_mechanics/structural_mechanics_model.hh
+++ b/src/model/structural_mechanics/structural_mechanics_model.hh
@@ -1,335 +1,334 @@
 /**
  * @file   structural_mechanics_model.hh
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Sébastien Hartmann <sebastien.hartmann@epfl.ch>
  * @author Philip Mueller <philip.paul.mueller@bluemail.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Damien Spielmann <damien.spielmann@epfl.ch>
  *
  * @date creation: Fri Jul 15 2011
  * @date last modification: Thu Apr 01 2021
  *
  * @brief  Particular implementation of the structural elements in the
  * StructuralMechanicsModel
  *
  *
  * @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_named_argument.hh"
-#include "boundary_condition.hh"
 #include "model.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_STRUCTURAL_MECHANICS_MODEL_HH_
 #define AKANTU_STRUCTURAL_MECHANICS_MODEL_HH_
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 class Material;
 class MaterialSelector;
 class DumperIOHelper;
 class NonLocalManager;
 template <ElementKind kind, class IntegrationOrderFunctor>
 class IntegratorGauss;
 template <ElementKind kind> class ShapeStructural;
 } // namespace akantu
 
 namespace akantu {
 
 struct StructuralMaterial {
   Real E{0};
   Real A{1};
   Real I{0};
   Real Iz{0};
   Real Iy{0};
   Real GJ{0};
   Real rho{0};
   Real t{0};
   Real nu{0};
 };
 
 class StructuralMechanicsModel : public Model {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   using MyFEEngineType =
       FEEngineTemplate<IntegratorGauss, ShapeStructural, _ek_structural>;
 
   StructuralMechanicsModel(Mesh & mesh, UInt dim = _all_dimensions,
                            const ID & id = "structural_mechanics_model");
 
   ~StructuralMechanicsModel() override;
 
   /// Init full model
   void initFullImpl(const ModelOptions & options) override;
 
   /// Init boundary FEEngine
   void initFEEngineBoundary() override;
 
   /* ------------------------------------------------------------------------ */
   /* Virtual methods from SolverCallback                                      */
   /* ------------------------------------------------------------------------ */
   /// get the type of matrix needed
   MatrixType getMatrixType(const ID & matrix_id) override;
 
   /// callback to assemble a Matrix
   void assembleMatrix(const ID & matrix_id) override;
 
   /// callback to assemble a lumped Matrix
   void assembleLumpedMatrix(const ID & matrix_id) override;
 
   /// callback to assemble the residual (rhs)
   void assembleResidual() override;
 
   void assembleResidual(const ID & residual_part) override;
 
   bool canSplitResidual() override { return true; }
 
   void afterSolveStep(bool converged) override;
 
   /// compute kinetic energy
   Real getKineticEnergy();
 
   /// compute potential energy
   Real getPotentialEnergy();
 
   /// compute the specified energy
   Real getEnergy(const ID & energy);
 
   /* ------------------------------------------------------------------------ */
   /* Virtual methods from Model                                               */
   /* ------------------------------------------------------------------------ */
 protected:
   /// get some default values for derived classes
   std::tuple<ID, TimeStepSolverType>
   getDefaultSolverID(const AnalysisMethod & method) override;
 
   ModelSolverOptions
   getDefaultSolverOptions(const TimeStepSolverType & type) const override;
 
   static UInt getNbDegreeOfFreedom(ElementType type);
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
   void initSolver(TimeStepSolverType time_step_solver_type,
                   NonLinearSolverType non_linear_solver_type) override;
 
   /// initialize the model
   void initModel() override;
 
   /// compute the stresses per elements
   void computeStresses();
 
   /// compute the nodal forces
   void assembleInternalForce();
 
   /// compute the nodal forces for an element type
   void assembleInternalForce(ElementType type, GhostType gt);
 
   /// assemble the stiffness matrix
   void assembleStiffnessMatrix();
 
   /// assemble the mass matrix for consistent mass resolutions
   void assembleMassMatrix();
 
 protected:
   /// assemble the mass matrix for either _ghost or _not_ghost elements
   void assembleMassMatrix(GhostType ghost_type);
 
   /// computes rho
   void computeRho(Array<Real> & rho, ElementType type, GhostType ghost_type);
 
   /// finish the computation of residual to solve in increment
   void updateResidualInternal();
 
   /* ------------------------------------------------------------------------ */
 private:
   template <ElementType type> void assembleStiffnessMatrix();
   template <ElementType type> void computeStressOnQuad();
   template <ElementType type>
   void computeTangentModuli(Array<Real> & tangent_moduli);
 
   /* ------------------------------------------------------------------------ */
   /* Dumpable interface                                                       */
   /* ------------------------------------------------------------------------ */
 public:
   std::shared_ptr<dumpers::Field>
   createNodalFieldReal(const std::string & field_name,
                        const std::string & group_name,
                        bool padding_flag) override;
 
   std::shared_ptr<dumpers::Field>
   createNodalFieldBool(const std::string & field_name,
                        const std::string & group_name,
                        bool padding_flag) override;
 
   std::shared_ptr<dumpers::Field>
   createElementalField(const std::string & field_name,
                        const std::string & group_name, bool padding_flag,
                        Int spatial_dimension, ElementKind kind) override;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// set the value of the time step
   void setTimeStep(Real time_step, const ID & solver_id = "") override;
 
   /// get the StructuralMechanicsModel::displacement vector
   AKANTU_GET_MACRO(Displacement, *displacement_rotation, Array<Real> &);
 
   /// get the StructuralMechanicsModel::velocity vector
   AKANTU_GET_MACRO(Velocity, *velocity, Array<Real> &);
 
   /// get    the    StructuralMechanicsModel::acceleration    vector,   updated
   /// by
   /// StructuralMechanicsModel::updateAcceleration
   AKANTU_GET_MACRO(Acceleration, *acceleration, Array<Real> &);
 
   /// get the StructuralMechanicsModel::external_force vector
   AKANTU_GET_MACRO(ExternalForce, *external_force, Array<Real> &);
 
   /// get the StructuralMechanicsModel::internal_force vector (boundary forces)
   AKANTU_GET_MACRO(InternalForce, *internal_force, Array<Real> &);
 
   /// get the StructuralMechanicsModel::boundary vector
   AKANTU_GET_MACRO(BlockedDOFs, *blocked_dofs, Array<bool> &);
 
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(RotationMatrix, rotation_matrix, Real);
 
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Stress, stress, Real);
 
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(ElementMaterial, element_material, UInt);
 
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(Set_ID, set_ID, UInt);
 
   /**
    * \brief This function adds the `StructuralMaterial` material to the list of
    * materials managed by *this.
    *
    * It is important that this function might invalidate all references to
    * structural materials, that were previously optained by `getMaterial()`.
    *
    * \param  material The new material.
    *
    * \return The ID of the material that was added.
    *
    * \note The return type is is new.
    */
   UInt addMaterial(StructuralMaterial & material, const ID & name = "");
 
   const StructuralMaterial &
   getMaterialByElement(const Element & element) const;
 
   /**
    * \brief Returns the ith material of *this.
    * \param i The ith material
    */
   const StructuralMaterial & getMaterial(UInt material_index) const;
 
   const StructuralMaterial & getMaterial(const ID & name) const;
 
   /**
    * \brief Returns the number of the different materials inside *this.
    */
   UInt getNbMaterials() const { return materials.size(); }
 
   /* ------------------------------------------------------------------------ */
   /* Boundaries (structural_mechanics_model_boundary.cc)                      */
   /* ------------------------------------------------------------------------ */
 public:
   /// Compute Linear load function set in global axis
   void computeForcesByGlobalTractionArray(const Array<Real> & traction_global,
                                           ElementType type);
 
   /// Compute Linear load function set in local axis
   void computeForcesByLocalTractionArray(const Array<Real> & tractions,
                                          ElementType type);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// time step
   Real time_step;
 
   /// conversion coefficient form force/mass to acceleration
   Real f_m2a;
 
   /// displacements array
   std::unique_ptr<Array<Real>> displacement_rotation;
 
   /// velocities array
   std::unique_ptr<Array<Real>> velocity;
 
   /// accelerations array
   std::unique_ptr<Array<Real>> acceleration;
 
   /// forces array
   std::unique_ptr<Array<Real>> internal_force;
 
   /// forces array
   std::unique_ptr<Array<Real>> external_force;
 
   /// lumped mass array
   std::unique_ptr<Array<Real>> mass;
 
   /// boundaries array
   std::unique_ptr<Array<bool>> blocked_dofs;
 
   /// stress array
   ElementTypeMapArray<Real> stress;
 
   ElementTypeMapArray<UInt> element_material;
 
   // Define sets of beams
   ElementTypeMapArray<UInt> set_ID;
 
   /// number of degre of freedom
   Int nb_degree_of_freedom;
 
   // Rotation matrix
   ElementTypeMapArray<Real> rotation_matrix;
 
   // /// analysis method check the list in akantu::AnalysisMethod
   // AnalysisMethod method;
 
   /// flag defining if the increment must be computed or not
   bool increment_flag;
 
   bool need_to_reassemble_mass{true};
   bool need_to_reassemble_stiffness{true};
 
   /* ------------------------------------------------------------------------ */
   std::vector<StructuralMaterial> materials;
   std::map<std::string, UInt> materials_names_to_id;
 };
 
 } // namespace akantu
 
 #include "structural_mechanics_model_inline_impl.hh"
 
 #endif /* AKANTU_STRUCTURAL_MECHANICS_MODEL_HH_ */
diff --git a/test/test_geometry/test_segment_intersection_triangle_3.cc b/test/test_geometry/test_segment_intersection_triangle_3.cc
index 0926f0730..786812933 100644
--- a/test/test_geometry/test_segment_intersection_triangle_3.cc
+++ b/test/test_geometry/test_segment_intersection_triangle_3.cc
@@ -1,137 +1,137 @@
 /**
  * @file   test_segment_intersection_triangle_3.cc
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Clement Roux <clement.roux@epfl.ch>
  *
  * @date creation: Fri Feb 27 2015
  * @date last modification:  Tue Mar 13 2018
  *
  * @brief  Tests the interface mesh generation
  *
  *
  * @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_common.hh"
 
 #include "geom_helper_functions.hh"
 #include "mesh_geom_common.hh"
 #include "mesh_segment_intersector.hh"
 #include "mesh_sphere_intersector.hh"
 
 #include <iostream>
 
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 typedef cgal::Cartesian K;
 typedef cgal::Spherical SK;
 
 /* -------------------------------------------------------------------------- */
 
 int main(int argc, char * argv[]) {
   initialize("", argc, argv);
   debug::setDebugLevel(dblError);
 
   Math::setTolerance(1e-10);
 
   Mesh mesh(2), interface_mesh(2, "interface_mesh");
   mesh.read("test_geometry_triangle.msh");
 
   MeshSegmentIntersector<2, _triangle_3> intersector(mesh, interface_mesh);
   intersector.constructData();
 
   // Testing a segment going out of the mesh
   K::Point_3 a(0, 0.25, 0), b(1, 0.25, 0), c(0.25, 0, 0), d(0.25, 1, 0);
 
   K::Segment_3 h_interface(a, b), v_interface(c, d);
 
   std::list<K::Segment_3> interface_list;
   interface_list.push_back(h_interface);
   interface_list.push_back(v_interface);
 
   intersector.computeIntersectionQueryList(interface_list);
 
   if (interface_mesh.getNbElement(_segment_2) != 4)
     return EXIT_FAILURE;
 
   Vector<Real> bary(2);
   Element test{_segment_2, 0, _not_ghost};
 
   interface_mesh.getBarycenter(test, bary);
   Real first_bary[] = {0.125, 0.25};
 
   if (!Math::are_vector_equal(2, bary.data(), first_bary))
     return EXIT_FAILURE;
 
   // Testing a segment completely inside an element
   K::Point_3 e(0.1, 0.33, 0), f(0.1, 0.67, 0);
   K::Segment_3 inside_segment(e, f);
   intersector.computeIntersectionQuery(inside_segment);
 
   test.element = interface_mesh.getNbElement(_segment_2) - 1;
   interface_mesh.getBarycenter(test, bary);
 
   Real second_bary[] = {0.1, 0.5};
 
   if (!Math::are_vector_equal(2, bary.data(), second_bary))
     return EXIT_FAILURE;
 
 #if 0
   // cgal::Spherical kernel testing the addition of nodes
   std::cout << "initial mesh size = " << mesh.getNodes().size() << " nodes" << std::endl;
 
   SK::Sphere_3 sphere(SK::Point_3(0, 1, 0), 0.2*0.2);
   SK::Sphere_3 sphere2(SK::Point_3(1, 0, 0), 0.4999999999);
   MeshSphereIntersector<2, _triangle_3> intersector_sphere(mesh);
   intersector_sphere.constructData();
 
   std::list<SK::Sphere_3> sphere_list;
   sphere_list.push_back(sphere);
   sphere_list.push_back(sphere2);
 
   intersector_sphere.computeIntersectionQueryList(sphere_list);
   std::cout << "final mesh size = " << mesh.getNodes().size() << std::endl;
 
-  const Array<UInt> new_node_triangle_3 = intersector_sphere.getNewNodePerElem();
+  const Array<Idx> new_node_triangle_3 = intersector_sphere.getNewNodePerElem();
   const Array<Real> & nodes = mesh.getNodes();
   std::cout << "New nodes :" << std::endl;
   std::cout << "node 5, x=" << nodes(4,0) << ", y=" << nodes(4,1) << std::endl;
   std::cout << "node 6, x=" << nodes(5,0) << ", y=" << nodes(5,1) << std::endl;
   std::cout << "node 7, x=" << nodes(6,0) << ", y=" << nodes(6,1) << std::endl;
 
   if ( (new_node_triangle_3(0,0) != 1) || (new_node_triangle_3(1,0) != 2)){
     for(UInt k=0; k != new_node_triangle_3.size(); ++k){
       std::cout << new_node_triangle_3(k,0) << " new nodes in element " << k << ", node(s): "
 		<< new_node_triangle_3(k,1) << ", " << new_node_triangle_3(k,3)
 		<< ", on segment(s):" << new_node_triangle_3(k,2) << ", "
 		<< new_node_triangle_3(k,4) << std::endl;
     }
     return EXIT_FAILURE;
   }
 #endif
 
   finalize();
   return EXIT_SUCCESS;
 }
diff --git a/test/test_io/test_dumper/test_dumper.cc b/test/test_io/test_dumper/test_dumper.cc
index 77c453dcb..2f27575a2 100644
--- a/test/test_io/test_dumper/test_dumper.cc
+++ b/test/test_io/test_dumper/test_dumper.cc
@@ -1,162 +1,163 @@
 /**
  * @file   test_dumper.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Tue May 21 2019
  *
  * @brief  test dumper
  *
  *
  * @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 "dumper_iohelper_paraview.hh"
 #include "dumper_nodal_field.hh"
 #include "dumper_text.hh"
 #include "dumper_variable.hh"
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
   initialize("input_file.dat", argc, argv);
 
-  UInt spatial_dimension = 3;
+  Int spatial_dimension = 3;
   Mesh mesh(spatial_dimension);
   mesh.read("test_dumper.msh");
 
   SolidMechanicsModel model(mesh);
   auto && mat_selector =
       std::make_shared<MeshDataMaterialSelector<std::string>>("physical_names",
                                                               model);
   model.setMaterialSelector(mat_selector);
 
   model.initFull();
   model.assembleInternalForces();
 
   Real time_step = 0.1;
 
   const Array<Real> & coord = mesh.getNodes();
   Array<Real> & disp = model.getDisplacement();
   Array<bool> & bound = model.getBlockedDOFs();
 
-  for (UInt n = 0; n < mesh.getNbNodes(); ++n) {
+  for (Int n = 0; n < mesh.getNbNodes(); ++n) {
     Real dist = 0.;
-    for (UInt d = 0; d < spatial_dimension; ++d) {
+    for (Int d = 0; d < spatial_dimension; ++d) {
       dist += coord(n, d) * coord(n, d);
     }
     dist = sqrt(dist);
 
-    for (UInt d = 0; d < spatial_dimension; ++d) {
+    for (Int d = 0; d < spatial_dimension; ++d) {
       disp(n, d) = (d + 1) * dist;
       bound(n, d) = bool((n % 2) + d);
     }
   }
 
   // dump boundary bottom as reference
   model.setGroupDirectory("paraview", "Bottom");
   model.setGroupBaseName("paraview_bottom", "Bottom");
   model.addDumpGroupField("displacement", "Bottom");
   model.addDumpGroupField("blocked_dofs", "Bottom");
 
-  UInt nbp = 3;
+  Int nbp = 3;
   DumperParaview prvdumper("paraview_bottom_parallel", "paraview", false);
   iohelper::Dumper & prvdpr = prvdumper.getDumper();
-  for (UInt p = 0; p < nbp; ++p) {
+  for (Int p = 0; p < nbp; ++p) {
     prvdpr.setParallelContext(p, nbp, 0);
     if (p != 0) {
       prvdumper.unRegisterField("connectivities");
       prvdumper.unRegisterField("element_type");
       prvdumper.unRegisterField("positions");
       prvdumper.unRegisterField("displacement");
     }
     prvdumper.registerFilteredMesh(
         mesh, mesh.getElementGroup("Bottom").getElements(),
         mesh.getElementGroup("Bottom").getNodeGroup().getNodes());
     prvdumper.registerField(
         "displacement",
         std::make_shared<dumpers::NodalField<Real, true>>(
             model.getDisplacement(), 0, 0,
             &(mesh.getElementGroup("Bottom").getNodeGroup().getNodes())));
     prvdumper.dump(0);
   }
 
   DumperText txtdumper("text_bottom", iohelper::_tdm_csv);
   txtdumper.setDirectory("paraview");
   txtdumper.setPrecision(8);
   txtdumper.setTimeStep(time_step);
   txtdumper.registerFilteredMesh(
       mesh, mesh.getElementGroup("Bottom").getElements(),
       mesh.getElementGroup("Bottom").getNodeGroup().getNodes());
   txtdumper.registerField(
       "displacement",
       std::make_shared<dumpers::NodalField<Real, true>>(
           model.getDisplacement(), 0, 0,
           &(mesh.getElementGroup("Bottom").getNodeGroup().getNodes())));
   txtdumper.registerField(
       "blocked_dofs",
       std::make_shared<dumpers::NodalField<bool, true>>(
           model.getBlockedDOFs(), 0, 0,
           &(mesh.getElementGroup("Bottom").getNodeGroup().getNodes())));
 
   Real pot_energy = 1.2345567891;
-  Vector<Real> gforces(2, 1.);
+  Vector<Real> gforces(2);
+  gforces.fill(1.);
   txtdumper.registerVariable(
       "potential_energy",
       std::make_shared<dumpers::Variable<Real>>(pot_energy));
   txtdumper.registerVariable(
       "global_forces",
       std::make_shared<dumpers::Variable<Vector<Real>>>(gforces));
 
   // dump a first time before the main loop
   model.dumpGroup("Bottom");
   txtdumper.dump();
 
   Real time = 0.;
-  for (UInt i = 1; i < 5; ++i) {
+  for (Int i = 1; i < 5; ++i) {
     pot_energy += 2.;
     gforces(0) += 0.1;
     gforces(1) += 0.2;
 
     // pre -> cor
 
     // increment time after all steps of integration
     time += time_step;
 
     // dump after time increment
     if (i % 2 == 0) {
       txtdumper.dump(time, i);
       model.dumpGroup("Bottom");
 
       // parallel test
-      for (UInt p = 0; p < nbp; ++p) {
+      for (Int p = 0; p < nbp; ++p) {
         prvdpr.setParallelContext(p, nbp, 0);
         prvdumper.dump(i);
       }
     }
   }
 
   finalize();
   return EXIT_SUCCESS;
 }
diff --git a/test/test_io/test_parser/test_parser.cc b/test/test_io/test_parser/test_parser.cc
index 87f03b77f..95ec38a80 100644
--- a/test/test_io/test_parser/test_parser.cc
+++ b/test/test_io/test_parser/test_parser.cc
@@ -1,76 +1,76 @@
 /**
  * @file   test_parser.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Sun Jul 09 2017
  *
  * @brief  test the input file parser
  *
  *
  * @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_random_generator.hh"
 #include "parser.hh"
 
 #include <iostream>
 
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
   initialize("input_file.dat", argc, argv);
 
   const Parser & p = getStaticParser();
 
-  std::cout << RandomGenerator<UInt>::seed() << "==123456" << std::endl;
+  std::cout << RandomGenerator<Int>::seed() << "==123456" << std::endl;
 
   std::cout << p << std::endl;
 
   Real toto = p.getParameter("toto");
   std::cout << toto;
   Real ref = 2 * M_PI + std::max(2., 50.);
   if (std::abs(toto - ref) > std::numeric_limits<Real>::epsilon()) {
     std::cout << "!=" << ref << std::endl;
     return 1;
   }
 
   std::cout << "==" << ref << std::endl;
 
   Vector<Real> vect = p.getParameter("vect");
   std::cout << vect << std::endl;
 
   Matrix<Real> mat = p.getParameter("mat");
   std::cout << mat << std::endl;
 
   RandomParameter<Real> rand1 = p.getParameter("rand1");
   std::cout << rand1 << std::endl;
 
   RandomParameter<Real> rand2 = p.getParameter("rand2");
   std::cout << rand2 << std::endl;
 
   RandomParameter<Real> rand3 = p.getParameter("rand3");
   std::cout << rand3 << std::endl;
 
   finalize();
   return 0;
 }
diff --git a/test/test_model/test_common/test_model_solver/test_model_solver.cc b/test/test_model/test_common/test_model_solver/test_model_solver.cc
index ec99168ea..8b6be5b40 100644
--- a/test/test_model/test_common/test_model_solver/test_model_solver.cc
+++ b/test/test_model/test_common/test_model_solver/test_model_solver.cc
@@ -1,178 +1,178 @@
 /**
  * @file   test_model_solver.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Apr 13 2016
  * @date last modification:  Tue Apr 23 2019
  *
  * @brief  Test default dof manager
  *
  *
  * @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 "aka_random_generator.hh"
 #include "dof_manager.hh"
 #include "dof_synchronizer.hh"
 #include "mesh.hh"
 #include "mesh_accessor.hh"
 #include "model_solver.hh"
 #include "non_linear_solver.hh"
 #include "sparse_matrix.hh"
 
 /* -------------------------------------------------------------------------- */
 #include "test_model_solver_my_model.hh"
 /* -------------------------------------------------------------------------- */
 #include <cmath>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 static void genMesh(Mesh & mesh, UInt nb_nodes);
 static void printResults(MyModel & model, UInt nb_nodes);
 
 Real F = -10;
 
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   initialize(argc, argv);
 
   UInt prank = Communicator::getStaticCommunicator().whoAmI();
 
   std::cout << std::setprecision(7);
 
   ID dof_manager_type = "default";
 #if defined(DOF_MANAGER_TYPE)
   dof_manager_type = DOF_MANAGER_TYPE;
 #endif
 
   UInt global_nb_nodes = 100;
   Mesh mesh(1);
 
-  RandomGenerator<UInt>::seed(1);
+  RandomGenerator<Idx>::seed(1);
 
   if (prank == 0) {
     genMesh(mesh, global_nb_nodes);
   }
 
   // std::cout << prank << RandGenerator<Real>::seed() << std::endl;
   mesh.distribute();
 
   MyModel model(F, mesh, false, dof_manager_type);
 
   model.getNewSolver("static", TimeStepSolverType::_static,
                      NonLinearSolverType::_newton_raphson);
   model.setIntegrationScheme("static", "disp",
                              IntegrationSchemeType::_pseudo_time);
 
   NonLinearSolver & solver = model.getDOFManager().getNonLinearSolver("static");
   solver.set("max_iterations", 2);
 
   model.solveStep();
 
   printResults(model, global_nb_nodes);
 
   finalize();
   return EXIT_SUCCESS;
 }
 
 /* -------------------------------------------------------------------------- */
 void genMesh(Mesh & mesh, UInt nb_nodes) {
   MeshAccessor mesh_accessor(mesh);
   auto & nodes = mesh_accessor.getNodes();
   auto & conn = mesh_accessor.getConnectivity(_segment_2);
 
   nodes.resize(nb_nodes);
   mesh_accessor.setNbGlobalNodes(nb_nodes);
 
   for (UInt n = 0; n < nb_nodes; ++n) {
     nodes(n, _x) = n * (1. / (nb_nodes - 1));
   }
 
   conn.resize(nb_nodes - 1);
   for (UInt n = 0; n < nb_nodes - 1; ++n) {
     conn(n, 0) = n;
     conn(n, 1) = n + 1;
   }
   mesh_accessor.makeReady();
 }
 
 /* -------------------------------------------------------------------------- */
 void printResults(MyModel & model, UInt /*nb_nodes*/) {
   // if (model.mesh.isDistributed()) {
   //   UInt prank = model.mesh.getCommunicator().whoAmI();
   //   auto & sync = dynamic_cast<DOFManagerDefault &>(model.getDOFManager())
   //       .getSynchronizer();
 
   //   if (prank == 0) {
   //     Array<Real> global_displacement(nb_nodes);
   //     Array<Real> global_forces(nb_nodes);
   //     Array<bool> global_blocked(nb_nodes);
 
   //     sync.gather(model.forces, global_forces);
   //     sync.gather(model.displacement, global_displacement);
   //     sync.gather(model.blocked, global_blocked);
 
   //     auto force_it = global_forces.begin();
   //     auto disp_it = global_displacement.begin();
   //     auto blocked_it = global_blocked.begin();
 
   //     std::cout << "node"
   //               << ", " << std::setw(8) << "disp"
   //               << ", " << std::setw(8) << "force"
   //               << ", " << std::setw(8) << "blocked" << std::endl;
 
   //     UInt node = 0;
   //     for (; disp_it != global_displacement.end();
   //          ++disp_it, ++force_it, ++blocked_it, ++node) {
   //       std::cout << node << ", " << std::setw(8) << *disp_it << ", "
   //                 << std::setw(8) << *force_it << ", " << std::setw(8)
   //                 << *blocked_it << std::endl;
 
   //       std::cout << std::flush;
   //     }
   //   } else {
   //     sync.gather(model.forces);
   //     sync.gather(model.displacement);
   //     sync.gather(model.blocked);
   //   }
   // } else {
   auto force_it = model.forces.begin();
   auto disp_it = model.displacement.begin();
   auto blocked_it = model.blocked.begin();
 
   std::cout << "node"
             << ", " << std::setw(8) << "disp"
             << ", " << std::setw(8) << "force"
             << ", " << std::setw(8) << "blocked" << std::endl;
 
   UInt node = 0;
   for (; disp_it != model.displacement.end();
        ++disp_it, ++force_it, ++blocked_it, ++node) {
     std::cout << node << ", " << std::setw(8) << *disp_it << ", "
               << std::setw(8) << *force_it << ", " << std::setw(8)
               << *blocked_it << std::endl;
 
     std::cout << std::flush;
   }
   //  }
 }
diff --git a/test/test_model/test_phase_field_model/test_phase_solid_coupling.cc b/test/test_model/test_phase_field_model/test_phase_solid_coupling.cc
index 144ae7701..898c23c3d 100644
--- a/test/test_model/test_phase_field_model/test_phase_solid_coupling.cc
+++ b/test/test_model/test_phase_field_model/test_phase_solid_coupling.cc
@@ -1,270 +1,273 @@
 /**
  * @file   test_phase_solid_coupling.cc
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  *
  * @date creation: Sun Jan 06 2019
  * @date last modification: Wed Mar 03 2021
  *
  * @brief  test of the class PhaseFieldModel on the 2d square
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "material.hh"
 #include "material_phasefield.hh"
 #include "non_linear_solver.hh"
 #include "phase_field_model.hh"
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 #include <iostream>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
-const UInt spatial_dimension = 2;
+const Int spatial_dimension = 2;
 
 /* -------------------------------------------------------------------------- */
 void applyDisplacement(SolidMechanicsModel &, Real &);
 void computeStrainOnQuadPoints(SolidMechanicsModel &, PhaseFieldModel &,
                                GhostType);
 void computeDamageOnQuadPoints(SolidMechanicsModel &, PhaseFieldModel &,
                                GhostType);
 void gradUToEpsilon(const Matrix<Real> &, Matrix<Real> &);
 /* -------------------------------------------------------------------------- */
 
 int main(int argc, char * argv[]) {
 
   std::ofstream os("data.csv");
   os << "#strain stress damage analytical_sigma analytical_damage" << std::endl;
 
   initialize("material_coupling.dat", argc, argv);
 
   Mesh mesh(spatial_dimension);
   mesh.read("test_one_element.msh");
 
   SolidMechanicsModel model(mesh);
   model.initFull(_analysis_method = _static);
 
   PhaseFieldModel phase(mesh);
   auto && selector = std::make_shared<MeshDataPhaseFieldSelector<std::string>>(
       "physical_names", phase);
   phase.setPhaseFieldSelector(selector);
   phase.initFull(_analysis_method = _static);
 
   model.setBaseName("phase_solid");
   model.addDumpField("stress");
   model.addDumpField("grad_u");
   model.addDumpFieldVector("displacement");
   model.addDumpField("damage");
   model.dump();
 
   UInt nbSteps = 1000;
   Real increment = 1e-4;
 
   auto & stress = model.getMaterial(0).getArray<Real>("stress", _quadrangle_4);
   auto & damage = model.getMaterial(0).getArray<Real>("damage", _quadrangle_4);
 
   Real analytical_damage{0.};
   Real analytical_sigma{0.};
 
   auto & phasefield = phase.getPhaseField(0);
 
   const Real E = phasefield.getParam("E");
   const Real nu = phasefield.getParam("nu");
   Real c22 = E * (1 - nu) / ((1 + nu) * (1 - 2 * nu));
 
   const Real gc = phasefield.getParam("gc");
   const Real l0 = phasefield.getParam("l0");
 
   Real error_stress{0.};
 
   Real error_damage{0.};
 
   for (UInt s = 0; s < nbSteps; ++s) {
     Real axial_strain = increment * s;
     applyDisplacement(model, axial_strain);
 
     model.solveStep();
     computeStrainOnQuadPoints(model, phase, _not_ghost);
 
     phase.solveStep();
     computeDamageOnQuadPoints(model, phase, _not_ghost);
 
     model.assembleInternalForces();
 
     analytical_damage = axial_strain * axial_strain * c22 /
                         (gc / l0 + axial_strain * axial_strain * c22);
     analytical_sigma =
         c22 * axial_strain * (1 - analytical_damage) * (1 - analytical_damage);
 
     error_stress = std::abs(analytical_sigma - stress(0, 3)) / analytical_sigma;
 
     error_damage = std::abs(analytical_damage - damage(0)) / analytical_damage;
 
     if (error_damage > 1e-8 and error_stress > 1e-8) {
       return EXIT_FAILURE;
     }
 
     os << axial_strain << " " << stress(0, 3) << " " << damage(0) << " "
        << analytical_sigma << " " << analytical_damage << " " << error_stress
        << " " << error_damage << std::endl;
 
     model.dump();
   }
 
   os.close();
   finalize();
 
   return EXIT_SUCCESS;
 }
 
 /* -------------------------------------------------------------------------- */
 void applyDisplacement(SolidMechanicsModel & model, Real & increment) {
   auto & displacement = model.getDisplacement();
 
   auto & positions = model.getMesh().getNodes();
   auto & blocked_dofs = model.getBlockedDOFs();
 
   for (UInt n = 0; n < model.getMesh().getNbNodes(); ++n) {
     if (positions(n, 1) == -0.5) {
       displacement(n, 0) = 0;
       displacement(n, 1) = 0;
       blocked_dofs(n, 0) = true;
       blocked_dofs(n, 1) = true;
     } else {
       displacement(n, 0) = 0;
       displacement(n, 1) = increment;
       blocked_dofs(n, 0) = true;
       blocked_dofs(n, 1) = true;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void computeStrainOnQuadPoints(SolidMechanicsModel & solid,
                                PhaseFieldModel & phase, GhostType ghost_type) {
 
   auto & mesh = solid.getMesh();
 
   auto nb_materials = solid.getNbMaterials();
   auto nb_phasefields = phase.getNbPhaseFields();
 
   AKANTU_DEBUG_ASSERT(
       nb_phasefields == nb_materials,
       "The number of phasefields and materials should be equal");
 
   for (auto index : arange(nb_materials)) {
     auto & material = solid.getMaterial(index);
 
     for (auto index2 : arange(nb_phasefields)) {
       auto & phasefield = phase.getPhaseField(index2);
 
       if (phasefield.getName() == material.getName()) {
 
         auto & strain_on_qpoints = phasefield.getStrain();
         auto & gradu_on_qpoints = material.getGradU();
 
-        for (auto & type : mesh.elementTypes(spatial_dimension, ghost_type)) {
+        for (const auto & type :
+             mesh.elementTypes(spatial_dimension, ghost_type)) {
           auto & strain_on_qpoints_vect = strain_on_qpoints(type, ghost_type);
           auto & gradu_on_qpoints_vect = gradu_on_qpoints(type, ghost_type);
           for (auto && values :
                zip(make_view(strain_on_qpoints_vect, spatial_dimension,
                              spatial_dimension),
                    make_view(gradu_on_qpoints_vect, spatial_dimension,
                              spatial_dimension))) {
             auto & strain = std::get<0>(values);
             auto & grad_u = std::get<1>(values);
-            gradUToEpsilon(grad_u, strain);
+            Material::gradUToEpsilon<spatial_dimension>(grad_u, strain);
           }
         }
 
         break;
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void computeDamageOnQuadPoints(SolidMechanicsModel & solid,
                                PhaseFieldModel & phase, GhostType ghost_type) {
 
   auto & fem = phase.getFEEngine();
   auto & mesh = phase.getMesh();
 
   auto nb_materials = solid.getNbMaterials();
   auto nb_phasefields = phase.getNbPhaseFields();
 
   AKANTU_DEBUG_ASSERT(
       nb_phasefields == nb_materials,
       "The number of phasefields and materials should be equal");
 
   for (auto index : arange(nb_materials)) {
     auto & material = solid.getMaterial(index);
 
     for (auto index2 : arange(nb_phasefields)) {
       auto & phasefield = phase.getPhaseField(index2);
 
       if (phasefield.getName() == material.getName()) {
 
         switch (spatial_dimension) {
         case 1: {
-          auto & mat = static_cast<MaterialPhaseField<1> &>(material);
+          auto & mat = dynamic_cast<MaterialPhaseField<1> &>(material);
           auto & solid_damage = mat.getDamage();
 
-          for (auto & type : mesh.elementTypes(spatial_dimension, ghost_type)) {
+          for (const auto & type :
+               mesh.elementTypes(spatial_dimension, ghost_type)) {
             auto & damage_on_qpoints_vect = solid_damage(type, ghost_type);
 
             fem.interpolateOnIntegrationPoints(
                 phase.getDamage(), damage_on_qpoints_vect, 1, type, ghost_type);
           }
 
           break;
         }
         case 2: {
-          auto & mat = static_cast<MaterialPhaseField<2> &>(material);
+          auto & mat = dynamic_cast<MaterialPhaseField<2> &>(material);
           auto & solid_damage = mat.getDamage();
 
-          for (auto & type : mesh.elementTypes(spatial_dimension, ghost_type)) {
+          for (const auto & type :
+               mesh.elementTypes(spatial_dimension, ghost_type)) {
             auto & damage_on_qpoints_vect = solid_damage(type, ghost_type);
 
             fem.interpolateOnIntegrationPoints(
                 phase.getDamage(), damage_on_qpoints_vect, 1, type, ghost_type);
           }
           break;
         }
         default:
           break;
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void gradUToEpsilon(const Matrix<Real> & grad_u, Matrix<Real> & epsilon) {
   for (UInt i = 0; i < spatial_dimension; ++i) {
     for (UInt j = 0; j < spatial_dimension; ++j)
       epsilon(i, j) = 0.5 * (grad_u(i, j) + grad_u(j, i));
   }
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_fixture.hh b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_fixture.hh
index 80363caf4..250d4716f 100644
--- a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_fixture.hh
+++ b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_fixture.hh
@@ -1,347 +1,347 @@
 /**
  * @file   test_cohesive_fixture.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Jan 10 2018
  * @date last modification:  Wed Nov 18 2020
  *
  * @brief  Coehsive element test fixture
  *
  *
  * @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 "communicator.hh"
 #include "solid_mechanics_model_cohesive.hh"
 #include "test_gtest_utils.hh"
 /* -------------------------------------------------------------------------- */
 #include <gtest/gtest.h>
 #include <vector>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_TEST_COHESIVE_FIXTURE_HH_
 #define AKANTU_TEST_COHESIVE_FIXTURE_HH_
 
 using namespace akantu;
 
 template <::akantu::AnalysisMethod t>
 using analysis_method_t = std::integral_constant<::akantu::AnalysisMethod, t>;
 
 class StrainIncrement : public BC::Functor {
 public:
   StrainIncrement(const Matrix<Real> & strain, BC::Axis dir)
       : strain_inc(strain), dir(dir) {}
 
   void operator()(UInt /*node*/, Vector<bool> & flags, Vector<Real> & primal,
                   const Vector<Real> & coord) const {
     if (std::abs(coord(dir)) < 1e-8) {
       return;
     }
 
     flags.set(true);
     primal += strain_inc * coord;
   }
 
   static const BC::Functor::Type type = BC::Functor::_dirichlet;
 
 private:
   Matrix<Real> strain_inc;
   BC::Axis dir;
 };
 
 template <typename param_> class TestSMMCFixture : public ::testing::Test {
 public:
   static constexpr ElementType cohesive_type =
       std::tuple_element_t<0, param_>::value;
   static constexpr ElementType type_1 = std::tuple_element_t<1, param_>::value;
   static constexpr ElementType type_2 = std::tuple_element_t<2, param_>::value;
 
   static constexpr size_t dim =
       ElementClass<cohesive_type>::getSpatialDimension();
 
   void SetUp() {
     mesh = std::make_unique<Mesh>(this->dim);
     if (Communicator::getStaticCommunicator().whoAmI() == 0) {
       mesh->read(this->mesh_name);
     }
     mesh->distribute();
   }
 
   void TearDown() {
     model.reset(nullptr);
     mesh.reset(nullptr);
   }
 
   void createModel() {
     model = std::make_unique<SolidMechanicsModelCohesive>(*mesh);
     model->initFull(_analysis_method = this->analysis_method,
                     _is_extrinsic = this->is_extrinsic);
 
     auto time_step = this->model->getStableTimeStep() * 0.01;
     this->model->setTimeStep(time_step);
 
     if (dim == 1) {
       surface = 1;
       group_size = 1;
       return;
     }
 
     auto facet_type = mesh->getFacetType(this->cohesive_type);
 
     auto & fe_engine = model->getFEEngineBoundary();
     const auto & group = mesh->getElementGroup("insertion");
     group_size = group.size(_ghost_type = _not_ghost);
     const auto & elements = group.getElements(facet_type);
     Array<Real> ones(fe_engine.getNbIntegrationPoints(facet_type) * group_size);
     ones.set(1.);
 
     surface = fe_engine.integrate(ones, facet_type, _not_ghost, elements);
     mesh->getCommunicator().allReduce(surface, SynchronizerOperation::_sum);
 
     mesh->getCommunicator().allReduce(group_size, SynchronizerOperation::_sum);
 
 #define debug_ 0
 
 #if debug_
     this->model->addDumpFieldVector("displacement");
     this->model->addDumpFieldVector("velocity");
     this->model->addDumpFieldVector("internal_force");
     this->model->addDumpFieldVector("external_force");
     this->model->addDumpField("blocked_dofs");
     this->model->addDumpField("stress");
     this->model->addDumpField("strain");
     this->model->assembleInternalForces();
     this->model->setBaseNameToDumper("cohesive elements", "cohesive_elements");
     this->model->addDumpFieldVectorToDumper("cohesive elements",
                                             "displacement");
     this->model->addDumpFieldToDumper("cohesive elements", "damage");
     this->model->addDumpFieldToDumper("cohesive elements", "tractions");
     this->model->addDumpFieldToDumper("cohesive elements", "opening");
     this->model->dump();
     this->model->dump("cohesive elements");
 #endif
   }
 
   void setInitialCondition(const Matrix<Real> & strain) {
     for (auto && data :
          zip(make_view(this->mesh->getNodes(), this->dim),
              make_view(this->model->getDisplacement(), this->dim))) {
       const auto & pos = std::get<0>(data);
       auto & disp = std::get<1>(data);
       disp = strain * pos;
     }
   }
 
   bool checkDamaged() {
     UInt nb_damaged = 0;
     auto & damage =
         model->getMaterial("insertion").getArray<Real>("damage", cohesive_type);
     for (auto d : damage) {
       if (d >= .99) {
         ++nb_damaged;
       }
     }
 
     return (nb_damaged == group_size);
   }
 
   void steps(const Matrix<Real> & strain) {
     StrainIncrement functor((1. / 300) * strain, this->dim == 1 ? _x : _y);
 
     for (auto _ [[gnu::unused]] : arange(nb_steps)) {
       this->model->applyBC(functor, "loading");
       this->model->applyBC(functor, "fixed");
       if (this->is_extrinsic) {
         this->model->checkCohesiveStress();
       }
 
       this->model->solveStep();
 #if debug_
       this->model->dump();
       this->model->dump("cohesive elements");
 #endif
     }
   }
 
   void checkInsertion() {
     auto nb_cohesive_element = this->mesh->getNbElement(cohesive_type);
     mesh->getCommunicator().allReduce(nb_cohesive_element,
                                       SynchronizerOperation::_sum);
 
     EXPECT_EQ(nb_cohesive_element, group_size);
   }
 
   void checkDissipated(Real expected_density) {
     Real edis = this->model->getEnergy("dissipated");
 
     EXPECT_NEAR(this->surface * expected_density, edis, 5e-1);
   }
 
   void testModeI() {
     this->createModel();
 
     auto & mat_el = this->model->getMaterial("body");
 
     auto speed = mat_el.getPushWaveSpeed(Element());
     auto direction = _y;
     if (dim == 1) {
       direction = _x;
     }
     auto length =
         mesh->getUpperBounds()(direction) - mesh->getLowerBounds()(direction);
     nb_steps = length / speed / model->getTimeStep();
 
     SCOPED_TRACE(std::to_string(this->dim) + "D - " + std::to_string(type_1) +
                  ":" + std::to_string(type_2));
 
     auto & mat_co = this->model->getMaterial("insertion");
     Real sigma_c = mat_co.get("sigma_c");
 
     Real E = mat_el.get("E");
     Real nu = mat_el.get("nu");
 
     Matrix<Real> strain;
     if (dim == 1) {
-      strain = {{1.}};
+      strain = Matrix<Real>{{1.}};
     } else if (dim == 2) {
-      strain = {{-nu, 0.}, {0., 1. - nu}};
+      strain = Matrix<Real>{{-nu, 0.}, {0., 1. - nu}};
       strain *= (1. + nu);
     } else if (dim == 3) {
-      strain = {{-nu, 0., 0.}, {0., 1., 0.}, {0., 0., -nu}};
+      strain = Matrix<Real>{{-nu, 0., 0.}, {0., 1., 0.}, {0., 0., -nu}};
     }
 
     strain *= sigma_c / E;
 
     this->setInitialCondition((1 - 1e-5) * strain);
     this->steps(2e-2 * strain);
   }
 
   void testModeII() {
     this->createModel();
     auto & mat_el = this->model->getMaterial("body");
     Real speed;
     try {
       speed =
           mat_el.getShearWaveSpeed(Element()); // the slowest speed if exists
     } catch (...) {
       speed = mat_el.getPushWaveSpeed(Element());
     }
 
     auto direction = _y;
     if (dim == 1)
       direction = _x;
     auto length =
         mesh->getUpperBounds()(direction) - mesh->getLowerBounds()(direction);
     nb_steps = 2 * length / 2. / speed / model->getTimeStep();
 
     SCOPED_TRACE(std::to_string(this->dim) + "D - " + std::to_string(type_1) +
                  ":" + std::to_string(type_2));
 
     if (this->dim > 1)
       this->model->applyBC(BC::Dirichlet::FlagOnly(_y), "sides");
     if (this->dim > 2)
       this->model->applyBC(BC::Dirichlet::FlagOnly(_z), "sides");
 
     auto & mat_co = this->model->getMaterial("insertion");
     Real sigma_c = mat_co.get("sigma_c");
     Real beta = mat_co.get("beta");
     // Real G_c = mat_co.get("G_c");
 
     Real E = mat_el.get("E");
     Real nu = mat_el.get("nu");
 
     Matrix<Real> strain;
     if (dim == 1) {
-      strain = {{1.}};
+      strain = Matrix<Real>{{1.}};
     } else if (dim == 2) {
-      strain = {{0., 1.}, {0., 0.}};
+      strain = Matrix<Real>{{0., 1.}, {0., 0.}};
       strain *= (1. + nu);
     } else if (dim == 3) {
-      strain = {{0., 1., 0.}, {0., 0., 0.}, {0., 0., 0.}};
+      strain = Matrix<Real>{{0., 1., 0.}, {0., 0., 0.}, {0., 0., 0.}};
       strain *= (1. + nu);
     }
     strain *= 2 * beta * beta * sigma_c / E;
 
     // nb_steps *= 5;
 
     this->setInitialCondition((1. - 1e-5) * strain);
     this->steps(0.005 * strain);
   }
 
 protected:
   std::unique_ptr<Mesh> mesh;
   std::unique_ptr<SolidMechanicsModelCohesive> model;
 
   std::string mesh_name{std::to_string(cohesive_type) + std::to_string(type_1) +
                         (type_1 == type_2 ? "" : std::to_string(type_2)) +
                         ".msh"};
 
   bool is_extrinsic;
   AnalysisMethod analysis_method;
 
   Real surface{0};
   UInt nb_steps{1000};
   UInt group_size{10000};
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename param_>
 constexpr ElementType TestSMMCFixture<param_>::cohesive_type;
 template <typename param_>
 constexpr ElementType TestSMMCFixture<param_>::type_1;
 template <typename param_>
 constexpr ElementType TestSMMCFixture<param_>::type_2;
 
 template <typename param_> constexpr size_t TestSMMCFixture<param_>::dim;
 /* -------------------------------------------------------------------------- */
 
 using IsExtrinsicTypes = std::tuple<std::true_type, std::false_type>;
 using AnalysisMethodTypes =
     std::tuple<analysis_method_t<_explicit_lumped_mass>>;
 
 using coh_types = gtest_list_t<std::tuple<
     std::tuple<_element_type_cohesive_1d_2, _element_type_segment_2,
                _element_type_segment_2>,
     std::tuple<_element_type_cohesive_2d_4, _element_type_triangle_3,
                _element_type_triangle_3>,
     std::tuple<_element_type_cohesive_2d_4, _element_type_quadrangle_4,
                _element_type_quadrangle_4>,
     std::tuple<_element_type_cohesive_2d_4, _element_type_triangle_3,
                _element_type_quadrangle_4>,
     std::tuple<_element_type_cohesive_2d_6, _element_type_triangle_6,
                _element_type_triangle_6>,
     std::tuple<_element_type_cohesive_2d_6, _element_type_quadrangle_8,
                _element_type_quadrangle_8>,
     std::tuple<_element_type_cohesive_2d_6, _element_type_triangle_6,
                _element_type_quadrangle_8>,
     std::tuple<_element_type_cohesive_3d_6, _element_type_tetrahedron_4,
                _element_type_tetrahedron_4>,
     std::tuple<_element_type_cohesive_3d_12, _element_type_tetrahedron_10,
                _element_type_tetrahedron_10> /*,
     std::tuple<_element_type_cohesive_3d_8, _element_type_hexahedron_8,
                _element_type_hexahedron_8>,
     std::tuple<_element_type_cohesive_3d_16, _element_type_hexahedron_20,
                _element_type_hexahedron_20>*/>>;
 
 TYPED_TEST_SUITE(TestSMMCFixture, coh_types, );
 
 #endif /* AKANTU_TEST_COHESIVE_FIXTURE_HH_ */
diff --git a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_insertion/test_cohesive_insertion_along_physical_surfaces.cc b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_insertion/test_cohesive_insertion_along_physical_surfaces.cc
index 4b5b16f85..8873aac7e 100644
--- a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_insertion/test_cohesive_insertion_along_physical_surfaces.cc
+++ b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_insertion/test_cohesive_insertion_along_physical_surfaces.cc
@@ -1,95 +1,95 @@
 /**
  * @file   test_cohesive_insertion_along_physical_surfaces.cc
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Aug 07 2015
  * @date last modification:  Thu Oct 29 2020
  *
  * @brief  Test intrinsic insertion of cohesive elements along physical surfaces
  *
  *
  * @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_common.hh"
 #include "material.hh"
 #include "material_cohesive.hh"
 #include "mesh.hh"
 #include "mesh_io.hh"
 #include "mesh_io_msh.hh"
 #include "mesh_utils.hh"
 #include "solid_mechanics_model_cohesive.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 #include <iostream>
 #include <limits>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
 
   initialize("input_file.dat", argc, argv);
 
   Math::setTolerance(1e-15);
 
   const UInt spatial_dimension = 3;
 
   Mesh mesh(spatial_dimension);
 
   mesh.read("3d_spherical_inclusion.msh");
 
   SolidMechanicsModelCohesive model(mesh);
 
   auto && material_selector =
       std::make_shared<MeshDataMaterialCohesiveSelector>(model);
   material_selector->setFallback(model.getMaterialSelector());
   model.setMaterialSelector(material_selector);
 
   model.initFull();
 
   std::vector<std::string> surfaces_name = {"interface", "coh1", "coh2",
                                             "coh3",      "coh4", "coh5"};
-  UInt nb_surf = surfaces_name.size();
+  Int nb_surf = surfaces_name.size();
 
-  for (auto & type :
+  for (const auto & type :
        mesh.elementTypes(spatial_dimension, _not_ghost, _ek_cohesive)) {
-    for (UInt i = 0; i < nb_surf; ++i) {
+    for (Int i = 0; i < nb_surf; ++i) {
 
-      UInt expected_insertion = mesh.getElementGroup(surfaces_name[i])
+      auto expected_insertion = mesh.getElementGroup(surfaces_name[i])
                                     .getElements(mesh.getFacetType(type))
                                     .size();
-      UInt inserted_elements =
+      auto inserted_elements =
           model.getMaterial(surfaces_name[i]).getElementFilter()(type).size();
       if (not(expected_insertion == inserted_elements)) {
         std::cout << "!!! Mismatch in insertion of surface named "
                   << surfaces_name[i] << " --> " << inserted_elements
                   << " inserted elements out of " << expected_insertion
                   << std::endl;
         return 1;
       }
     }
   }
 
   return 0;
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_cohesive/test_materials/test_material_cohesive_fixture.hh b/test/test_model/test_solid_mechanics_model/test_cohesive/test_materials/test_material_cohesive_fixture.hh
index 915aef080..e9a032d1c 100644
--- a/test/test_model/test_solid_mechanics_model/test_cohesive/test_materials/test_material_cohesive_fixture.hh
+++ b/test/test_model/test_solid_mechanics_model/test_cohesive/test_materials/test_material_cohesive_fixture.hh
@@ -1,314 +1,314 @@
 /**
  * @file   test_material_cohesive_fixture.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Feb 21 2018
  * @date last modification:  Sun Dec 30 2018
  *
  * @brief  Test the traction separations laws for cohesive elements
  *
  *
  * @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 "solid_mechanics_model_cohesive.hh"
 /* -------------------------------------------------------------------------- */
 #include "test_gtest_utils.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 #include <gtest/gtest.h>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 //#define debug_
 
 /* -------------------------------------------------------------------------- */
 template <template <UInt> class Mat, typename dim_>
 class TestMaterialCohesiveFixture : public ::testing::Test {
 public:
   static constexpr UInt dim = dim_::value;
   using Material = Mat<dim>;
 
   void SetUp() override {
     mesh = std::make_unique<Mesh>(dim);
     model = std::make_unique<SolidMechanicsModelCohesive>(*mesh);
     material = std::make_unique<Material>(*model);
 
     material->SetUps();
     openings = std::make_unique<Array<Real>>(0, dim);
     tractions = std::make_unique<Array<Real>>(0, dim);
     reset();
 
     gen.seed(::testing::GTEST_FLAG(random_seed));
 
     normal = getRandomNormal();
     tangents = getRandomTangents();
   }
 
   void TearDown() override {
     material.reset(nullptr);
     model.reset(nullptr);
     mesh.reset(nullptr);
 
     openings.reset(nullptr);
     tractions.reset(nullptr);
   }
 
   void reset() {
     openings->resize(1);
     tractions->resize(1);
 
     openings->zero();
     tractions->zero();
   }
 
   /* ------------------------------------------------------------------------ */
   void addOpening(const Vector<Real> & direction, Real start, Real stop,
                   UInt nb_steps) {
     for (auto s : arange(nb_steps)) {
       auto opening =
           direction * (start + (stop - start) / Real(nb_steps) * Real(s + 1));
       openings->push_back(opening);
     }
     tractions->resize(openings->size());
   }
 
   /* ------------------------------------------------------------------------ */
   Vector<Real> getRandomVector() {
     std::uniform_real_distribution<Real> dis;
     Vector<Real> vector(dim);
     for (auto s : arange(dim))
       vector(s) = dis(gen);
     return vector;
   }
 
   Vector<Real> getRandomNormal() {
     auto normal = getRandomVector();
     normal.normalize();
 #if defined(debug_)
     normal.set(0.);
     normal(0) = 1.;
 #endif
     return normal;
   }
 
   Matrix<Real> getRandomTangents() {
     auto dim = normal.size();
     Matrix<Real> tangent(dim, dim - 1);
     if (dim == 2) {
-      Math::normal2(normal.data(), tangent(0).data());
+      normal = Math::normal(tangent(0));
     }
 
     if (dim == 3) {
       auto v = getRandomVector();
-      tangent(0) = (v - v.dot(normal) * normal).normalize();
-      Math::normal3(normal.data(), tangent(0).data(),
-                    tangent(1).data());
+      tangent(0) = (v - v.dot(normal) * normal).normalized();
+      normal = Math::normal(tangent(0), tangent(1));
     }
 
 #if defined(debug_)
     if (dim == 2)
       tangent(0) = Vector<Real>{0., 1};
     if (dim == 3)
       tangent = Matrix<Real>{{0., 0.}, {1., 0.}, {0., 1.}};
 #endif
 
     return tangent;
   }
 
   /* ------------------------------------------------------------------------ */
   void output_csv() {
     const ::testing::TestInfo * const test_info =
         ::testing::UnitTest::GetInstance()->current_test_info();
 
     std::ofstream cout(std::string(test_info->name()) + ".csv");
     auto print_vect_name = [&](auto name) {
       for (auto s : arange(dim)) {
         if (s != 0) {
           cout << ", ";
         }
         cout << name << "_" << s;
       }
     };
     auto print_vect = [&](const auto & vect) {
       cout << vect.dot(normal);
       if (dim > 1)
         cout << ", " << vect.dot(tangents(0));
       if (dim > 2)
         cout << ", " << vect.dot(tangents(1));
     };
 
     cout << "delta, ";
     print_vect_name("opening");
     cout << ", ";
     print_vect_name("traction");
     cout << std::endl;
 
     for (auto && data : zip(make_view(*this->openings, this->dim),
                             make_view(*this->tractions, this->dim))) {
       const auto & opening = std::get<0>(data);
       auto & traction = std::get<1>(data);
 
       cout << this->material->delta(opening, normal) << ", ";
       print_vect(opening);
       cout << ", ";
       print_vect(traction);
       cout << std::endl;
     }
   }
 
   /* ------------------------------------------------------------------------ */
   Real dissipated() {
-    Vector<Real> prev_opening(dim, 0.);
-    Vector<Real> prev_traction(dim, 0.);
+    Vector<Real> prev_opening = Vector<Real>::Zero(dim);
+    Vector<Real> prev_traction = Vector<Real>::Zero(dim);
 
     Real etot = 0.;
     Real erev = 0.;
     for (auto && data : zip(make_view(*this->openings, this->dim),
                             make_view(*this->tractions, this->dim))) {
       const auto & opening = std::get<0>(data);
       const auto & traction = std::get<1>(data);
 
       etot += (opening - prev_opening).dot(traction + prev_traction) / 2.;
       erev = traction.dot(opening) / 2.;
 
       prev_opening = opening;
       prev_traction = traction;
     }
 
     return etot - erev;
   }
 
   /* ------------------------------------------------------------------------ */
   void checkModeI(Real max_opening, Real expected_dissipated) {
     this->material->insertion_stress_ = this->material->sigma_c_ * normal;
     addOpening(normal, 0., max_opening, 100);
 
     this->material->computeTractions(*openings, normal, *tractions);
 
     for (auto && data : zip(make_view(*this->openings, this->dim),
                             make_view(*this->tractions, this->dim))) {
       const auto & opening = std::get<0>(data);
       auto & traction = std::get<1>(data);
       auto T = traction.dot(normal);
       EXPECT_NEAR(0, (traction - T * normal).norm(), 1e-9);
 
       auto T_expected =
           this->material->tractionModeI(opening, normal).dot(normal);
       EXPECT_NEAR(T_expected, T, 1e-9);
     }
 
     EXPECT_NEAR(expected_dissipated, dissipated(), 1e-5);
     this->output_csv();
   }
 
   /* ------------------------------------------------------------------------ */
   void checkModeII(Real max_opening) {
     if (this->dim == 1) {
       SUCCEED();
       return;
     }
 
     std::uniform_real_distribution<Real> dis;
 
-    auto direction = Vector<Real>(tangents(0));
+    Vector<Real> direction = tangents(0);
     auto alpha = dis(gen) + 0.1;
     auto beta = dis(gen) + 0.2;
 #ifndef debug_
-    direction = alpha * Vector<Real>(tangents(0));
-    if (dim > 2)
-      direction += beta * Vector<Real>(tangents(1));
+    direction = alpha * tangents(0);
+    if (dim > 2) {
+      direction += beta * tangents(1);
+    }
 
-    direction = direction.normalize();
+    direction = direction.normalized();
 #endif
 
     beta = this->material->get("beta");
     this->material->insertion_stress_ =
         beta * this->material->sigma_c_ * direction;
 
     addOpening(direction, 0., max_opening, 100);
 
     this->material->computeTractions(*openings, normal, *tractions);
 
     for (auto && data : zip(make_view(*this->openings, this->dim),
                             make_view(*this->tractions, this->dim))) {
       const auto & opening = std::get<0>(data);
       const auto & traction = std::get<1>(data);
 
       // In ModeII normal traction should be 0
       ASSERT_NEAR(0, traction.dot(normal), 1e-9);
       // Normal opening is null
       ASSERT_NEAR(0, opening.dot(normal), 1e-16);
 
       auto T = traction.dot(direction);
       auto T_expected =
           this->material->tractionModeII(opening, normal).dot(direction);
 
       EXPECT_NEAR(T_expected, T, 1e-9);
     }
 
     // EXPECT_NEAR(expected_dissipated, dissipated(), 1e-5);
     this->output_csv();
   }
 
 protected:
   Vector<Real> normal;
   Matrix<Real> tangents;
   std::unique_ptr<Mesh> mesh;
   std::unique_ptr<SolidMechanicsModelCohesive> model;
   std::unique_ptr<Material> material;
 
   std::unique_ptr<Array<Real>> openings;
   std::unique_ptr<Array<Real>> tractions;
 
   std::mt19937 gen;
 };
 
 template <template <UInt> class Mat, UInt dim>
 struct TestMaterialCohesive : public Mat<dim> {
   TestMaterialCohesive(SolidMechanicsModel & model)
-      : Mat<dim>(model, "test"), insertion_stress_(dim, 0.) {}
+      : Mat<dim>(model, "test"), insertion_stress_(Vector<Real>(dim)) {}
 
   virtual void SetUp() {}
   virtual void resetInternal() {}
 
   void SetUps() {
     this->initMaterial();
     this->SetUp();
     this->updateInternalParameters();
     this->resetInternals();
   }
 
   void resetInternals() { this->resetInternal(); }
 
   virtual void computeTractions(Array<Real> & /*openings*/,
                                 const Vector<Real> & /*normal*/,
                                 Array<Real> & /*tractions*/) {}
 
   Vector<Real> insertion_stress_;
   Real sigma_c_{0};
   bool is_extrinsic{true};
 };
 
 template <template <UInt> class Mat, typename dim_>
 constexpr UInt TestMaterialCohesiveFixture<Mat, dim_>::dim;
diff --git a/test/test_model/test_solid_mechanics_model/test_cohesive/test_materials/test_material_cohesive_linear.cc b/test/test_model/test_solid_mechanics_model/test_cohesive/test_materials/test_material_cohesive_linear.cc
index 841b37d62..11a327a60 100644
--- a/test/test_model/test_solid_mechanics_model/test_cohesive/test_materials/test_material_cohesive_linear.cc
+++ b/test/test_model/test_solid_mechanics_model/test_cohesive/test_materials/test_material_cohesive_linear.cc
@@ -1,195 +1,195 @@
 /**
  * @file   test_material_cohesive_linear.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Feb 21 2018
  * @date last modification:  Wed Nov 18 2020
  *
  * @brief  Test material cohesive linear
  *
  *
  * @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 "test_material_cohesive_fixture.hh"
 /* -------------------------------------------------------------------------- */
 #include "material_cohesive_linear.hh"
 /* -------------------------------------------------------------------------- */
 
 template <Int dim>
 struct TestMaterialCohesiveLinear
     : public TestMaterialCohesive<MaterialCohesiveLinear, dim> {
 
   TestMaterialCohesiveLinear(SolidMechanicsModel & model)
       : TestMaterialCohesive<MaterialCohesiveLinear, dim>(model) {}
 
   void SetUp() override {
     this->is_extrinsic = true;
 
     this->beta = 2.;
     this->kappa = 2;
 
     this->G_c = 10.;
     this->sigma_c_ = 1e6;
     this->penalty = 1e11;
 
     this->delta_c_ = 2. * this->G_c / this->sigma_c_;
   }
 
   void resetInternal() override {
-    normal_opening = Vector<Real>(dim, 0.);
-    tangential_opening = Vector<Real>(dim, 0.);
-    contact_traction = Vector<Real>(dim, 0.);
-    contact_opening = Vector<Real>(dim, 0.);
+    normal_opening = Vector<Real>::Zero(dim);
+    tangential_opening = Vector<Real>::Zero(dim);
+    contact_traction = Vector<Real>::Zero(dim);
+    contact_opening = Vector<Real>::Zero(dim);
   }
 
   void computeTractions(Array<Real> & openings, const Vector<Real> & normal,
                         Array<Real> & tractions) override {
     for (auto && data :
          zip(make_view(openings, dim), make_view(tractions, dim))) {
       auto & opening = std::get<0>(data);
       auto & traction = std::get<1>(data);
 
       this->computeTractionOnQuad(
           traction, opening, normal, delta_max, this->delta_c_,
           this->insertion_stress_, this->sigma_c_, normal_opening,
           tangential_opening, normal_opening_norm, tangential_opening_norm,
           damage, penetration, contact_traction, contact_opening);
 
       opening += contact_opening;
       traction += contact_traction;
     }
   }
 
   Real delta(const Vector<Real> & opening, const Vector<Real> & normal) {
     auto beta = this->beta;
     auto kappa = this->kappa;
 
     auto normal_opening = opening.dot(normal) * normal;
     auto tangential_opening = opening - normal_opening;
 
     return std::sqrt(std::pow(normal_opening.norm(), 2) +
                      std::pow(tangential_opening.norm() * beta / kappa, 2));
   }
 
   Vector<Real> traction(const Vector<Real> & opening,
                         const Vector<Real> & normal) {
     auto delta_c = this->delta_c_;
     auto sigma_c = this->sigma_c_;
     auto beta = this->beta;
     auto kappa = this->kappa;
 
     auto normal_opening = opening.dot(normal) * normal;
     auto tangential_opening = opening - normal_opening;
 
     auto delta_ = this->delta(opening, normal);
     if (delta_ < 1e-16) {
       return this->insertion_stress_;
     }
 
     if (opening.dot(normal) / delta_c < -Math::getTolerance()) {
       ADD_FAILURE() << "This is contact";
-      return Vector<Real>(dim, 0.);
+      return Vector<Real>::Zero(dim);
     }
 
     auto T = sigma_c * (delta_c - delta_) / delta_c / delta_ *
              (normal_opening + tangential_opening * beta * beta / kappa);
 
     return T;
   }
 
   Vector<Real> tractionModeI(const Vector<Real> & opening,
                              const Vector<Real> & normal) {
     return traction(opening, normal);
   }
 
   Vector<Real> tractionModeII(const Vector<Real> & opening,
                               const Vector<Real> & normal) {
     return traction(opening, normal);
   }
 
 public:
   Real delta_c_{0};
 
   Real delta_max{0.};
   Real normal_opening_norm{0};
   Real tangential_opening_norm{0};
   Real damage{0};
   bool penetration{false};
 
   Real etot{0.};
   Real edis{0.};
 
   Vector<Real> normal_opening;
   Vector<Real> tangential_opening;
 
   Vector<Real> contact_traction;
   Vector<Real> contact_opening;
 };
 
 template <typename dim_>
 using TestMaterialCohesiveLinearFixture =
     TestMaterialCohesiveFixture<TestMaterialCohesiveLinear, dim_>;
 
 using coh_types = gtest_list_t<TestAllDimensions>;
 
 TYPED_TEST_SUITE(TestMaterialCohesiveLinearFixture, coh_types, );
 
 TYPED_TEST(TestMaterialCohesiveLinearFixture, ModeI) {
   this->checkModeI(this->material->delta_c_, this->material->get("G_c"));
 
   Real G_c = this->material->get("G_c");
   EXPECT_NEAR(G_c, this->dissipated(), 1e-6);
 }
 
 TYPED_TEST(TestMaterialCohesiveLinearFixture, ModeII) {
   this->checkModeII(this->material->delta_c_);
 
   if (this->dim != 1) {
     Real G_c = this->material->get("G_c");
     Real beta = this->material->get("beta");
     Real dis = beta * G_c;
     EXPECT_NEAR(dis, this->dissipated(), 1e-6);
   }
 }
 
 TYPED_TEST(TestMaterialCohesiveLinearFixture, Cycles) {
   auto delta_c = this->material->delta_c_;
   auto sigma_c = this->material->sigma_c_;
 
   this->material->insertion_stress_ = this->normal * sigma_c;
 
   this->addOpening(this->normal, 0, 0.1 * delta_c, 100);
   this->addOpening(this->normal, 0.1 * delta_c, 0., 100);
   this->addOpening(this->normal, 0., 0.5 * delta_c, 100);
   this->addOpening(this->normal, 0.5 * delta_c, -1.e-5, 100);
   this->addOpening(this->normal, -1.e-5, 0.9 * delta_c, 100);
   this->addOpening(this->normal, 0.9 * delta_c, 0., 100);
   this->addOpening(this->normal, 0., delta_c, 100);
 
   this->material->computeTractions(*this->openings, this->normal,
                                    *this->tractions);
 
   Real G_c = this->material->get("G_c");
   EXPECT_NEAR(G_c, this->dissipated(), 2e-3); // due to contact dissipation at 0
   this->output_csv();
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/local_material_damage.cc b/test/test_model/test_solid_mechanics_model/test_materials/local_material_damage.cc
index 56b6243a7..5abf0d7c6 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/local_material_damage.cc
+++ b/test/test_model/test_solid_mechanics_model/test_materials/local_material_damage.cc
@@ -1,107 +1,112 @@
 /**
  * @file   local_material_damage.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Marion Estelle Chambart <marion.chambart@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Fri May 03 2019
  *
  * @brief  Specialization of the material class for the damage material
  *
  *
  * @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 "local_material_damage.hh"
 #include "solid_mechanics_model.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 LocalMaterialDamage::LocalMaterialDamage(SolidMechanicsModel & model,
                                          const ID & id)
     : Material(model, id), damage("damage", *this) {
   AKANTU_DEBUG_IN();
 
   this->registerParam("E", E, 0., _pat_parsable, "Young's modulus");
   this->registerParam("nu", nu, 0.5, _pat_parsable, "Poisson's ratio");
   this->registerParam("lambda", lambda, _pat_readable,
                       "First Lamé coefficient");
   this->registerParam("mu", mu, _pat_readable, "Second Lamé coefficient");
   this->registerParam("kapa", kpa, _pat_readable, "Bulk coefficient");
   this->registerParam("Yd", Yd, 50., _pat_parsmod);
   this->registerParam("Sd", Sd, 5000., _pat_parsmod);
 
   damage.initialize(1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void LocalMaterialDamage::initMaterial() {
   AKANTU_DEBUG_IN();
   Material::initMaterial();
 
   lambda = nu * E / ((1 + nu) * (1 - 2 * nu));
   mu = E / (2 * (1 + nu));
   kpa = lambda + 2. / 3. * mu;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void LocalMaterialDamage::computeStress(ElementType el_type,
                                         GhostType ghost_type) {
   AKANTU_DEBUG_IN();
+  auto dim = this->spatial_dimension;
 
-  auto dam = damage(el_type, ghost_type).begin();
+  for (auto && data :
+       zip(make_view(this->gradu(el_type, ghost_type), dim, dim),
+           make_view(this->stress(el_type, ghost_type), dim, dim),
+           damage(el_type, ghost_type))) {
+    auto && grad_u = std::get<0>(data);
+    auto && sigma = std::get<1>(data);
+    auto && dam = std::get<2>(data);
 
-  MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
-
-  computeStressOnQuad(grad_u, sigma, *dam);
-  ++dam;
-
-  MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
+    computeStressOnQuad(grad_u, sigma, dam);
+    ++dam;
+  }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void LocalMaterialDamage::computePotentialEnergy(ElementType el_type) {
   AKANTU_DEBUG_IN();
-
+  auto dim = this->spatial_dimension;
   Material::computePotentialEnergy(el_type);
 
-  Real * epot = potential_energy(el_type).data();
-
-  MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, _not_ghost);
-  computePotentialEnergyOnQuad(grad_u, sigma, *epot);
-  epot++;
-  MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
-
+  for (auto && data : zip(make_view(this->gradu(el_type), dim, dim),
+                          make_view(this->stress(el_type), dim, dim),
+                          potential_energy(el_type))) {
+    auto && grad_u = std::get<0>(data);
+    auto && sigma = std::get<1>(data);
+    auto && epot = std::get<2>(data);
+    computePotentialEnergyOnQuad(grad_u, sigma, epot);
+  }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/local_material_damage.hh b/test/test_model/test_solid_mechanics_model/test_materials/local_material_damage.hh
index 685a724a0..656490102 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/local_material_damage.hh
+++ b/test/test_model/test_solid_mechanics_model/test_materials/local_material_damage.hh
@@ -1,127 +1,121 @@
 /**
  * @file   local_material_damage.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Marion Estelle Chambart <marion.chambart@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Fri May 03 2019
  *
  * @brief  Material isotropic elastic
  *
  *
  * @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 "material.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_LOCAL_MATERIAL_DAMAGE_HH_
 #define AKANTU_LOCAL_MATERIAL_DAMAGE_HH_
 
 namespace akantu {
 
 class LocalMaterialDamage : public Material {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   LocalMaterialDamage(SolidMechanicsModel & model, const ID & id = "");
 
-  virtual ~LocalMaterialDamage(){};
+  ~LocalMaterialDamage() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
-  void initMaterial();
+  void initMaterial() override;
 
   /// constitutive law for all element of a type
-  void computeStress(ElementType el_type, GhostType ghost_type = _not_ghost);
+  void computeStress(ElementType el_type,
+                     GhostType ghost_type = _not_ghost) override;
 
   /// constitutive law for a given quadrature point
-  inline void computeStressOnQuad(Matrix<Real> & grad_u, Matrix<Real> & sigma,
-                                  Real & damage);
-
-  /// compute tangent stiffness
-  virtual void computeTangentStiffness(__attribute__((unused))
-                                       ElementType el_type,
-                                       __attribute__((unused))
-                                       Array<Real> & tangent_matrix,
-                                       __attribute__((unused))
-                                       GhostType ghost_type = _not_ghost){};
+  inline void computeStressOnQuad(MatrixProxy<Real> & grad_u,
+                                  MatrixProxy<Real> & sigma, Real & damage);
 
   /// compute the potential energy for all elements
-  void computePotentialEnergy(ElementType el_type);
+  void computePotentialEnergy(ElementType el_type) override;
 
   /// compute the potential energy for on element
-  inline void computePotentialEnergyOnQuad(Matrix<Real> & grad_u,
-                                           Matrix<Real> & sigma, Real & epot);
+  inline void computePotentialEnergyOnQuad(MatrixProxy<Real> & grad_u,
+                                           MatrixProxy<Real> & sigma,
+                                           Real & epot);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// compute the celerity of wave in the material
-  inline Real getCelerity(const Element & element) const;
+  inline Real getCelerity(const Element & element) const override;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Damage, damage, Real);
 
 private:
   /// the young modulus
   Real E;
 
   /// Poisson coefficient
   Real nu;
 
   /// First Lamé coefficient
   Real lambda;
 
   /// Second Lamé coefficient (shear modulus)
   Real mu;
 
   /// resistance to damage
   Real Yd;
 
   /// damage threshold
   Real Sd;
 
   /// Bulk modulus
   Real kpa;
 
   /// damage internal variable
   InternalField<Real> damage;
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 #include "local_material_damage_inline_impl.hh"
 
 } // namespace akantu
 
 #endif /* AKANTU_LOCAL_MATERIAL_DAMAGE_HH_ */
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/local_material_damage_inline_impl.hh b/test/test_model/test_solid_mechanics_model/test_materials/local_material_damage_inline_impl.hh
index e2654d9a0..cc7cace42 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/local_material_damage_inline_impl.hh
+++ b/test/test_model/test_solid_mechanics_model/test_materials/local_material_damage_inline_impl.hh
@@ -1,71 +1,72 @@
 /**
  * @file   local_material_damage_inline_impl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Marion Estelle Chambart <marion.chambart@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Mon Sep 11 2017
  *
  * @brief  Implementation of the inline functions of the material damage
  *
  *
  * @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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
-inline void LocalMaterialDamage::computeStressOnQuad(Matrix<Real> & grad_u,
-                                                     Matrix<Real> & sigma,
+inline void LocalMaterialDamage::computeStressOnQuad(MatrixProxy<Real> & grad_u,
+                                                     MatrixProxy<Real> & sigma,
                                                      Real & dam) {
 
   Real trace = grad_u.trace();
 
   /// \sigma_{ij} = \lambda * (\nabla u)_{kk} * \delta_{ij} + \mu * (\nabla
   /// u_{ij} + \nabla u_{ji})
   auto && epsilon = (grad_u + grad_u.transpose()) / 2.;
 
-  sigma =
-      Matrix<Real>::Identity(spatial_dimension) * trace * lambda + mu * epsilon;
+  sigma = Matrix<Real>::Identity(spatial_dimension, spatial_dimension) * trace *
+              lambda +
+          mu * epsilon;
 
   Real Y = sigma.doubleDot(epsilon) / 2.;
   Real Fd = Y - Yd - Sd * dam;
 
   if (Fd > 0) {
     dam = (Y - Yd) / Sd;
   }
   dam = std::min(dam, 1.);
 
   sigma *= 1 - dam;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void LocalMaterialDamage::computePotentialEnergyOnQuad(
-    Matrix<Real> & grad_u, Matrix<Real> & sigma, Real & epot) {
-  epot = sigma.doubleDot(epsilon) / 2.;
+    MatrixProxy<Real> & grad_u, MatrixProxy<Real> & sigma, Real & epot) {
+  epot = sigma.doubleDot(grad_u) / 2.;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real
 LocalMaterialDamage::getCelerity(const Element & /*element*/) const {
   return (std::sqrt(E / rho));
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/test_damage_materials.cc b/test/test_model/test_solid_mechanics_model/test_materials/test_damage_materials.cc
index 1a5608d09..902ec80c0 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/test_damage_materials.cc
+++ b/test/test_model/test_solid_mechanics_model/test_materials/test_damage_materials.cc
@@ -1,246 +1,257 @@
 /**
  * @file   test_damage_materials.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Nov 17 2017
  * @date last modification:  Wed Nov 18 2020
  *
  * @brief  Tests for damage materials
  *
  *
  * @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 "test_material_fixtures.hh"
 /* -------------------------------------------------------------------------- */
 #include <material_marigo.hh>
 #include <material_mazars.hh>
 #include <py_aka_array.hh>
 #include <solid_mechanics_model.hh>
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 #include <gtest/gtest.h>
 #include <pybind11/embed.h>
 #include <pybind11/numpy.h>
 #include <pybind11/stl.h>
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 namespace py = pybind11;
 using namespace py::literals;
 
 using mat_types = ::testing::Types<
     // Traits<MaterialMarigo, 1>, Traits<MaterialMarigo, 2>,
     // Traits<MaterialMarigo, 3>,
     Traits<MaterialMazars, 1>, Traits<MaterialMazars, 2>,
     Traits<MaterialMazars, 3>>;
 
 /*****************************************************************/
 
 template <> void FriendMaterial<MaterialMazars<1>>::setParams() {
   K0.setDefaultValue(1e-4);
   At = 1.0;
   Bt = 5e3;
   Ac = 0.8;
   Bc = 1391.3;
   beta = 1.;
   E = 25e9;
   nu = 0.2;
 
   updateInternalParameters();
 }
 
 template <> void FriendMaterial<MaterialMazars<2>>::setParams() {
   K0.setDefaultValue(1e-4);
   At = 1.0;
   Bt = 5e3;
   Ac = 0.8;
   Bc = 1391.3;
   beta = 1.;
   E = 25e9;
   nu = 0.2;
   plane_stress = true;
   updateInternalParameters();
 }
 
 template <> void FriendMaterial<MaterialMazars<3>>::setParams() {
   K0.setDefaultValue(1e-4);
   At = 1.0;
   Bt = 5e3;
   Ac = 0.8;
   Bc = 1391.3;
   beta = 1.;
   E = 25e9;
   nu = 0.2;
 
   updateInternalParameters();
 }
 
 template <> void FriendMaterial<MaterialMazars<1>>::testComputeStress() {
   Array<Real> epsilons(1001, 1);
   Array<Real> sigmas(1001, 1);
   Array<Real> damages(1001, 1);
 
   for (auto && data : enumerate(epsilons)) {
     std::get<1>(data) = 2e-6 * std::get<0>(data);
   }
   Real _K0 = K0;
   py::module py_engine = py::module::import("py_mazars");
 
   auto kwargs_mat_params =
       py::dict("K0"_a = _K0, "At"_a = At, "Bt"_a = Bt, "Ac"_a = Ac, "Bc"_a = Bc,
                "E"_a = E, "nu"_a = nu);
   auto kwargs = py::dict("epsilons"_a = epsilons, "sigmas"_a = sigmas,
                          "damages"_a = damages);
 
   auto py_mazars = py_engine.attr("Mazars")(**kwargs_mat_params);
   // auto Gf_py = py_mazars.attr("compute")(**kwargs);
 
   Real dam = 0.;
   Real dam_ref = 0.;
   Real ehat = 0.;
+  Matrix<Real> strain(this->spatial_dimension, this->spatial_dimension);
+  Matrix<Real> sigma(this->spatial_dimension, this->spatial_dimension);
 
   for (auto && epsilon : epsilons) {
-    Matrix<Real> strain(this->spatial_dimension, this->spatial_dimension, 0.);
-    Matrix<Real> sigma(this->spatial_dimension, this->spatial_dimension, 0.);
+    strain.zero();
     strain(0, 0) = epsilon;
 
-    computeStressOnQuad(strain, sigma, dam, ehat);
+    computeStressOnQuad(make_named_tuple(
+        tuple::get<"grad_u"_h>() = strain, tuple::get<"sigma"_h>() = sigma,
+        tuple::get<"damage"_h>() = dam, tuple::get<"Ehat"_h>() = ehat));
 
     Real sigma_ref;
     auto py_data =
         py_mazars.attr("compute_step")(epsilon, sigma_ref, dam_ref, false);
     std::tie(sigma_ref, dam_ref) = py::cast<std::pair<double, double>>(py_data);
 
     EXPECT_NEAR(sigma(0, 0), sigma_ref, 1e-5);
     EXPECT_NEAR(dam, dam_ref, 1e-10);
   }
 }
 
 template <> void FriendMaterial<MaterialMazars<2>>::testComputeStress() {
   Array<Real> epsilons(1001, 1);
   Array<Real> sigmas(1001, 1);
   Array<Real> damages(1001, 1);
 
   for (auto && data : enumerate(epsilons)) {
     std::get<1>(data) = 2e-6 * std::get<0>(data);
   }
   Real _K0 = K0;
   py::module py_engine = py::module::import("py_mazars");
 
   auto kwargs_mat_params =
       py::dict("K0"_a = _K0, "At"_a = At, "Bt"_a = Bt, "Ac"_a = Ac, "Bc"_a = Bc,
                "E"_a = E, "nu"_a = nu);
   auto kwargs = py::dict("epsilons"_a = epsilons, "sigmas"_a = sigmas,
                          "damages"_a = damages);
 
   auto py_mazars = py_engine.attr("Mazars")(**kwargs_mat_params);
   // auto Gf_py = py_mazars.attr("compute")(**kwargs);
 
   Real dam = 0.;
   Real dam_ref = 0.;
   Real ehat = 0.;
 
+  Matrix<Real> strain(this->spatial_dimension, this->spatial_dimension);
+  Matrix<Real> sigma(this->spatial_dimension, this->spatial_dimension);
+
   for (auto && epsilon : epsilons) {
-    Matrix<Real> strain(this->spatial_dimension, this->spatial_dimension, 0.);
-    Matrix<Real> sigma(this->spatial_dimension, this->spatial_dimension, 0.);
+    strain.zero();
     strain(0, 0) = epsilon;
     strain(1, 1) = -this->nu * epsilon;
 
-    computeStressOnQuad(strain, sigma, dam, ehat);
+    computeStressOnQuad(make_named_tuple(
+        tuple::get<"grad_u"_h>() = strain, tuple::get<"sigma"_h>() = sigma,
+        tuple::get<"damage"_h>() = dam, tuple::get<"Ehat"_h>() = ehat));
 
     Real sigma_ref;
     auto py_data =
         py_mazars.attr("compute_step")(epsilon, sigma_ref, dam_ref, false);
     std::tie(sigma_ref, dam_ref) = py::cast<std::pair<double, double>>(py_data);
 
     EXPECT_NEAR(sigma(0, 0), sigma_ref, 1e-5);
     EXPECT_NEAR(dam, dam_ref, 1e-10);
   }
 }
 
 template <> void FriendMaterial<MaterialMazars<3>>::testComputeStress() {
   Array<Real> epsilons(1001, 1);
   Array<Real> sigmas(1001, 1);
   Array<Real> damages(1001, 1);
 
   for (auto && data : enumerate(epsilons)) {
     std::get<1>(data) = 2e-6 * std::get<0>(data);
   }
   Real _K0 = K0;
   py::module py_engine = py::module::import("py_mazars");
 
   auto kwargs_mat_params =
       py::dict("K0"_a = _K0, "At"_a = At, "Bt"_a = Bt, "Ac"_a = Ac, "Bc"_a = Bc,
                "E"_a = E, "nu"_a = nu);
   auto kwargs = py::dict("epsilons"_a = epsilons, "sigmas"_a = sigmas,
                          "damages"_a = damages);
 
   auto py_mazars = py_engine.attr("Mazars")(**kwargs_mat_params);
   // auto Gf_py = py_mazars.attr("compute")(**kwargs);
 
   Real dam = 0.;
   Real dam_ref = 0.;
   Real ehat = 0.;
 
+  Matrix<Real> strain(this->spatial_dimension, this->spatial_dimension);
+  Matrix<Real> sigma(this->spatial_dimension, this->spatial_dimension);
+
   for (auto && epsilon : epsilons) {
-    Matrix<Real> strain(this->spatial_dimension, this->spatial_dimension, 0.);
-    Matrix<Real> sigma(this->spatial_dimension, this->spatial_dimension, 0.);
+    strain.zero();
     strain(0, 0) = epsilon;
     strain(1, 1) = strain(2, 2) = -this->nu * epsilon;
 
-    computeStressOnQuad(strain, sigma, dam, ehat);
+    computeStressOnQuad(make_named_tuple(
+        tuple::get<"grad_u"_h>() = strain, tuple::get<"sigma"_h>() = sigma,
+        tuple::get<"damage"_h>() = dam, tuple::get<"Ehat"_h>() = ehat));
 
     Real sigma_ref;
     auto py_data =
         py_mazars.attr("compute_step")(epsilon, sigma_ref, dam_ref, false);
     std::tie(sigma_ref, dam_ref) = py::cast<std::pair<double, double>>(py_data);
 
     EXPECT_NEAR(sigma(0, 0), sigma_ref, 1e-5);
     EXPECT_NEAR(dam, dam_ref, 1e-10);
   }
 }
 
 namespace {
 
 template <typename T>
 class TestDamageMaterialFixture : public ::TestMaterialFixture<T> {};
 
 TYPED_TEST_SUITE(TestDamageMaterialFixture, mat_types, );
 
 TYPED_TEST(TestDamageMaterialFixture, ComputeStress) {
   this->material->testComputeStress();
 }
 TYPED_TEST(TestDamageMaterialFixture, DISABLED_EnergyDensity) {
   this->material->testEnergyDensity();
 }
 TYPED_TEST(TestDamageMaterialFixture, DISABLED_ComputeTangentModuli) {
   this->material->testComputeTangentModuli();
 }
 TYPED_TEST(TestDamageMaterialFixture, DISABLED_ComputeCelerity) {
   this->material->testCelerity();
 }
 } // namespace
 /*****************************************************************/
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/test_elastic_materials.cc b/test/test_model/test_solid_mechanics_model/test_materials/test_elastic_materials.cc
index a4d0c8219..b2f4701c0 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/test_elastic_materials.cc
+++ b/test/test_model/test_solid_mechanics_model/test_materials/test_elastic_materials.cc
@@ -1,888 +1,912 @@
 /**
  * @file   test_elastic_materials.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Enrico Milanese <enrico.milanese@epfl.ch>
  *
  * @date creation: Fri Nov 17 2017
  * @date last modification:  Wed Nov 18 2020
  *
  * @brief  Tests the Elastic materials
  *
  *
  * @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 "test_gtest_utils.hh"
 #include "test_material_fixtures.hh"
 /* -------------------------------------------------------------------------- */
+#include <aka_voigthelper.hh>
 #include <material_elastic.hh>
 #include <material_elastic_orthotropic.hh>
 #include <solid_mechanics_model.hh>
 /* -------------------------------------------------------------------------- */
 #include <gtest/gtest.h>
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 using mat_types =
     ::testing::Types<Traits<MaterialElastic, 1>, Traits<MaterialElastic, 2>,
                      Traits<MaterialElastic, 3>,
 
                      Traits<MaterialElasticOrthotropic, 2>,
                      Traits<MaterialElasticOrthotropic, 3>,
 
                      Traits<MaterialElasticLinearAnisotropic, 2>,
                      Traits<MaterialElasticLinearAnisotropic, 3>>;
 
 /* -------------------------------------------------------------------------- */
 template <> void FriendMaterial<MaterialElastic<1>>::setParams() {
   Real E = 3.;
   Real rho = 2;
   setParam("E", E);
   setParam("rho", rho);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> void FriendMaterial<MaterialElastic<1>>::testComputeStress() {
-  Matrix<Real> eps = {{2}};
+  Matrix<Real> eps{{2}};
   Matrix<Real> sigma(1, 1);
   Real sigma_th = 2;
-  this->computeStressOnQuad(eps, sigma, sigma_th);
+  this->computeStressOnQuad(make_named_tuple(
+      tuple::get<"grad_u"_h>() = eps, tuple::get<"sigma"_h>() = sigma,
+      tuple::get<"sigma"_h>() = sigma_th));
 
   auto solution = E * eps(0, 0) + sigma_th;
   EXPECT_NEAR(sigma(0, 0), solution, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> void FriendMaterial<MaterialElastic<1>>::testEnergyDensity() {
   Real eps = 2, sigma = 2;
   Real epot = 0;
-  this->computePotentialEnergyOnQuad({{eps}}, {{sigma}}, epot);
+  this->computePotentialEnergyOnQuad(
+      make_named_tuple(tuple::get<"grad_u"_h>() = Matrix<Real>{{eps}},
+                       tuple::get<"sigma"_h>() = Matrix<Real>{{sigma}}),
+      epot);
   Real solution = 2;
   EXPECT_NEAR(epot, solution, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElastic<1>>::testComputeTangentModuli() {
   Matrix<Real> tangent(1, 1);
-  this->computeTangentModuliOnQuad(tangent);
+  this->computeTangentModuliOnQuad(
+      make_named_tuple(tuple::get<"tangent_moduli"_h>() = tangent));
   EXPECT_NEAR(tangent(0, 0), E, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> void FriendMaterial<MaterialElastic<1>>::testCelerity() {
   auto wave_speed = this->getCelerity(Element());
   auto solution = std::sqrt(E / rho);
   EXPECT_NEAR(wave_speed, solution, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> void FriendMaterial<MaterialElastic<2>>::setParams() {
   Real E = 1.;
   Real nu = .3;
   Real rho = 2;
   setParam("E", E);
   setParam("nu", nu);
   setParam("rho", rho);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> void FriendMaterial<MaterialElastic<2>>::testComputeStress() {
   Real bulk_modulus_K = E / (3 * (1 - 2 * nu));
   Real shear_modulus_mu = E / (2 * (1 + nu));
 
-  auto rotation_matrix = getRandomRotation();
+  Matrix<Real> rotation_matrix = getRandomRotation();
 
   auto grad_u = this->getComposedStrain(1.).block(0, 0, 2, 2);
 
   auto grad_u_rot = this->applyRotation(grad_u, rotation_matrix);
 
   Matrix<Real> sigma_rot(2, 2);
-  this->computeStressOnQuad(grad_u_rot, sigma_rot, sigma_th);
+  this->computeStressOnQuad(make_named_tuple(
+      tuple::get<"grad_u"_h>() = grad_u_rot,
+      tuple::get<"sigma"_h>() = sigma_rot, tuple::get<"sigma"_h>() = sigma_th));
 
   auto sigma = this->reverseRotation(sigma_rot, rotation_matrix);
 
-  auto identity = Matrix<Real>::eye(2, 1.);
+  auto identity = Matrix<Real>::Identity(2, 2);
 
   auto strain = 0.5 * (grad_u + grad_u.transpose());
   auto deviatoric_strain = strain - 1. / 3. * strain.trace() * identity;
 
   auto sigma_expected = 2 * shear_modulus_mu * deviatoric_strain +
                         (sigma_th + 2. * bulk_modulus_K) * identity;
 
   auto diff = sigma - sigma_expected;
   Real stress_error =
       diff.lpNorm<Eigen::Infinity>() / sigma_expected.lpNorm<Eigen::Infinity>();
   EXPECT_NEAR(stress_error, 0., 1e-13);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> void FriendMaterial<MaterialElastic<2>>::testEnergyDensity() {
-  Matrix<Real> sigma = {{1, 2}, {2, 4}};
-  Matrix<Real> eps = {{1, 0}, {0, 1}};
+  Matrix<Real, 2, 2> sigma{{1, 2}, {2, 4}};
+  Matrix<Real, 2, 2> eps{{1, 0}, {0, 1}};
   Real epot = 0;
   Real solution = 2.5;
-  this->computePotentialEnergyOnQuad(eps, sigma, epot);
+  this->computePotentialEnergyOnQuad(
+      make_named_tuple(tuple::get<"grad_u"_h>() = eps,
+                       tuple::get<"sigma"_h>() = sigma),
+      epot);
   EXPECT_NEAR(epot, solution, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElastic<2>>::testComputeTangentModuli() {
-  Matrix<Real> tangent(3, 3);
+  Matrix<Real, 3, 3> tangent;
 
   /* Plane Strain */
   // clang-format off
-  Matrix<Real> solution = {
+  Matrix<Real, 3,3> solution{
     {1 - nu, nu, 0},
     {nu, 1 - nu, 0},
     {0, 0, (1 - 2 * nu) / 2},
   };
   // clang-format on
   solution *= E / ((1 + nu) * (1 - 2 * nu));
 
-  this->computeTangentModuliOnQuad(tangent);
-  Real tangent_error = (tangent - solution).norm<L_2>();
+  this->computeTangentModuliOnQuad(
+      make_named_tuple(tuple::get<"tangent_moduli"_h>() = tangent));
+  Real tangent_error = (tangent - solution).norm();
   EXPECT_NEAR(tangent_error, 0, 1e-14);
 
   /* Plane Stress */
   this->plane_stress = true;
   this->updateInternalParameters();
   // clang-format off
-  solution = {
+  solution = Matrix<Real, 3,3>{
     {1, nu, 0},
     {nu, 1, 0},
     {0, 0, (1 - nu) / 2},
   };
   // clang-format on
   solution *= E / (1 - nu * nu);
 
-  this->computeTangentModuliOnQuad(tangent);
-  tangent_error = (tangent - solution).norm<L_2>();
+  this->computeTangentModuliOnQuad(
+      make_named_tuple(tuple::get<"tangent_moduli"_h>() = tangent));
+  tangent_error = (tangent - solution).norm();
   EXPECT_NEAR(tangent_error, 0, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> void FriendMaterial<MaterialElastic<2>>::testCelerity() {
   auto push_wave_speed = this->getPushWaveSpeed(Element());
   auto celerity = this->getCelerity(Element());
 
   Real K = E / (3 * (1 - 2 * nu));
   Real mu = E / (2 * (1 + nu));
   Real sol = std::sqrt((K + 4. / 3 * mu) / rho);
 
   EXPECT_NEAR(push_wave_speed, sol, 1e-14);
   EXPECT_NEAR(celerity, sol, 1e-14);
 
   auto shear_wave_speed = this->getShearWaveSpeed(Element());
 
   sol = std::sqrt(mu / rho);
 
   EXPECT_NEAR(shear_wave_speed, sol, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> void FriendMaterial<MaterialElastic<3>>::setParams() {
   Real E = 1.;
   Real nu = .3;
   Real rho = 2;
   setParam("E", E);
   setParam("nu", nu);
   setParam("rho", rho);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> void FriendMaterial<MaterialElastic<3>>::testComputeStress() {
   Real bulk_modulus_K = E / 3. / (1 - 2. * nu);
   Real shear_modulus_mu = 0.5 * E / (1 + nu);
 
   Matrix<Real> rotation_matrix = getRandomRotation();
 
   auto grad_u = this->getComposedStrain(1.);
 
   auto grad_u_rot = this->applyRotation(grad_u, rotation_matrix);
 
   Matrix<Real> sigma_rot(3, 3);
-  this->computeStressOnQuad(grad_u_rot, sigma_rot, sigma_th);
+  this->computeStressOnQuad(make_named_tuple(
+      tuple::get<"grad_u"_h>() = grad_u_rot,
+      tuple::get<"sigma"_h>() = sigma_rot, tuple::get<"sigma"_h>() = sigma_th));
 
   auto sigma = this->reverseRotation(sigma_rot, rotation_matrix);
 
-  Matrix<Real> identity(3, 3);
+  Matrix<Real, 3, 3> identity;
   identity.eye();
 
   Matrix<Real> strain = 0.5 * (grad_u + grad_u.transpose());
   Matrix<Real> deviatoric_strain = strain - 1. / 3. * strain.trace() * identity;
 
   Matrix<Real> sigma_expected = 2 * shear_modulus_mu * deviatoric_strain +
                                 (sigma_th + 3. * bulk_modulus_K) * identity;
 
   auto diff = sigma - sigma_expected;
   Real stress_error = diff.lpNorm<Eigen::Infinity>();
   EXPECT_NEAR(stress_error, 0., 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> void FriendMaterial<MaterialElastic<3>>::testEnergyDensity() {
-  Matrix<Real> sigma = {{1, 2, 3}, {2, 4, 5}, {3, 5, 6}};
-  Matrix<Real> eps = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
+  Matrix<Real, 3, 3> sigma{{1, 2, 3}, {2, 4, 5}, {3, 5, 6}};
+  Matrix<Real, 3, 3> eps{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
   Real epot = 0;
   Real solution = 5.5;
-  this->computePotentialEnergyOnQuad(eps, sigma, epot);
+  this->computePotentialEnergyOnQuad(
+      make_named_tuple(tuple::get<"grad_u"_h>() = eps,
+                       tuple::get<"sigma"_h>() = sigma),
+      epot);
   EXPECT_NEAR(epot, solution, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElastic<3>>::testComputeTangentModuli() {
   Matrix<Real> tangent(6, 6);
 
   // clang-format off
-  Matrix<Real> solution = {
+  Matrix<Real,6,6> solution{
       {1 - nu, nu, nu, 0, 0, 0},
       {nu, 1 - nu, nu, 0, 0, 0},
       {nu, nu, 1 - nu, 0, 0, 0},
       {0, 0, 0, (1 - 2 * nu) / 2, 0, 0},
       {0, 0, 0, 0, (1 - 2 * nu) / 2, 0},
       {0, 0, 0, 0, 0, (1 - 2 * nu) / 2},
   };
   // clang-format on
   solution *= E / ((1 + nu) * (1 - 2 * nu));
 
-  this->computeTangentModuliOnQuad(tangent);
-  Real tangent_error = (tangent - solution).norm<L_2>();
+  this->computeTangentModuliOnQuad(
+      make_named_tuple(tuple::get<"tangent_moduli"_h>() = tangent));
+  Real tangent_error = (tangent - solution).norm();
   EXPECT_NEAR(tangent_error, 0, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> void FriendMaterial<MaterialElastic<3>>::testCelerity() {
   auto push_wave_speed = this->getPushWaveSpeed(Element());
   auto celerity = this->getCelerity(Element());
 
   Real K = E / (3 * (1 - 2 * nu));
   Real mu = E / (2 * (1 + nu));
   Real sol = std::sqrt((K + 4. / 3 * mu) / rho);
 
   EXPECT_NEAR(push_wave_speed, sol, 1e-14);
   EXPECT_NEAR(celerity, sol, 1e-14);
 
   auto shear_wave_speed = this->getShearWaveSpeed(Element());
 
   sol = std::sqrt(mu / rho);
 
   EXPECT_NEAR(shear_wave_speed, sol, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> void FriendMaterial<MaterialElasticOrthotropic<2>>::setParams() {
   // Note: for this test material and canonical basis coincide
-  Vector<Real> n1 = {1, 0};
-  Vector<Real> n2 = {0, 1};
+  Vector<Real, 2> n1{1, 0};
+  Vector<Real, 2> n2{0, 1};
   Real E1 = 1.;
   Real E2 = 2.;
   Real nu12 = 0.1;
   Real G12 = 2.;
   Real rho = 2.5;
 
   *this->dir_vecs[0] = n1;
   *this->dir_vecs[1] = n2;
   this->E1 = E1;
   this->E2 = E2;
   this->nu12 = nu12;
   this->G12 = G12;
   this->rho = rho;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElasticOrthotropic<2>>::testComputeStress() {
   UInt Dim = 2;
   // material frame of reference is rotate by rotation_matrix starting from
   // canonical basis
   Matrix<Real> rotation_matrix = getRandomRotation();
 
   // canonical basis as expressed in the material frame of reference, as
   // required by MaterialElasticOrthotropic class (it is simply given by the
   // columns of the rotation_matrix; the lines give the material basis expressed
   // in the canonical frame of reference)
   *this->dir_vecs[0] = rotation_matrix(0);
   *this->dir_vecs[1] = rotation_matrix(1);
 
   // set internal Cijkl matrix expressed in the canonical frame of reference
   this->updateInternalParameters();
 
   // gradient in material frame of reference
-  auto grad_u = this->getComposedStrain(2.).block(0, 0, 2, 2);
+  auto grad_u = this->getComposedStrain(2.).block<2, 2>(0, 0);
 
   // gradient in canonical basis (we need to rotate *back* to the canonical
   // basis)
   auto grad_u_rot = this->reverseRotation(grad_u, rotation_matrix);
 
   // stress in the canonical basis
   Matrix<Real> sigma_rot(2, 2);
-  this->computeStressOnQuad(grad_u_rot, sigma_rot);
+  this->computeStressOnQuad(
+      make_named_tuple(tuple::get<"grad_u"_h>() = grad_u_rot,
+                       tuple::get<"sigma"_h>() = sigma_rot));
 
   // stress in the material reference (we need to apply the rotation)
   auto sigma = this->applyRotation(sigma_rot, rotation_matrix);
 
   // construction of Cijkl engineering tensor in the *material* frame of
   // reference
   // ref: http://solidmechanics.org/Text/Chapter3_2/Chapter3_2.php#Sect3_2_13
   Real nu21 = nu12 * E2 / E1;
   Real gamma = 1 / (1 - nu12 * nu21);
 
-  Matrix<Real> C_expected(2 * Dim, 2 * Dim, 0);
+  Matrix<Real> C_expected(2 * Dim, 2 * Dim);
+  C_expected.zero();
   C_expected(0, 0) = gamma * E1;
   C_expected(1, 1) = gamma * E2;
   C_expected(2, 2) = G12;
 
   C_expected(1, 0) = C_expected(0, 1) = gamma * E1 * nu21;
 
   // epsilon is computed directly in the *material* frame of reference
   Matrix<Real> epsilon = 0.5 * (grad_u + grad_u.transpose());
 
   // sigma_expected is computed directly in the *material* frame of reference
   Matrix<Real> sigma_expected(Dim, Dim);
   for (UInt i = 0; i < Dim; ++i) {
     for (UInt j = 0; j < Dim; ++j) {
       sigma_expected(i, i) += C_expected(i, j) * epsilon(j, j);
     }
   }
 
   sigma_expected(0, 1) = sigma_expected(1, 0) =
       C_expected(2, 2) * 2 * epsilon(0, 1);
 
   // sigmas are checked in the *material* frame of reference
   auto diff = sigma - sigma_expected;
   Real stress_error = diff.lpNorm<Eigen::Infinity>();
   EXPECT_NEAR(stress_error, 0., 1e-13);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElasticOrthotropic<2>>::testEnergyDensity() {
-  Matrix<Real> sigma = {{1, 2}, {2, 4}};
-  Matrix<Real> eps = {{1, 0}, {0, 1}};
+  Matrix<Real, 2, 2> sigma{{1, 2}, {2, 4}};
+  Matrix<Real, 2, 2> eps{{1, 0}, {0, 1}};
   Real epot = 0;
   Real solution = 2.5;
-  this->computePotentialEnergyOnQuad(eps, sigma, epot);
+  this->computePotentialEnergyOnQuad(
+      make_named_tuple(tuple::get<"grad_u"_h>() = eps,
+                       tuple::get<"sigma"_h>() = sigma),
+      epot);
   EXPECT_NEAR(epot, solution, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElasticOrthotropic<2>>::testComputeTangentModuli() {
   // construction of Cijkl engineering tensor in the *material* frame of
   // reference
   // ref: http://solidmechanics.org/Text/Chapter3_2/Chapter3_2.php#Sect3_2_13
   Real nu21 = nu12 * E2 / E1;
   Real gamma = 1 / (1 - nu12 * nu21);
 
   Matrix<Real> C_expected(3, 3);
   C_expected(0, 0) = gamma * E1;
   C_expected(1, 1) = gamma * E2;
   C_expected(2, 2) = G12;
 
   C_expected(1, 0) = C_expected(0, 1) = gamma * E1 * nu21;
 
   Matrix<Real> tangent(3, 3);
-  this->computeTangentModuliOnQuad(tangent);
+  this->computeTangentModuliOnQuad(
+      make_named_tuple(tuple::get<"tangent_moduli"_h>() = tangent));
 
-  Real tangent_error = (tangent - C_expected).norm<L_2>();
+  Real tangent_error = (tangent - C_expected).norm();
   EXPECT_NEAR(tangent_error, 0, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <> void FriendMaterial<MaterialElasticOrthotropic<2>>::testCelerity() {
   // construction of Cijkl engineering tensor in the *material* frame of
   // reference
   // ref: http://solidmechanics.org/Text/Chapter3_2/Chapter3_2.php#Sect3_2_13
   Real nu21 = nu12 * E2 / E1;
   Real gamma = 1 / (1 - nu12 * nu21);
 
   Matrix<Real> C_expected(3, 3);
   C_expected(0, 0) = gamma * E1;
   C_expected(1, 1) = gamma * E2;
   C_expected(2, 2) = G12;
 
   C_expected(1, 0) = C_expected(0, 1) = gamma * E1 * nu21;
 
   Vector<Real> eig_expected(3);
-  C_expected.eig(eig_expected);
+  C_expected.eigh(eig_expected);
 
   auto celerity_expected = std::sqrt(eig_expected(0) / rho);
 
   auto celerity = this->getCelerity(Element());
 
   EXPECT_NEAR(celerity_expected, celerity, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> void FriendMaterial<MaterialElasticOrthotropic<3>>::setParams() {
-  Vector<Real> n1 = {1, 0, 0};
-  Vector<Real> n2 = {0, 1, 0};
-  Vector<Real> n3 = {0, 0, 1};
+  Vector<Real, 3> n1{1, 0, 0};
+  Vector<Real, 3> n2{0, 1, 0};
+  Vector<Real, 3> n3{0, 0, 1};
   Real E1 = 1.;
   Real E2 = 2.;
   Real E3 = 3.;
   Real nu12 = 0.1;
   Real nu13 = 0.2;
   Real nu23 = 0.3;
   Real G12 = 2.;
   Real G13 = 3.;
   Real G23 = 1.;
   Real rho = 2.3;
 
   *this->dir_vecs[0] = n1;
   *this->dir_vecs[1] = n2;
   *this->dir_vecs[2] = n3;
   this->E1 = E1;
   this->E2 = E2;
   this->E3 = E3;
   this->nu12 = nu12;
   this->nu13 = nu13;
   this->nu23 = nu23;
   this->G12 = G12;
   this->G13 = G13;
   this->G23 = G23;
   this->rho = rho;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElasticOrthotropic<3>>::testComputeStress() {
   UInt Dim = 3;
 
   // material frame of reference is rotate by rotation_matrix starting from
   // canonical basis
   Matrix<Real> rotation_matrix = getRandomRotation();
 
   // canonical basis as expressed in the material frame of reference, as
   // required by MaterialElasticOrthotropic class (it is simply given by the
   // columns of the rotation_matrix; the lines give the material basis expressed
   // in the canonical frame of reference)
   *this->dir_vecs[0] = rotation_matrix(0);
   *this->dir_vecs[1] = rotation_matrix(1);
   *this->dir_vecs[2] = rotation_matrix(2);
 
   // set internal Cijkl matrix expressed in the canonical frame of reference
   this->updateInternalParameters();
 
   // gradient in material frame of reference
   auto grad_u = this->getComposedStrain(2.);
 
   // gradient in canonical basis (we need to rotate *back* to the canonical
   // basis)
   auto grad_u_rot = this->reverseRotation(grad_u, rotation_matrix);
 
   // stress in the canonical basis
   Matrix<Real> sigma_rot(3, 3);
-  this->computeStressOnQuad(grad_u_rot, sigma_rot);
+  this->computeStressOnQuad(
+      make_named_tuple(tuple::get<"grad_u"_h>() = grad_u_rot,
+                       tuple::get<"sigma"_h>() = sigma_rot));
 
   // stress in the material reference (we need to apply the rotation)
   auto sigma = this->applyRotation(sigma_rot, rotation_matrix);
 
   // construction of Cijkl engineering tensor in the *material* frame of
   // reference
   // ref: http://solidmechanics.org/Text/Chapter3_2/Chapter3_2.php#Sect3_2_13
   Real nu21 = nu12 * E2 / E1;
   Real nu31 = nu13 * E3 / E1;
   Real nu32 = nu23 * E3 / E2;
   Real gamma = 1 / (1 - nu12 * nu21 - nu23 * nu32 - nu31 * nu13 -
                     2 * nu21 * nu32 * nu13);
 
   Matrix<Real> C_expected(6, 6);
   C_expected(0, 0) = gamma * E1 * (1 - nu23 * nu32);
   C_expected(1, 1) = gamma * E2 * (1 - nu13 * nu31);
   C_expected(2, 2) = gamma * E3 * (1 - nu12 * nu21);
 
   C_expected(1, 0) = C_expected(0, 1) = gamma * E1 * (nu21 + nu31 * nu23);
   C_expected(2, 0) = C_expected(0, 2) = gamma * E1 * (nu31 + nu21 * nu32);
   C_expected(2, 1) = C_expected(1, 2) = gamma * E2 * (nu32 + nu12 * nu31);
 
   C_expected(3, 3) = G23;
   C_expected(4, 4) = G13;
   C_expected(5, 5) = G12;
 
   // epsilon is computed directly in the *material* frame of reference
   Matrix<Real> epsilon = 0.5 * (grad_u + grad_u.transpose());
 
   // sigma_expected is computed directly in the *material* frame of reference
   Matrix<Real> sigma_expected(Dim, Dim);
   for (UInt i = 0; i < Dim; ++i) {
     for (UInt j = 0; j < Dim; ++j) {
       sigma_expected(i, i) += C_expected(i, j) * epsilon(j, j);
     }
   }
 
   sigma_expected(0, 1) = C_expected(5, 5) * 2 * epsilon(0, 1);
   sigma_expected(0, 2) = C_expected(4, 4) * 2 * epsilon(0, 2);
   sigma_expected(1, 2) = C_expected(3, 3) * 2 * epsilon(1, 2);
   sigma_expected(1, 0) = sigma_expected(0, 1);
   sigma_expected(2, 0) = sigma_expected(0, 2);
   sigma_expected(2, 1) = sigma_expected(1, 2);
 
   // sigmas are checked in the *material* frame of reference
   auto diff = sigma - sigma_expected;
   Real stress_error = diff.lpNorm<Eigen::Infinity>();
   EXPECT_NEAR(stress_error, 0., 1e-13);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElasticOrthotropic<3>>::testEnergyDensity() {
-  Matrix<Real> sigma = {{1, 2, 3}, {2, 4, 5}, {3, 5, 6}};
-  Matrix<Real> eps = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
+  Matrix<Real, 3, 3> sigma{{1, 2, 3}, {2, 4, 5}, {3, 5, 6}};
+  Matrix<Real, 3, 3> eps{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
   Real epot = 0;
   Real solution = 5.5;
-  this->computePotentialEnergyOnQuad(eps, sigma, epot);
+  this->computePotentialEnergyOnQuad(
+      make_named_tuple(tuple::get<"grad_u"_h>() = eps,
+                       tuple::get<"sigma"_h>() = sigma),
+      epot);
   EXPECT_NEAR(epot, solution, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElasticOrthotropic<3>>::testComputeTangentModuli() {
   // Note: for this test material and canonical basis coincide
   UInt Dim = 3;
 
   // construction of Cijkl engineering tensor in the *material* frame of
   // reference
   // ref: http://solidmechanics.org/Text/Chapter3_2/Chapter3_2.php#Sect3_2_13
-  Real nu21 = nu12 * E2 / E1;
-  Real nu31 = nu13 * E3 / E1;
-  Real nu32 = nu23 * E3 / E2;
-  Real gamma = 1 / (1 - nu12 * nu21 - nu23 * nu32 - nu31 * nu13 -
+  auto nu21 = nu12 * E2 / E1;
+  auto nu31 = nu13 * E3 / E1;
+  auto nu32 = nu23 * E3 / E2;
+  auto gamma = 1 / (1 - nu12 * nu21 - nu23 * nu32 - nu31 * nu13 -
                     2 * nu21 * nu32 * nu13);
 
-  Matrix<Real> C_expected(2 * Dim, 2 * Dim, 0);
+  Matrix<Real> C_expected(2 * Dim, 2 * Dim);
+  C_expected.zero();
+
   C_expected(0, 0) = gamma * E1 * (1 - nu23 * nu32);
   C_expected(1, 1) = gamma * E2 * (1 - nu13 * nu31);
   C_expected(2, 2) = gamma * E3 * (1 - nu12 * nu21);
 
   C_expected(1, 0) = C_expected(0, 1) = gamma * E1 * (nu21 + nu31 * nu23);
   C_expected(2, 0) = C_expected(0, 2) = gamma * E1 * (nu31 + nu21 * nu32);
   C_expected(2, 1) = C_expected(1, 2) = gamma * E2 * (nu32 + nu12 * nu31);
 
   C_expected(3, 3) = G23;
   C_expected(4, 4) = G13;
   C_expected(5, 5) = G12;
 
   Matrix<Real> tangent(6, 6);
-  this->computeTangentModuliOnQuad(tangent);
+  this->computeTangentModuliOnQuad(
+      make_named_tuple(tuple::get<"tangent_moduli"_h>() = tangent));
 
-  Real tangent_error = (tangent - C_expected).norm<L_2>();
+  Real tangent_error = (tangent - C_expected).norm();
   EXPECT_NEAR(tangent_error, 0, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> void FriendMaterial<MaterialElasticOrthotropic<3>>::testCelerity() {
   // Note: for this test material and canonical basis coincide
   UInt Dim = 3;
   // construction of Cijkl engineering tensor in the *material* frame of
   // reference
   // ref: http://solidmechanics.org/Text/Chapter3_2/Chapter3_2.php#Sect3_2_13
-  Real nu21 = nu12 * E2 / E1;
-  Real nu31 = nu13 * E3 / E1;
-  Real nu32 = nu23 * E3 / E2;
-  Real gamma = 1 / (1 - nu12 * nu21 - nu23 * nu32 - nu31 * nu13 -
+  auto nu21 = nu12 * E2 / E1;
+  auto nu31 = nu13 * E3 / E1;
+  auto nu32 = nu23 * E3 / E2;
+  auto gamma = 1 / (1 - nu12 * nu21 - nu23 * nu32 - nu31 * nu13 -
                     2 * nu21 * nu32 * nu13);
 
-  Matrix<Real> C_expected(2 * Dim, 2 * Dim, 0);
+  Matrix<Real> C_expected(2 * Dim, 2 * Dim);
+  C_expected.zero();
+
   C_expected(0, 0) = gamma * E1 * (1 - nu23 * nu32);
   C_expected(1, 1) = gamma * E2 * (1 - nu13 * nu31);
   C_expected(2, 2) = gamma * E3 * (1 - nu12 * nu21);
 
   C_expected(1, 0) = C_expected(0, 1) = gamma * E1 * (nu21 + nu31 * nu23);
   C_expected(2, 0) = C_expected(0, 2) = gamma * E1 * (nu31 + nu21 * nu32);
   C_expected(2, 1) = C_expected(1, 2) = gamma * E2 * (nu32 + nu12 * nu31);
 
   C_expected(3, 3) = G23;
   C_expected(4, 4) = G13;
   C_expected(5, 5) = G12;
 
   Vector<Real> eig_expected(6);
-  C_expected.eig(eig_expected);
+  C_expected.eigh(eig_expected);
 
   auto celerity_expected = std::sqrt(eig_expected(0) / rho);
 
   auto celerity = this->getCelerity(Element());
 
   EXPECT_NEAR(celerity_expected, celerity, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElasticLinearAnisotropic<2>>::setParams() {
-  Matrix<Real> C = {
-      {1.0, 0.3, 0.4},
-      {0.3, 2.0, 0.1},
-      {0.4, 0.1, 1.5},
-  };
+  Matrix<Real, 3, 3> C{{1.0, 0.3, 0.4}, {0.3, 2.0, 0.1}, {0.4, 0.1, 1.5}};
 
-  for (auto i = 0u; i < C.rows(); ++i)
-    for (auto j = 0u; j < C.cols(); ++j)
-      this->Cprime(i, j) = C(i, j);
+  Cprime.block<3, 3>(0, 0) = C;
 
   this->rho = 2.7;
 
   // material frame of reference is rotate by rotation_matrix starting from
   // canonical basis
   Matrix<Real> rotation_matrix = getRandomRotation();
 
   // canonical basis as expressed in the material frame of reference, as
   // required by MaterialElasticLinearAnisotropic class (it is simply given by
   // the columns of the rotation_matrix; the lines give the material basis
   // expressed in the canonical frame of reference)
   *this->dir_vecs[0] = rotation_matrix(0);
   *this->dir_vecs[1] = rotation_matrix(1);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElasticLinearAnisotropic<2>>::testComputeStress() {
-  Matrix<Real> C = {
-      {1.0, 0.3, 0.4},
-      {0.3, 2.0, 0.1},
-      {0.4, 0.1, 1.5},
-  };
+  Matrix<Real, 3, 3> C{{1.0, 0.3, 0.4}, {0.3, 2.0, 0.1}, {0.4, 0.1, 1.5}};
 
-  Matrix<Real> rotation_matrix(2, 2);
+  Matrix<Real, 2, 2> rotation_matrix;
 
   rotation_matrix(0) = *this->dir_vecs[0];
   rotation_matrix(1) = *this->dir_vecs[1];
 
   // gradient in material frame of reference
-  auto grad_u = this->getComposedStrain(1.).block(0, 0, 2, 2);
+  auto grad_u = this->getComposedStrain(1.).block<2, 2>(0, 0);
 
   // gradient in canonical basis (we need to rotate *back* to the canonical
   // basis)
   auto grad_u_rot = this->reverseRotation(grad_u, rotation_matrix);
 
   // stress in the canonical basis
-  Matrix<Real> sigma_rot(2, 2);
-  this->computeStressOnQuad(grad_u_rot, sigma_rot);
+  Matrix<Real, 2, 2> sigma_rot;
+  this->computeStressOnQuad(
+      make_named_tuple(tuple::get<"grad_u"_h>() = grad_u_rot,
+                       tuple::get<"sigma"_h>() = sigma_rot));
 
   // stress in the material reference (we need to apply the rotation)
   auto sigma = this->applyRotation(sigma_rot, rotation_matrix);
 
   // epsilon is computed directly in the *material* frame of reference
-  Matrix<Real> epsilon = 0.5 * (grad_u + grad_u.transpose());
-  Vector<Real> epsilon_voigt(3);
-  epsilon_voigt(0) = epsilon(0, 0);
-  epsilon_voigt(1) = epsilon(1, 1);
-  epsilon_voigt(2) = 2 * epsilon(0, 1);
+  Matrix<Real, 2, 2> epsilon = (grad_u + grad_u.transpose()) / 2.;
+  Vector<Real, 3> epsilon_voigt =
+      VoigtHelper<2>::matrixToVoigtWithFactors(epsilon);
 
   // sigma_expected is computed directly in the *material* frame of reference
-  Vector<Real> sigma_voigt = C * epsilon_voigt;
-  Matrix<Real> sigma_expected(2, 2);
-  sigma_expected(0, 0) = sigma_voigt(0);
-  sigma_expected(1, 1) = sigma_voigt(1);
-  sigma_expected(0, 1) = sigma_expected(1, 0) = sigma_voigt(2);
+  Vector<Real, 3> sigma_voigt = C * epsilon_voigt;
+
+  Matrix<Real, 2, 2> sigma_expected =
+      VoigtHelper<2>::voigtToMatrix(sigma_voigt);
 
   // sigmas are checked in the *material* frame of reference
   auto diff = sigma - sigma_expected;
   Real stress_error = diff.lpNorm<Eigen::Infinity>();
   EXPECT_NEAR(stress_error, 0., 1e-13);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElasticLinearAnisotropic<2>>::testEnergyDensity() {
-  Matrix<Real> sigma = {{1, 2}, {2, 4}};
-  Matrix<Real> eps = {{1, 0}, {0, 1}};
+  Matrix<Real> sigma{{1, 2}, {2, 4}};
+  Matrix<Real> eps{{1, 0}, {0, 1}};
   Real epot = 0;
   Real solution = 2.5;
-  this->computePotentialEnergyOnQuad(eps, sigma, epot);
+  this->computePotentialEnergyOnQuad(
+      make_named_tuple(tuple::get<"grad_u"_h>() = eps,
+                       tuple::get<"sigma"_h>() = sigma),
+      epot);
   EXPECT_NEAR(epot, solution, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<
     MaterialElasticLinearAnisotropic<2>>::testComputeTangentModuli() {
   Matrix<Real> tangent(3, 3);
-  this->computeTangentModuliOnQuad(tangent);
+  this->computeTangentModuliOnQuad(
+      make_named_tuple(tuple::get<"tangent_moduli"_h>() = tangent));
 
-  Real tangent_error = (tangent - C).norm<L_2>();
+  Real tangent_error = (tangent - C).norm();
   EXPECT_NEAR(tangent_error, 0, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElasticLinearAnisotropic<2>>::testCelerity() {
   Vector<Real> eig_expected(3);
-  C.eig(eig_expected);
+  C.eigh(eig_expected);
 
   auto celerity_expected = std::sqrt(eig_expected(0) / this->rho);
   auto celerity = this->getCelerity(Element());
 
   EXPECT_NEAR(celerity_expected, celerity, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElasticLinearAnisotropic<3>>::setParams() {
   // Note: for this test material and canonical basis coincide
-  Matrix<Real> C = {
+  Matrix<Real, 6, 6> C{
       {1.0, 0.3, 0.4, 0.3, 0.2, 0.1}, {0.3, 2.0, 0.1, 0.2, 0.3, 0.2},
       {0.4, 0.1, 1.5, 0.1, 0.4, 0.3}, {0.3, 0.2, 0.1, 2.4, 0.1, 0.4},
-      {0.2, 0.3, 0.4, 0.1, 0.9, 0.1}, {0.1, 0.2, 0.3, 0.4, 0.1, 1.2},
-  };
+      {0.2, 0.3, 0.4, 0.1, 0.9, 0.1}, {0.1, 0.2, 0.3, 0.4, 0.1, 1.2}};
 
   for (auto i = 0u; i < C.rows(); ++i)
     for (auto j = 0u; j < C.cols(); ++j)
       this->Cprime(i, j) = C(i, j);
 
   this->rho = 2.9;
 
   // material frame of reference is rotate by rotation_matrix starting from
   // canonical basis
   Matrix<Real> rotation_matrix = getRandomRotation();
 
   // canonical basis as expressed in the material frame of reference, as
   // required by MaterialElasticLinearAnisotropic class (it is simply given by
   // the columns of the rotation_matrix; the lines give the material basis
   // expressed in the canonical frame of reference)
   *this->dir_vecs[0] = rotation_matrix(0);
   *this->dir_vecs[1] = rotation_matrix(1);
   *this->dir_vecs[2] = rotation_matrix(2);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElasticLinearAnisotropic<3>>::testComputeStress() {
-  Matrix<Real> C = {
+  Matrix<Real, 6, 6> C{
       {1.0, 0.3, 0.4, 0.3, 0.2, 0.1}, {0.3, 2.0, 0.1, 0.2, 0.3, 0.2},
       {0.4, 0.1, 1.5, 0.1, 0.4, 0.3}, {0.3, 0.2, 0.1, 2.4, 0.1, 0.4},
-      {0.2, 0.3, 0.4, 0.1, 0.9, 0.1}, {0.1, 0.2, 0.3, 0.4, 0.1, 1.2},
-  };
+      {0.2, 0.3, 0.4, 0.1, 0.9, 0.1}, {0.1, 0.2, 0.3, 0.4, 0.1, 1.2}};
 
-  Matrix<Real> rotation_matrix(3, 3);
+  Matrix<Real, 3, 3> rotation_matrix;
 
   rotation_matrix(0) = *this->dir_vecs[0];
   rotation_matrix(1) = *this->dir_vecs[1];
   rotation_matrix(2) = *this->dir_vecs[2];
 
   // gradient in material frame of reference
   auto grad_u = this->getComposedStrain(2.);
 
   // gradient in canonical basis (we need to rotate *back* to the canonical
   // basis)
   auto grad_u_rot = this->reverseRotation(grad_u, rotation_matrix);
 
   // stress in the canonical basis
-  Matrix<Real> sigma_rot(3, 3);
-  this->computeStressOnQuad(grad_u_rot, sigma_rot);
+  Matrix<Real, 3, 3> sigma_rot;
+  this->computeStressOnQuad(
+      make_named_tuple(tuple::get<"grad_u"_h>() = grad_u_rot,
+                       tuple::get<"sigma"_h>() = sigma_rot));
 
   // stress in the material reference (we need to apply the rotation)
   auto sigma = this->applyRotation(sigma_rot, rotation_matrix);
 
   // epsilon is computed directly in the *material* frame of reference
-  Matrix<Real> epsilon = 0.5 * (grad_u + grad_u.transpose());
-  Vector<Real> epsilon_voigt(6);
-  epsilon_voigt(0) = epsilon(0, 0);
-  epsilon_voigt(1) = epsilon(1, 1);
-  epsilon_voigt(2) = epsilon(2, 2);
-  epsilon_voigt(3) = 2 * epsilon(1, 2);
-  epsilon_voigt(4) = 2 * epsilon(0, 2);
-  epsilon_voigt(5) = 2 * epsilon(0, 1);
+  Matrix<Real, 3, 3> epsilon = (grad_u + grad_u.transpose()) / 2.;
+  Vector<Real, 6> epsilon_voigt =
+      VoigtHelper<3>::matrixToVoigtWithFactors(epsilon);
 
   // sigma_expected is computed directly in the *material* frame of reference
-  Vector<Real> sigma_voigt = C * epsilon_voigt;
-  Matrix<Real> sigma_expected(3, 3);
-  sigma_expected(0, 0) = sigma_voigt(0);
-  sigma_expected(1, 1) = sigma_voigt(1);
-  sigma_expected(2, 2) = sigma_voigt(2);
-  sigma_expected(1, 2) = sigma_expected(2, 1) = sigma_voigt(3);
-  sigma_expected(0, 2) = sigma_expected(2, 0) = sigma_voigt(4);
-  sigma_expected(0, 1) = sigma_expected(1, 0) = sigma_voigt(5);
+  Vector<Real, 6> sigma_voigt = C * epsilon_voigt;
+  Matrix<Real, 3, 3> sigma_expected =
+      VoigtHelper<3>::voigtToMatrix(sigma_voigt);
 
   // sigmas are checked in the *material* frame of reference
   auto diff = sigma - sigma_expected;
   Real stress_error = diff.lpNorm<Eigen::Infinity>();
   EXPECT_NEAR(stress_error, 0., 1e-13);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElasticLinearAnisotropic<3>>::testEnergyDensity() {
-  Matrix<Real> sigma = {{1, 2, 3}, {2, 4, 5}, {3, 5, 6}};
-  Matrix<Real> eps = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
+  Matrix<Real, 3, 3> sigma{{1, 2, 3}, {2, 4, 5}, {3, 5, 6}};
+  Matrix<Real, 3, 3> eps{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
   Real epot = 0;
   Real solution = 5.5;
-  this->computePotentialEnergyOnQuad(eps, sigma, epot);
+  this->computePotentialEnergyOnQuad(
+      make_named_tuple(tuple::get<"grad_u"_h>() = eps,
+                       tuple::get<"sigma"_h>() = sigma),
+      epot);
   EXPECT_NEAR(epot, solution, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<
     MaterialElasticLinearAnisotropic<3>>::testComputeTangentModuli() {
-  Matrix<Real> tangent(6, 6);
-  this->computeTangentModuliOnQuad(tangent);
+  Matrix<Real, 6, 6> tangent;
+  this->computeTangentModuliOnQuad(
+      make_named_tuple(tuple::get<"tangent_moduli"_h>() = tangent));
 
-  Real tangent_error = (tangent - C).norm<L_2>();
+  Real tangent_error = (tangent - C).norm();
   EXPECT_NEAR(tangent_error, 0, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FriendMaterial<MaterialElasticLinearAnisotropic<3>>::testCelerity() {
-  Vector<Real> eig_expected(6);
-  C.eig(eig_expected);
+  Vector<Real, 6> eig_expected;
+  C.eigh(eig_expected);
 
   auto celerity_expected = std::sqrt(eig_expected(0) / this->rho);
 
   auto celerity = this->getCelerity(Element());
 
   EXPECT_NEAR(celerity_expected, celerity, 1e-14);
 }
 
 /* -------------------------------------------------------------------------- */
 
 namespace {
 
 template <typename T>
 class TestElasticMaterialFixture : public ::TestMaterialFixture<T> {};
 
 TYPED_TEST_SUITE(TestElasticMaterialFixture, mat_types, );
 
 TYPED_TEST(TestElasticMaterialFixture, ComputeStress) {
   this->material->testComputeStress();
 }
 
 TYPED_TEST(TestElasticMaterialFixture, EnergyDensity) {
   this->material->testEnergyDensity();
 }
 
 TYPED_TEST(TestElasticMaterialFixture, ComputeTangentModuli) {
   this->material->testComputeTangentModuli();
 }
 
 TYPED_TEST(TestElasticMaterialFixture, ComputeCelerity) {
   this->material->testCelerity();
 }
 
 } // namespace
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/test_finite_deformation.cc b/test/test_model/test_solid_mechanics_model/test_materials/test_finite_deformation.cc
index 896b25148..68fbc9dfb 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/test_finite_deformation.cc
+++ b/test/test_model/test_solid_mechanics_model/test_materials/test_finite_deformation.cc
@@ -1,139 +1,139 @@
 /**
  * @file   test_finite_deformation.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Nov 11 2019
  * @date last modification:  Wed May 27 2020
  *
  * @brief  Test for dinite deformation
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <solid_mechanics_model.hh>
 /* -------------------------------------------------------------------------- */
 #include <gtest/gtest.h>
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 TEST(TestFiniteDeformation, NotUnit) {
   getStaticParser().parse("material_finite_deformation.dat");
 
   const double pi = std::atan(1) * 4;
   constexpr int dim = 3;
 
   Mesh mesh(dim);
   mesh.read("1_tetrahedron.msh");
 
   SolidMechanicsModel model(mesh);
   model.initFull(_analysis_method = _static);
 
 #if DEBUG_TEST
   model.addDumpField("displacement");
   model.addDumpField("internal_force");
   model.addDumpField("stress");
   model.addDumpField("strain");
   model.dump();
 #endif
 
   Matrix<Real> alpha{{0.00, 0.02, 0.03, 0.04},
                      {0.00, 0.06, 0.07, 0.08},
                      {0.00, 0.10, 0.11, 0.12}};
 
   auto impose_disp = [&] {
     model.getDisplacement().zero();
     for (auto data : zip(make_view(mesh.getNodes(), dim),
                          make_view(model.getDisplacement(), dim),
                          make_view(model.getBlockedDOFs(), dim))) {
       auto & pos = std::get<0>(data);
       auto & dis = std::get<1>(data);
       auto & blocked = std::get<2>(data);
 
       blocked.set(true);
 
       dis += Vector<Real>(alpha(0));
       for (auto p : arange(dim)) {
         dis += Vector<Real>(alpha(1 + p)) * pos(p);
       }
     }
   };
 
   impose_disp();
   model.solveStep();
 #if DEBUG_TEST
   model.dump();
 #endif
 
   auto stesses0 = model.getMaterial(0).getStress();
   auto displacement0 = model.getDisplacement();
   auto internal_force0 = model.getInternalForce();
 
   auto theta = pi / 4;
   Matrix<Real> R{{1., 0., 0.},
                  {0., std::cos(theta), -std::sin(theta)},
                  {0., std::sin(theta), std::cos(theta)}};
 
   impose_disp();
   for (auto data : zip(make_view(mesh.getNodes(), dim),
                        make_view(model.getDisplacement(), dim))) {
     auto & X = std::get<0>(data);
     auto & u = std::get<1>(data);
     u = R * (X + u) - X;
   }
 
   model.solveStep();
 #if DEBUG_TEST
   model.dump();
 #endif
 
   for (auto data : zip(make_view(mesh.getNodes(), dim),
                        make_view(model.getDisplacement(), dim),
                        make_view(displacement0, dim),
                        make_view(model.getInternalForce(), dim),
                        make_view(internal_force0, dim))) {
     auto pos = std::get<0>(data);
-    Vector<Real> refdis(dim, 0.);
+    Vector<Real> refdis(dim);
 
-    refdis += Vector<Real>(alpha(0));
+    refdis = alpha(0);
     for (auto p : arange(dim)) {
       refdis += Vector<Real>(alpha(1 + p)) * pos(p);
     }
 
     auto dis = std::get<1>(data);
     auto dis0 = std::get<2>(data);
 
     auto err = refdis.distance(dis0);
     EXPECT_NEAR(err, 0, 1e-14);
 
     auto err1 = dis.distance(R * (pos + dis0) - pos);
     EXPECT_NEAR(err1, 0, 1e-14);
 
     auto f = std::get<3>(data);
     auto f0 = std::get<4>(data);
 
     auto err3 = f.distance(R * f0);
     EXPECT_NEAR(err3, 0, 1e-5);
   }
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/test_local_material.cc b/test/test_model/test_solid_mechanics_model/test_materials/test_local_material.cc
index 326728e2b..e419c9936 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/test_local_material.cc
+++ b/test/test_model/test_solid_mechanics_model/test_materials/test_local_material.cc
@@ -1,134 +1,134 @@
 /**
  * @file   test_local_material.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Marion Estelle Chambart <marion.chambart@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Clement Roux <clement.roux@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Wed Jun 05 2019
  *
  * @brief  test of the class SolidMechanicsModel with custom local damage on a
  * notched plate
  *
  *
  * @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 <iostream>
 /* -------------------------------------------------------------------------- */
 #include "local_material_damage.hh"
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
   akantu::initialize("material.dat", argc, argv);
   UInt max_steps = 1100;
 
   const UInt spatial_dimension = 2;
   Mesh mesh(spatial_dimension);
   mesh.read("mesh_section_gap.msh");
 
   /// model initialization
   MaterialFactory::getInstance().registerAllocator(
       "local_damage",
       [](UInt, const ID &, SolidMechanicsModel & model,
          const ID & id) -> std::unique_ptr<Material> {
         return std::make_unique<LocalMaterialDamage>(model, id);
       });
 
   SolidMechanicsModel model(mesh);
   model.initFull();
 
   std::cout << model.getMaterial(0) << std::endl;
 
   model.addDumpField("damage");
 
   model.addDumpField("strain");
   model.addDumpField("stress");
   model.addDumpFieldVector("displacement");
   model.addDumpFieldVector("external_force");
   model.addDumpFieldVector("internal_force");
   model.dump();
 
   Real time_step = model.getStableTimeStep();
   model.setTimeStep(time_step / 2.5);
 
   /// Dirichlet boundary conditions
   model.applyBC(BC::Dirichlet::FixedValue(0.0, _x), "Fixed");
   // model.applyBC(BC::Dirichlet::FixedValue(0.0, _y), "Fixed");
-  Matrix<Real> stress(2, 2);
-  stress.eye(5e7);
+  Matrix<Real> stress = Matrix<Real, 2, 2>::Identity() * 5e7;
   model.applyBC(BC::Neumann::FromHigherDim(stress), "Traction");
 
-  for (UInt s = 0; s < max_steps; ++s)
+  for (UInt s = 0; s < max_steps; ++s) {
     model.solveStep();
+  }
 
   model.dump();
 
   // This should throw a bad_cast if not the proper material
   auto & mat =
       dynamic_cast<LocalMaterialDamage &>(model.getMaterial("concrete"));
   const auto & filter = mat.getElementFilter();
-  for (auto & type : filter.elementTypes(spatial_dimension)) {
+  for (const auto & type : filter.elementTypes(spatial_dimension)) {
     std::cout << mat.getDamage(type) << std::endl;
   }
 
   // This part of the test is to mesh dependent and as nothing to do with the
   // fact that we can create a user defined material or not
 
   // const auto & lower_bounds = mesh.getLowerBounds();
   // const auto & upper_bounds = mesh.getUpperBounds();
   // Real L = upper_bounds(_x) - lower_bounds(_x);
   // Real H = upper_bounds(_y) - lower_bounds(_y);
 
   // const auto & filter = model.getMaterial("concrete").getElementFilter();
 
   // Vector<Real> barycenter(spatial_dimension);
 
   // for (auto & type : filter.elementTypes(spatial_dimension)) {
   //   UInt nb_elem = mesh.getNbElement(type);
   //   const UInt nb_gp = model.getFEEngine().getNbIntegrationPoints(type);
   //   const auto & material_damage_array =
   //       model.getMaterial(0).getArray<Real>("damage", type);
   //   UInt cpt = 0;
   //   for (auto nel : arange(nb_elem)) {
   //     mesh.getBarycenter({type, nel, _not_ghost}, barycenter);
   //     if ((std::abs(barycenter(_x) - (L / 2) + 0.025) < 0.025) &&
   //         (std::abs(barycenter(_y) - (H / 2) + 0.045) < 0.045)) {
   //       if (material_damage_array(cpt, 0) < 0.9) {
   //         std::terminate();
   //       } else {
   //         std::cout << "element " << nel << " is correctly broken" <<
   //         std::endl;
   //       }
   //     }
 
   //     cpt += nb_gp;
   //   }
   // }
 
   akantu::finalize();
   return 0;
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/test_material_elasto_plastic_linear_isotropic_hardening/test_material_elasto_plastic_linear_isotropic_hardening.cc b/test/test_model/test_solid_mechanics_model/test_materials/test_material_elasto_plastic_linear_isotropic_hardening/test_material_elasto_plastic_linear_isotropic_hardening.cc
index e7e2e080e..1cc947ee2 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/test_material_elasto_plastic_linear_isotropic_hardening/test_material_elasto_plastic_linear_isotropic_hardening.cc
+++ b/test/test_model/test_solid_mechanics_model/test_materials/test_material_elasto_plastic_linear_isotropic_hardening/test_material_elasto_plastic_linear_isotropic_hardening.cc
@@ -1,93 +1,93 @@
 /**
  * @file   test_material_elasto_plastic_linear_isotropic_hardening.cc
  *
  * @author Jaehyun Cho <jaehyun.cho@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Tue May 21 2019
  *
  * @brief  test for material type elasto plastic linear isotropic hardening
  * using tension-compression test
  *
  *
  * @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 "non_linear_solver.hh"
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 
 int main(int argc, char * argv[]) {
   initialize("test_material_elasto_plastic_linear_isotropic_hardening.dat",
              argc, argv);
 
   const UInt spatial_dimension = 2;
   const Real u_increment = 0.1;
   const UInt steps = 20;
 
   Mesh mesh(spatial_dimension);
   mesh.read("test_material_elasto_plastic_linear_isotropic_hardening.msh");
 
   SolidMechanicsModel model(mesh);
   model.initFull(_analysis_method = _static);
 
   auto & solver = model.getNonLinearSolver("static");
   solver.set("max_iterations", 300);
   solver.set("threshold", 1e-5);
 
   model.applyBC(BC::Dirichlet::FixedValue(0.0, _x), "left");
   model.applyBC(BC::Dirichlet::FixedValue(0.0, _y), "bottom");
 
   std::cout.precision(4);
-  for (UInt i = 0; i < steps; ++i) {
+  for (Int i = 0; i < steps; ++i) {
 
     model.applyBC(BC::Dirichlet::FixedValue(i * u_increment, _x), "right");
 
     try {
       model.solveStep();
     } catch (debug::NLSNotConvergedException & e) {
       std::cout << e.niter << " " << e.error << std::endl;
       throw;
     }
     Real strainxx = i * u_increment / 10.;
 
-    const Array<UInt> & edge_nodes =
+    const auto & edge_nodes =
         mesh.getElementGroup("right").getNodeGroup().getNodes();
-    Array<Real> & residual = model.getInternalForce();
+    auto & residual = model.getInternalForce();
     Real reaction = 0;
 
-    for (UInt n = 0; n < edge_nodes.size(); n++) {
+    for (Int n = 0; n < edge_nodes.size(); n++) {
       reaction -= residual(edge_nodes(n), 0);
     }
 
     std::cout << strainxx << "," << reaction << std::endl;
   }
 
   finalize();
   return 0;
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/test_material_fixtures.hh b/test/test_model/test_solid_mechanics_model/test_materials/test_material_fixtures.hh
index 462a9dc09..28a0ab997 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/test_material_fixtures.hh
+++ b/test/test_model/test_solid_mechanics_model/test_materials/test_material_fixtures.hh
@@ -1,215 +1,211 @@
 /**
  * @file   test_material_fixtures.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Nov 17 2017
  * @date last modification:  Fri Dec 13 2019
  *
  * @brief  Fixture for material tests
  *
  *
  * @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 "test_gtest_utils.hh"
 /* -------------------------------------------------------------------------- */
 #include <material_elastic.hh>
 #include <solid_mechanics_model.hh>
 /* -------------------------------------------------------------------------- */
 #include <gtest/gtest.h>
 #include <random>
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 template <typename T> class FriendMaterial : public T {
 public:
   ~FriendMaterial() = default;
 
   FriendMaterial(SolidMechanicsModel & model, const ID & id = "material")
       : T(model, id) {
     gen.seed(::testing::GTEST_FLAG(random_seed));
   }
 
   virtual void testComputeStress() { AKANTU_TO_IMPLEMENT(); };
   virtual void testComputeTangentModuli() { AKANTU_TO_IMPLEMENT(); };
   virtual void testEnergyDensity() { AKANTU_TO_IMPLEMENT(); };
   virtual void testCelerity() { AKANTU_TO_IMPLEMENT(); }
 
   virtual void setParams() {}
   virtual void SetUp() {
     this->setParams();
     this->initMaterial();
   }
 
   virtual void TearDown() {}
 
   inline Matrix<Real> getDeviatoricStrain(Real intensity);
   inline Matrix<Real> getHydrostaticStrain(Real intensity);
   inline Matrix<Real> getComposedStrain(Real intensity);
 
   inline const Matrix<Real> reverseRotation(Matrix<Real> mat,
                                             Matrix<Real> rotation_matrix) {
     Matrix<Real> R = rotation_matrix;
     Matrix<Real> m2 = mat * R;
     Matrix<Real> m1 = R.transpose();
     return m1 * m2;
   };
 
-  inline const Matrix<Real> applyRotation(Matrix<Real> mat,
-                                          const Matrix<Real> rotation_matrix) {
-    Matrix<Real> R = rotation_matrix;
-    Matrix<Real> m2 = mat * R.transpose();
-    Matrix<Real> m1 = R;
-    return m1 * m2;
+  inline const Matrix<Real> applyRotation(Matrix<Real> A,
+                                          const Matrix<Real> R) {
+    return R * A * R.transpose();
   };
 
   inline Vector<Real> getRandomVector();
   inline Matrix<Real> getRandomRotation();
 
 protected:
   std::mt19937 gen;
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 Matrix<Real> FriendMaterial<T>::getDeviatoricStrain(Real intensity) {
-  Matrix<Real> dev = {{0., 1., 2.}, {1., 0., 3.}, {2., 3., 0.}};
+  Matrix<Real> dev{{0., 1., 2.}, {1., 0., 3.}, {2., 3., 0.}};
   dev *= intensity;
   return dev;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 Matrix<Real> FriendMaterial<T>::getHydrostaticStrain(Real intensity) {
-  Matrix<Real> dev = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
+  Matrix<Real> dev{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
   dev *= intensity;
   return dev;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T>
 Matrix<Real> FriendMaterial<T>::getComposedStrain(Real intensity) {
   Matrix<Real> s = FriendMaterial<T>::getHydrostaticStrain(intensity) +
                    FriendMaterial<T>::getDeviatoricStrain(intensity);
   s *= intensity;
   return s;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> Vector<Real> FriendMaterial<T>::getRandomVector() {
   auto dim = this->spatial_dimension;
   std::uniform_real_distribution<Real> dis;
-  Vector<Real> vector(dim, 0.);
+  Vector<Real> vector(dim);
+  vector.zero();
   while (vector.norm() < 1e-9) {
     for (auto s : arange(dim))
       vector(s) = dis(gen);
   }
   return vector;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> Matrix<Real> FriendMaterial<T>::getRandomRotation() {
-  auto dim = this->spatial_dimension;
+  const auto dim = this->spatial_dimension;
 
   Matrix<Real> rotation(dim, dim);
-  Vector<Real> v1 = rotation(0);
-  v1 = getRandomVector().normalize();
+  auto && v1 = rotation(0);
+  v1 = getRandomVector().normalized();
   if (dim == 2) {
-    Vector<Real> v1_ = {v1(0), v1(1), 0};
-    Vector<Real> v2_(3);
-    Vector<Real> v3_ = {0, 0, 1};
-    v2_.crossProduct(v3_, v1_);
-
-    Vector<Real> v2 = rotation(1);
-    v2(0) = v2_(0);
-    v2(1) = v2_(1);
+    Vector<Real, 3> v1{v1(0), v1(1), 0};
+    Vector<Real, 3> v3{0, 0, 1};
+
+    Vector<Real, 3> v2 = v3.cross(v1);
+
+    rotation(1) = v2.block<2, 1>(0, 0);
   }
 
   if (dim == 3) {
-    auto v2 = getRandomVector();
-    v2 = (v2 - v2.dot(v1) * v1).normalize();
+    Vector<Real, 3> v2 = getRandomVector();
+    Vector<Real, 3> v1_ = v1;
+    v2 = (v2 - v2.dot(v1_) * v1_).normalized();
 
-    Vector<Real> v3(3);
-    v3.crossProduct(v1, v2);
+    Vector<Real, 3> v3 = v1_.cross(v2);
 
     rotation(1) = v2;
     rotation(2) = v3;
   }
 
 //#define debug_
 #if defined(debug_)
   if (dim == 2)
-    rotation = Matrix<Real>{{1., 0.}, {0., 1.}};
+    rotation = Matrix<Rea, 2, 2>{{1., 0.}, {0., 1.}};
   if (dim == 3)
-    rotation = Matrix<Real>{{1., 0., 0.}, {0., 1., 0.}, {0., 0., 1.}};
+    rotation = Matrix<Real, 3, 3>{{1., 0., 0.}, {0., 1., 0.}, {0., 0., 1.}};
 #endif
 
   rotation = rotation.transpose();
 
   return rotation;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, class Model>
 class TestMaterialBaseFixture : public ::testing::Test {
 public:
   using mat_class = typename T::mat_class;
 
   void SetUp() override {
     constexpr auto spatial_dimension = T::Dim;
     mesh = std::make_unique<Mesh>(spatial_dimension);
     model = std::make_unique<Model>(*mesh);
     material = std::make_unique<friend_class>(*model);
     material->SetUp();
   }
 
   void TearDown() override {
     material->TearDown();
     material.reset(nullptr);
     model.reset(nullptr);
     mesh.reset(nullptr);
   }
 
   using friend_class = FriendMaterial<mat_class>;
 
 protected:
   std::unique_ptr<Mesh> mesh;
   std::unique_ptr<Model> model;
   std::unique_ptr<friend_class> material;
 };
 
 /* -------------------------------------------------------------------------- */
 template <template <UInt> class T, UInt _Dim> struct Traits {
   using mat_class = T<_Dim>;
   static constexpr UInt Dim = _Dim;
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 using TestMaterialFixture = TestMaterialBaseFixture<T, SolidMechanicsModel>;
 
 /* -------------------------------------------------------------------------- */
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/test_material_non_local/custom_non_local_test_material.hh b/test/test_model/test_solid_mechanics_model/test_materials/test_material_non_local/custom_non_local_test_material.hh
index b2024674c..0fd2622a3 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/test_material_non_local/custom_non_local_test_material.hh
+++ b/test/test_model/test_solid_mechanics_model/test_materials/test_material_non_local/custom_non_local_test_material.hh
@@ -1,81 +1,82 @@
 /**
  * @file   custom_non_local_test_material.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Fri Jun 26 2020
  *
  * @brief  Custom material to test the non local 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 "material_elastic.hh"
 #include "material_non_local.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef CUSTOM_NON_LOCAL_TEST_MATERIAL_HH_
 #define CUSTOM_NON_LOCAL_TEST_MATERIAL_HH_
 
 namespace akantu {
 
 template <Int dim>
 class CustomNonLocalTestMaterial
     : public MaterialNonLocal<dim, MaterialElastic<dim>> {
 public:
   using MyNonLocalParent = MaterialNonLocal<dim, MaterialElastic<dim>>;
 
   CustomNonLocalTestMaterial(SolidMechanicsModel & model, const ID & id);
 
   /* ------------------------------------------------------------------------ */
   void initMaterial() override;
 
   void computeNonLocalStress(ElementType el_type, GhostType ghost_type);
   void computeStress(ElementType el_type, GhostType ghost_type) override;
 
 protected:
   void registerNonLocalVariables() override;
 
   /* ------------------------------------------------------------------------ */
   void computeNonLocalStresses(GhostType ghost_type) override {
     AKANTU_DEBUG_IN();
 
-    for (auto & type : this->element_filter.elementTypes(dim, ghost_type)) {
+    for (const auto & type :
+         this->element_filter.elementTypes(dim, ghost_type)) {
       computeNonLocalStress(type, ghost_type);
     }
 
     AKANTU_DEBUG_OUT();
   }
 
 public:
   void setDamage(Real dam) { this->local_damage.setDefaultValue(dam); }
 
 protected:
   InternalField<Real> local_damage;
   InternalField<Real> damage;
 };
 
 } // namespace akantu
 
 #endif /* CUSTOM_NON_LOCAL_TEST_MATERIAL_HH_ */
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/test_material_non_local/test_material_damage_non_local.cc b/test/test_model/test_solid_mechanics_model/test_materials/test_material_non_local/test_material_damage_non_local.cc
index 3bc68d7f8..e4fd2e605 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/test_material_non_local/test_material_damage_non_local.cc
+++ b/test/test_model/test_solid_mechanics_model/test_materials/test_material_non_local/test_material_damage_non_local.cc
@@ -1,117 +1,116 @@
 /**
  * @file   test_material_damage_non_local.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Clement Roux <clement.roux@epfl.ch>
  *
  * @date creation: Wed Aug 04 2010
  * @date last modification: Thu Dec 14 2017
  *
  * @brief  test for non-local damage materials on a 2D plate with a section gap
  * the sample should break at the notch
  *
  *
  * @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 <iostream>
 
 /* -------------------------------------------------------------------------- */
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
   debug::setDebugLevel(dblWarning);
 
   akantu::initialize("material_damage_non_local.dat", argc, argv);
   UInt max_steps = 1100;
 
   const UInt spatial_dimension = 2;
   Mesh mesh(spatial_dimension);
   mesh.read("mesh_section_gap.msh");
 
   SolidMechanicsModel model(mesh);
 
   /// model initialization
   model.initFull();
 
   Real time_step = model.getStableTimeStep();
   model.setTimeStep(time_step / 2.5);
 
   std::cout << model << std::endl;
 
   model.applyBC(BC::Dirichlet::FixedValue(0.0), "Fixed");
 
   // Boundary condition (Neumann)
-  Matrix<Real> stress(2, 2);
-  stress.eye(5e8);
+  Matrix<Real, 2, 2> stress = Matrix<Real, 2, 2>::Identity() * 5e8;
   model.applyBC(BC::Neumann::FromHigherDim(stress), "Traction");
 
   model.setBaseName("damage_non_local");
   model.addDumpFieldVector("displacement");
   model.addDumpField("velocity");
   model.addDumpField("acceleration");
   model.addDumpFieldVector("external_force");
   model.addDumpFieldVector("internal_force");
   model.addDumpField("damage");
   model.addDumpField("stress");
   model.addDumpField("strain");
   model.dump();
 
   for (UInt s = 0; s < max_steps; ++s) {
     model.solveStep();
 
     // if(s % 100 == 0) std::cout << "Step " << s+1 << "/" << max_steps
     // <<std::endl;  if(s % 100 == 0) model.dump();
   }
 
   model.dump();
 
   const auto & lower_bounds = mesh.getLowerBounds();
   const auto & upper_bounds = mesh.getUpperBounds();
   Real L = upper_bounds(0) - lower_bounds(0);
   Real H = upper_bounds(1) - lower_bounds(1);
 
   const auto & mat = model.getMaterial(0);
   const auto & filter = mat.getElementFilter();
   Vector<Real> barycenter(spatial_dimension);
 
-  for (auto & type : filter.elementTypes(spatial_dimension)) {
-    UInt nb_elem = mesh.getNbElement(type);
-    const UInt nb_gp = model.getFEEngine().getNbIntegrationPoints(type);
+  for (const auto & type : filter.elementTypes(spatial_dimension)) {
+    auto nb_elem = mesh.getNbElement(type);
+    const auto nb_gp = model.getFEEngine().getNbIntegrationPoints(type);
     auto & material_damage_array = mat.getArray<Real>("damage", type);
-    UInt cpt = 0;
-    for (UInt nel = 0; nel < nb_elem; ++nel) {
+    Int cpt = 0;
+    for (Int nel = 0; nel < nb_elem; ++nel) {
       mesh.getBarycenter({type, nel, _not_ghost}, barycenter);
       if ((std::abs(barycenter(0) - (L / 2) + 0.025) < 0.025) &&
           (std::abs(barycenter(1) - (H / 2) + 0.025) < 0.025)) {
         if (material_damage_array(cpt, 0) < 0.9) {
           std::terminate();
         }
       }
       cpt += nb_gp;
     }
   }
 
   return 0;
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/test_material_orthotropic.cc b/test/test_model/test_solid_mechanics_model/test_materials/test_material_orthotropic.cc
index 6c0d747da..867dffa3a 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/test_material_orthotropic.cc
+++ b/test/test_model/test_solid_mechanics_model/test_materials/test_material_orthotropic.cc
@@ -1,101 +1,102 @@
 /**
  * @file   test_material_orthotropic.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Thu May 09 2019
  *
  * @brief  test of the class SolidMechanicsModel
  *
  *
  * @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 "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
   //  akantu::initialize("orthotropic.dat", argc, argv);
   akantu::initialize("orthotropic.dat", argc, argv);
   UInt max_steps = 1000;
   Real epot, ekin;
 
   Mesh mesh(2);
   mesh.read("square.msh");
   mesh.createBoundaryGroupFromGeometry();
 
   SolidMechanicsModel model(mesh);
 
   /// model initialization
   model.initFull();
 
   Real time_step = model.getStableTimeStep();
   model.setTimeStep(time_step / 10.);
 
   model.assembleMassLumped();
 
   std::cout << model << std::endl;
 
   // Boundary condition (Neumann)
-  Matrix<Real> stress(2, 2);
-  stress.eye(Real(1e3));
+  Matrix<Real> stress = Matrix<Real, 2, 2>::Identity() * 1e3;
+
   model.applyBC(BC::Neumann::FromHigherDim(stress), "boundary_0");
 
   model.setBaseName("square-orthotrope");
   model.addDumpFieldVector("displacement");
   model.addDumpField("mass");
   model.addDumpField("velocity");
   model.addDumpField("acceleration");
   model.addDumpFieldVector("external_force");
   model.addDumpFieldVector("internal_force");
   model.addDumpField("stress");
   model.addDumpField("grad_u");
   model.dump();
 
   std::ofstream energy;
   energy.open("energy.csv");
   energy << "id,epot,ekin,tot" << std::endl;
 
   for (UInt s = 0; s < max_steps; ++s) {
     model.solveStep();
 
     epot = model.getEnergy("potential");
     ekin = model.getEnergy("kinetic");
 
     std::cerr << "passing step " << s << "/" << max_steps << std::endl;
     energy << s << "," << epot << "," << ekin << "," << epot + ekin
            << std::endl;
 
-    if (s % 100 == 0)
+    if (s % 100 == 0) {
       model.dump();
+    }
   }
 
   energy.close();
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/test_material_thermal.cc b/test/test_model/test_solid_mechanics_model/test_materials/test_material_thermal.cc
index 8dfe2b79a..cc8156d6f 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/test_material_thermal.cc
+++ b/test/test_model/test_solid_mechanics_model/test_materials/test_material_thermal.cc
@@ -1,106 +1,109 @@
 /**
  * @file   test_material_thermal.cc
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Wed Nov 18 2020
  *
  * @brief  Test the thermal material
  *
  *
  * @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 "material_thermal.hh"
 #include "solid_mechanics_model.hh"
 #include "test_material_fixtures.hh"
 /* -------------------------------------------------------------------------- */
 #include <gtest/gtest.h>
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 using mat_types =
     ::testing::Types<Traits<MaterialThermal, 1>, Traits<MaterialThermal, 2>,
                      Traits<MaterialThermal, 3>>;
 
 /* -------------------------------------------------------------------------- */
 template <> void FriendMaterial<MaterialThermal<3>>::testComputeStress() {
   Real E = 1.;
   Real nu = .3;
   Real alpha = 2;
   setParam("E", E);
   setParam("nu", nu);
   setParam("alpha", alpha);
 
   Real deltaT = 1;
   Real sigma = 0;
-  this->computeStressOnQuad(sigma, deltaT);
+  this->computeStressOnQuad(make_named_tuple(
+      tuple::get<"sigma_th"_h>() = sigma, tuple::get<"delta_T"_h>() = deltaT));
   Real solution = -E / (1 - 2 * nu) * alpha * deltaT;
   auto error = std::abs(sigma - solution);
   ASSERT_NEAR(error, 0, 1e-14);
 }
 
 template <> void FriendMaterial<MaterialThermal<2>>::testComputeStress() {
   Real E = 1.;
   Real nu = .3;
   Real alpha = 2;
   setParam("E", E);
   setParam("nu", nu);
   setParam("alpha", alpha);
 
   Real deltaT = 1;
   Real sigma = 0;
-  this->computeStressOnQuad(sigma, deltaT);
+  this->computeStressOnQuad(make_named_tuple(
+      tuple::get<"sigma_th"_h>() = sigma, tuple::get<"delta_T"_h>() = deltaT));
   Real solution = -E / (1 - 2 * nu) * alpha * deltaT;
   auto error = std::abs(sigma - solution);
   ASSERT_NEAR(error, 0, 1e-14);
 }
 
 template <> void FriendMaterial<MaterialThermal<1>>::testComputeStress() {
   Real E = 1.;
   Real nu = .3;
   Real alpha = 2;
   setParam("E", E);
   setParam("nu", nu);
   setParam("alpha", alpha);
 
   Real deltaT = 1;
   Real sigma = 0;
-  this->computeStressOnQuad(sigma, deltaT);
+  this->computeStressOnQuad(make_named_tuple(
+      tuple::get<"sigma_th"_h>() = sigma, tuple::get<"delta_T"_h>() = deltaT));
   Real solution = -E * alpha * deltaT;
   auto error = std::abs(sigma - solution);
   ASSERT_NEAR(error, 0, 1e-14);
 }
 
 namespace {
 
 template <typename T>
 class TestMaterialThermalFixture : public ::TestMaterialFixture<T> {};
 
 TYPED_TEST_SUITE(TestMaterialThermalFixture, mat_types, );
 
 TYPED_TEST(TestMaterialThermalFixture, ThermalComputeStress) {
   this->material->testComputeStress();
 }
 } // namespace
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/test_multi_material_elastic.cc b/test/test_model/test_solid_mechanics_model/test_materials/test_multi_material_elastic.cc
index 6dcd6dfad..d9633a0d3 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/test_multi_material_elastic.cc
+++ b/test/test_model/test_solid_mechanics_model/test_materials/test_multi_material_elastic.cc
@@ -1,124 +1,116 @@
 /**
  * @file   test_multi_material_elastic.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Mar 03 2017
  * @date last modification:  Thu May 09 2019
  *
  * @brief  Test with 2 elastic materials
  *
  *
  * @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 "non_linear_solver.hh"
 #include <solid_mechanics_model.hh>
 
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
   initialize("test_multi_material_elastic.dat", argc, argv);
 
-  UInt spatial_dimension = 2;
-  Mesh mesh(spatial_dimension);
+  const Int dim = 2;
+  Mesh mesh(dim);
 
   mesh.read("test_multi_material_elastic.msh");
 
   SolidMechanicsModel model(mesh);
 
   auto && mat_sel = std::make_shared<MeshDataMaterialSelector<std::string>>(
       "physical_names", model);
   model.setMaterialSelector(mat_sel);
 
   model.initFull(_analysis_method = _static);
 
   model.applyBC(BC::Dirichlet::FlagOnly(_y), "ground");
   model.applyBC(BC::Dirichlet::FlagOnly(_x), "corner");
 
-  Vector<Real> trac(spatial_dimension, 0.);
+  Vector<Real> trac = Vector<Real>::Zero(dim);
   trac(_y) = 1.;
   model.applyBC(BC::Neumann::FromTraction(trac), "air");
 
   model.addDumpField("external_force");
   model.addDumpField("internal_force");
   model.addDumpField("blocked_dofs");
   model.addDumpField("displacement");
   model.addDumpField("stress");
   model.addDumpField("grad_u");
 
   // model.dump();
   auto & solver = model.getNonLinearSolver("static");
   solver.set("max_iterations", 1);
   solver.set("threshold", 1e-8);
   solver.set("convergence_type", SolveConvergenceCriteria::_residual);
 
   model.solveStep();
   // model.dump();
 
   std::map<std::string, Matrix<Real>> ref_strain;
-  ref_strain["strong"] = Matrix<Real>(spatial_dimension, spatial_dimension, 0.);
+  ref_strain["strong"] = Matrix<Real, dim, dim>::Zero();
   ref_strain["strong"](_y, _y) = .5;
 
-  ref_strain["weak"] = Matrix<Real>(spatial_dimension, spatial_dimension, 0.);
+  ref_strain["weak"] = Matrix<Real, dim, dim>::Zero();
   ref_strain["weak"](_y, _y) = 1;
 
-  Matrix<Real> ref_stress(spatial_dimension, spatial_dimension, 0.);
+  Matrix<Real, dim, dim> ref_stress = Matrix<Real, dim, dim>::Zero();
   ref_stress(_y, _y) = 1.;
 
   std::vector<std::string> mats = {"strong", "weak"};
 
-  typedef Array<Real>::const_matrix_iterator mat_it;
-  auto check = [](mat_it it, mat_it end, const Matrix<Real> & ref) -> bool {
-    for (; it != end; ++it) {
-      Real dist = (*it - ref).norm<L_2>();
-
-      // std::cout << *it << " " << dist << " " << (dist < 1e-10 ? "OK" : "Not
-      // OK") << std::endl;
-
-      if (dist > 1e-10)
+  auto check = [](auto && view, const Matrix<Real> & ref) -> bool {
+    for (auto && mat : view) {
+      Real dist = (mat - ref).norm();
+      if (dist > 1e-10) {
         return false;
+      }
     }
-
     return true;
   };
 
-  for (auto & type : mesh.elementTypes(spatial_dimension)) {
+  for (const auto & type : mesh.elementTypes(dim)) {
     for (auto mat_id : mats) {
       auto & stress = model.getMaterial(mat_id).getStress(type);
       auto & grad_u = model.getMaterial(mat_id).getGradU(type);
 
-      auto sit = stress.begin(spatial_dimension, spatial_dimension);
-      auto send = stress.end(spatial_dimension, spatial_dimension);
+      auto sview = make_view<dim, dim>(stress);
+      auto gview = make_view<dim, dim>(grad_u);
 
-      auto git = grad_u.begin(spatial_dimension, spatial_dimension);
-      auto gend = grad_u.end(spatial_dimension, spatial_dimension);
-
-      if (!check(sit, send, ref_stress))
+      if (not check(sview, ref_stress)) {
         AKANTU_ERROR("The stresses are not correct");
-      if (!check(git, gend, ref_strain[mat_id]))
+      }
+      if (not check(gview, ref_strain[mat_id])) {
         AKANTU_ERROR("The grad_u are not correct");
+      }
     }
   }
 
-  finalize();
-
   return 0;
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/test_plastic_materials.cc b/test/test_model/test_solid_mechanics_model/test_materials/test_plastic_materials.cc
index 16021f9fa..0da82f1d1 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/test_plastic_materials.cc
+++ b/test/test_model/test_solid_mechanics_model/test_materials/test_plastic_materials.cc
@@ -1,196 +1,208 @@
 /**
  * @file   test_plastic_materials.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *
  * @date creation: Fri Nov 17 2017
  * @date last modification:  Tue Jan 19 2021
  *
  * @brief  Tests the plastic material
  *
  *
  * @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 "material_linear_isotropic_hardening.hh"
 #include "solid_mechanics_model.hh"
 #include "test_material_fixtures.hh"
 #include <gtest/gtest.h>
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 using mat_types = ::testing::Types<
     // Traits<MaterialLinearIsotropicHardening, 1>,
     // Traits<MaterialLinearIsotropicHardening, 2>,
     Traits<MaterialLinearIsotropicHardening, 3>>;
 
 /* -------------------------------------------------------------------------- */
 
 template <>
 void FriendMaterial<MaterialLinearIsotropicHardening<3>>::testComputeStress() {
 
   Real E = 1.;
   // Real nu = .3;
   Real nu = 0.;
   Real rho = 1.;
   Real sigma_0 = 1.;
   Real h = 0.;
   Real bulk_modulus_K = E / 3. / (1 - 2. * nu);
   Real shear_modulus_mu = 0.5 * E / (1 + nu);
 
   setParam("E", E);
   setParam("nu", nu);
   setParam("rho", rho);
   setParam("sigma_y", sigma_0);
   setParam("h", h);
 
   auto rotation_matrix = getRandomRotation();
 
   Real max_strain = 10.;
   Real strain_steps = 100;
   Real dt = max_strain / strain_steps;
   std::vector<double> steps(strain_steps);
   std::iota(steps.begin(), steps.end(), 0.);
 
-  Matrix<Real> previous_grad_u_rot(3, 3, 0.);
-  Matrix<Real> previous_sigma(3, 3, 0.);
-  Matrix<Real> previous_sigma_rot(3, 3, 0.);
-  Matrix<Real> inelastic_strain_rot(3, 3, 0.);
-  Matrix<Real> inelastic_strain(3, 3, 0.);
-  Matrix<Real> previous_inelastic_strain(3, 3, 0.);
-  Matrix<Real> previous_inelastic_strain_rot(3, 3, 0.);
-  Matrix<Real> sigma_rot(3, 3, 0.);
+  Matrix<Real, 3, 3> previous_grad_u_rot = Matrix<Real, 3, 3>::Zero();
+  Matrix<Real, 3, 3> previous_sigma = Matrix<Real, 3, 3>::Zero();
+  Matrix<Real, 3, 3> previous_sigma_rot = Matrix<Real, 3, 3>::Zero();
+  Matrix<Real, 3, 3> inelastic_strain_rot = Matrix<Real, 3, 3>::Zero();
+  Matrix<Real, 3, 3> inelastic_strain = Matrix<Real, 3, 3>::Zero();
+  Matrix<Real, 3, 3> previous_inelastic_strain = Matrix<Real, 3, 3>::Zero();
+  Matrix<Real, 3, 3> previous_inelastic_strain_rot = Matrix<Real, 3, 3>::Zero();
+  Matrix<Real, 3, 3> sigma_rot = Matrix<Real, 3, 3>::Zero();
+
   Real iso_hardening = 0.;
   Real previous_iso_hardening = 0.;
 
   // hydrostatic loading (should not plastify)
   for (auto && i : steps) {
     auto t = i * dt;
 
     auto grad_u = this->getHydrostaticStrain(t);
     auto grad_u_rot = this->applyRotation(grad_u, rotation_matrix);
 
-    this->computeStressOnQuad(grad_u_rot, previous_grad_u_rot, sigma_rot,
-                              previous_sigma_rot, inelastic_strain_rot,
-                              previous_inelastic_strain_rot, iso_hardening,
-                              previous_iso_hardening, 0., 0.);
+    this->computeStressOnQuad(make_named_tuple(
+        tuple::get<"grad_u"_h>() = grad_u_rot,
+        tuple::get<"sigma"_h>() = sigma_rot,
+        tuple::get<"previous_sigma"_h>() = previous_sigma_rot,
+        tuple::get<"previous_grad_u"_h>() = previous_grad_u_rot,
+        tuple::get<"inelastic_strain"_h>() = inelastic_strain_rot,
+        tuple::get<"previous_inelastic_strain"_h>() =
+            previous_inelastic_strain_rot,
+        tuple::get<"iso_hardening"_h>() = iso_hardening,
+        tuple::get<"previous_iso_hardening"_h>() = previous_iso_hardening));
 
     auto sigma = this->reverseRotation(sigma_rot, rotation_matrix);
 
-    Matrix<Real> sigma_expected =
-        t * 3. * bulk_modulus_K * Matrix<Real>::eye(3, 1.);
+    Matrix<Real, 3, 3> sigma_expected =
+        t * 3. * bulk_modulus_K * Matrix<Real, 3, 3>::Identity();
 
     Real stress_error = (sigma - sigma_expected).lpNorm<Eigen::Infinity>();
 
     ASSERT_NEAR(stress_error, 0., 1e-13);
     ASSERT_NEAR(inelastic_strain_rot.lpNorm<Eigen::Infinity>(), 0., 1e-13);
 
     previous_grad_u_rot = grad_u_rot;
     previous_sigma_rot = sigma_rot;
     previous_inelastic_strain_rot = inelastic_strain_rot;
     previous_iso_hardening = iso_hardening;
   }
 
   // deviatoric loading (should plastify)
   // stress at onset of plastication
   Real beta = sqrt(42);
   Real t_P = sigma_0 / 2. / shear_modulus_mu / beta;
   Matrix<Real> sigma_P = sigma_0 / beta * this->getDeviatoricStrain(1.);
 
   for (auto && i : steps) {
 
     auto t = i * dt;
     auto grad_u = this->getDeviatoricStrain(t);
     auto grad_u_rot = this->applyRotation(grad_u, rotation_matrix);
     Real iso_hardening{0.};
     Real previous_iso_hardening{0.};
 
-    this->computeStressOnQuad(grad_u_rot, previous_grad_u_rot, sigma_rot,
-                              previous_sigma_rot, inelastic_strain_rot,
-                              previous_inelastic_strain_rot, iso_hardening,
-                              previous_iso_hardening, 0., 0.);
+    this->computeStressOnQuad(make_named_tuple(
+        tuple::get<"grad_u"_h>() = grad_u_rot,
+        tuple::get<"sigma"_h>() = sigma_rot,
+        tuple::get<"previous_grad_u"_h>() = previous_grad_u_rot,
+        tuple::get<"previous_sigma"_h>() = previous_sigma_rot,
+        tuple::get<"inelastic_strain"_h>() = inelastic_strain_rot,
+        tuple::get<"previous_inelastic_strain"_h>() =
+            previous_inelastic_strain_rot,
+        tuple::get<"iso_hardening"_h>() = iso_hardening,
+        tuple::get<"previous_iso_hardening"_h>() = previous_iso_hardening));
 
     auto sigma = this->reverseRotation(sigma_rot, rotation_matrix);
     auto inelastic_strain =
         this->reverseRotation(inelastic_strain_rot, rotation_matrix);
 
     if (t < t_P) {
-
       Matrix<Real> sigma_expected =
           shear_modulus_mu * (grad_u + grad_u.transpose());
 
       Real stress_error = (sigma - sigma_expected).lpNorm<Eigen::Infinity>();
       ASSERT_NEAR(stress_error, 0., 1e-13);
       ASSERT_NEAR(inelastic_strain_rot.lpNorm<Eigen::Infinity>(), 0., 1e-13);
     } else if (t > t_P + dt) {
       // skip the transition from non plastic to plastic
 
       auto delta_lambda_expected =
           dt / t * previous_sigma.doubleDot(grad_u + grad_u.transpose()) / 2.;
       auto delta_inelastic_strain_expected =
           delta_lambda_expected * 3. / 2. / sigma_0 * previous_sigma;
       auto inelastic_strain_expected =
           delta_inelastic_strain_expected + previous_inelastic_strain;
       ASSERT_NEAR((inelastic_strain - inelastic_strain_expected)
                       .lpNorm<Eigen::Infinity>(),
                   0., 1e-13);
       auto delta_sigma_expected =
           2. * shear_modulus_mu *
           (0.5 * dt / t * (grad_u + grad_u.transpose()) -
            delta_inelastic_strain_expected);
 
       auto delta_sigma = sigma - previous_sigma;
       ASSERT_NEAR(
           (delta_sigma_expected - delta_sigma).lpNorm<Eigen::Infinity>(), 0.,
           1e-13);
     }
     previous_sigma = sigma;
     previous_sigma_rot = sigma_rot;
     previous_grad_u_rot = grad_u_rot;
     previous_inelastic_strain = inelastic_strain;
     previous_inelastic_strain_rot = inelastic_strain_rot;
   }
 }
 
 namespace {
 
 template <typename T>
 class TestPlasticMaterialFixture : public ::TestMaterialFixture<T> {};
 
 TYPED_TEST_SUITE(TestPlasticMaterialFixture, mat_types, );
 
 TYPED_TEST(TestPlasticMaterialFixture, ComputeStress) {
   this->material->testComputeStress();
 }
 TYPED_TEST(TestPlasticMaterialFixture, DISABLED_EnergyDensity) {
   this->material->testEnergyDensity();
 }
 TYPED_TEST(TestPlasticMaterialFixture, DISABLED_ComputeTangentModuli) {
   this->material->testComputeTangentModuli();
 }
 TYPED_TEST(TestPlasticMaterialFixture, DISABLED_ComputeCelerity) {
   this->material->testCelerity();
 }
 } // namespace
 
 /*****************************************************************/
diff --git a/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_bernoulli_beam_2.cc b/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_bernoulli_beam_2.cc
index f1a5d1772..bc43e767c 100644
--- a/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_bernoulli_beam_2.cc
+++ b/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_bernoulli_beam_2.cc
@@ -1,115 +1,115 @@
 /**
  * @file   test_structural_mechanics_model_bernoulli_beam_2.cc
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Thu Feb 25 2021
  *
  * @brief  Computation of the analytical exemple 1.1 in the TGC vol 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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "test_structural_mechanics_model_fixture.hh"
 /* -------------------------------------------------------------------------- */
 #include <gtest/gtest.h>
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 class TestStructBernoulli2
     : public TestStructuralFixture<element_type_t<_bernoulli_beam_2>> {
   using parent = TestStructuralFixture<element_type_t<_bernoulli_beam_2>>;
 
 public:
   void addMaterials() override {
     mat.E = 3e10;
     mat.I = 0.0025;
     mat.A = 0.01;
 
     this->model->addMaterial(mat);
 
     mat.E = 3e10;
     mat.I = 0.00128;
     mat.A = 0.01;
 
     this->model->addMaterial(mat);
   }
 
   void assignMaterials() override {
     auto & materials = this->model->getElementMaterial(parent::type);
     materials(0) = 0;
     materials(1) = 1;
   }
 
   void setDirichletBCs() override {
     auto boundary = this->model->getBlockedDOFs().begin(parent::ndof);
     // clang-format off
-    *boundary = {true, true, true}; ++boundary;
-    *boundary = {false, true, false}; ++boundary;
-    *boundary = {false, true, false}; ++boundary;
+    *boundary = Vector<bool>{true, true, true}; ++boundary;
+    *boundary = Vector<bool>{false, true, false}; ++boundary;
+    *boundary = Vector<bool>{false, true, false}; ++boundary;
     // clang-format on
   }
 
   void setNeumannBCs() override {
     Real M = 3600; // Nm
     Real q = 6000; // kN/m
     Real L = 10;   // m
     auto & forces = this->model->getExternalForce();
     forces(2, 2) = -M; // moment on last node
 #if 1                  // as long as integration is not available
     forces(0, 1) = -q * L / 2;
     forces(0, 2) = -q * L * L / 12;
     forces(1, 1) = -q * L / 2;
     forces(1, 2) = q * L * L / 12;
 #else
     auto & group = mesh.createElementGroup("lin_force");
     group.add({type, 0, _not_ghost});
     Vector<Real> lin_force = {0, q, 0};
     // a linear force is not actually a *boundary* condition
     // it is equivalent to a volume force
     model.applyBC(BC::Neumann::FromSameDim(lin_force), group);
 #endif
     forces(2, 0) = mat.E * mat.A / 18;
   }
 
 protected:
   StructuralMaterial mat;
 };
 
 /* -------------------------------------------------------------------------- */
 
 TEST_F(TestStructBernoulli2, TestDisplacements) {
   model->solveStep();
   auto d1 = model->getDisplacement()(1, 2);
   auto d2 = model->getDisplacement()(2, 2);
   auto d3 = model->getDisplacement()(1, 0);
 
   Real tol = Math::getTolerance();
 
   EXPECT_NEAR(d1, 5.6 / 4800, tol);  // first rotation
   EXPECT_NEAR(d2, -3.7 / 4800, tol); // second rotation
   EXPECT_NEAR(d3, 10. / 18, tol);    // axial deformation
 }
diff --git a/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_bernoulli_beam_3.cc b/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_bernoulli_beam_3.cc
index f24169ec4..a0ca69d11 100644
--- a/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_bernoulli_beam_3.cc
+++ b/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_bernoulli_beam_3.cc
@@ -1,99 +1,99 @@
 /**
  * @file   test_structural_mechanics_model_bernoulli_beam_3.cc
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Thu Feb 25 2021
  *
  * @brief  Computation of the analytical exemple 1.1 in the TGC vol 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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "test_structural_mechanics_model_fixture.hh"
 /* -------------------------------------------------------------------------- */
 #include <gtest/gtest.h>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 class TestStructBernoulli3Static
     : public TestStructuralFixture<element_type_t<_bernoulli_beam_3>> {
   using parent = TestStructuralFixture<element_type_t<_bernoulli_beam_3>>;
 
 public:
   void readMesh(std::string filename) override { parent::readMesh(filename); }
 
   void setNormals() override {
     auto & normals = this->mesh->getData<Real>("extra_normal", parent::type);
     normals(0, _z) = 1;
     normals(1, _z) = 1;
   }
 
   void addMaterials() override {
     StructuralMaterial mat;
     mat.E = 1;
     mat.Iz = 1;
     mat.Iy = 1;
     mat.A = 1;
     mat.GJ = 1;
     this->model->addMaterial(mat);
   }
 
   void setDirichletBCs() override {
     // Boundary conditions (blocking all DOFs of nodes 2 & 3)
     auto boundary = ++this->model->getBlockedDOFs().begin(parent::ndof);
     // clang-format off
-    *boundary = {true, true, true, true, true, true}; ++boundary;
-    *boundary = {true, true, true, true, true, true}; ++boundary;
+    *boundary = Vector<bool>{true, true, true, true, true, true}; ++boundary;
+    *boundary = Vector<bool>{true, true, true, true, true, true}; ++boundary;
     // clang-format on
   }
 
   void setNeumannBCs() override {
     // Forces
     Real P = 1; // N
     auto & forces = this->model->getExternalForce();
     forces.zero();
     forces(0, 2) = -P; // vertical force on first node
   }
 
   void assignMaterials() override {
     model->getElementMaterial(parent::type).set(0);
   }
 };
 
 /* -------------------------------------------------------------------------- */
 TEST_F(TestStructBernoulli3Static, TestDisplacements) {
   model->solveStep();
   auto vz = model->getDisplacement()(0, 2);
   auto thy = model->getDisplacement()(0, 4);
   auto thx = model->getDisplacement()(0, 3);
   auto thz = model->getDisplacement()(0, 5);
 
   Real tol = Math::getTolerance();
 
   EXPECT_NEAR(vz, -5. / 48, tol);
   EXPECT_NEAR(thy, -std::sqrt(2) / 8, tol);
   EXPECT_NEAR(thz, 0, tol);
   EXPECT_NEAR(thx, 0, tol);
 }
diff --git a/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_bernoulli_beam_dynamics.cc b/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_bernoulli_beam_dynamics.cc
index 4aa090ae8..869b3f597 100644
--- a/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_bernoulli_beam_dynamics.cc
+++ b/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_bernoulli_beam_dynamics.cc
@@ -1,369 +1,371 @@
 /**
  * @file   test_structural_mechanics_model_bernoulli_beam_dynamics.cc
  *
  * @author Sébastien Hartmann <sebastien.hartmann@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Mon Mar 15 2021
  *
  * @brief  Test for _bernouilli_beam in dynamic
  *
  *
  * @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 "test_structural_mechanics_model_fixture.hh"
 /* -------------------------------------------------------------------------- */
 #include "dof_manager.hh"
 #include "mesh_accessor.hh"
 #include "non_linear_solver_newton_raphson.hh"
 #include "structural_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 #include <iostream>
 #include <limits>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 static Real analytical_solution(Real time, Real L, Real rho, Real E,
                                 __attribute__((unused)) Real A, Real I,
                                 Real F) {
   Real omega = M_PI * M_PI / L / L * sqrt(E * I / rho);
   Real sum = 0.;
   UInt i = 5;
   for (UInt n = 1; n <= i; n += 2) {
     sum += (1. - cos(n * n * omega * time)) / pow(n, 4);
   }
 
   return 2. * F * pow(L, 3) / pow(M_PI, 4) / E / I * sum;
 }
 
 template <class Type>
 class TestStructBernoulliDynamic : public TestStructuralFixture<Type> {
   using parent = TestStructuralFixture<Type>;
 
 public:
   const UInt nb_element{40};
   const Real L{2};
   const Real le{L / nb_element};
 
   const UInt nb_nodes{nb_element + 1};
   const Real F{1e4};
 
   StructuralMaterial mat;
 
   void readMesh(std::string /*filename*/) override {
     MeshAccessor mesh_accessor(*this->mesh);
     auto & nodes = mesh_accessor.getNodes();
     nodes.resize(nb_nodes);
 
     nodes.set(0.);
 
     for (auto && data : enumerate(make_view(nodes, this->spatial_dimension))) {
       auto & node = std::get<1>(data);
-      UInt i = std::get<0>(data);
+      Int i = std::get<0>(data);
       node[_x] = i * le;
     }
 
     this->mesh->addConnectivityType(parent::type);
     auto & connectivities = mesh_accessor.getConnectivity(parent::type);
     connectivities.resize(nb_element);
     for (auto && data : enumerate(make_view(connectivities, 2))) {
-      UInt i = std::get<0>(data);
+      Idx i = std::get<0>(data);
       auto & connectivity = std::get<1>(data);
 
-      connectivity = {i, i + 1};
+      connectivity = Vector<Idx>{i, i + 1};
     }
 
     mesh_accessor.makeReady();
   }
 
   void setNormals() override {
     if (this->spatial_dimension != 3) {
       return;
     }
     auto & normals =
         this->mesh->template getData<Real>("extra_normal", parent::type);
     normals.resize(nb_element);
 
     for (auto && normal : make_view(normals, this->spatial_dimension)) {
-      normal = {0., 0., 1.};
+      normal = Vector<Real>{0., 0., 1.};
     }
   }
 
   AnalysisMethod getAnalysisMethod() const override {
     return _implicit_dynamic;
   }
 
   void addMaterials() override {
     this->mat.E = 1e9;
     this->mat.rho = 10;
     this->mat.I = 1;
     this->mat.Iz = 1;
     this->mat.Iy = 1;
     this->mat.A = 1;
     this->mat.GJ = 1;
 
     this->model->addMaterial(mat);
   }
 
   void setDirichletBCs() override {
     auto & boundary = this->model->getBlockedDOFs();
     boundary.set(false);
 
     boundary(0, _x) = true;
     boundary(0, _y) = true;
 
     boundary(nb_nodes - 1, _y) = true;
 
     if (this->spatial_dimension == 3) {
       boundary(0, _z) = true;
       boundary(nb_nodes - 1, _z) = true;
     }
   }
 
   void setNeumannBCs() override {
     auto node_to_print = nb_nodes / 2;
     // Forces
     auto & forces = this->model->getExternalForce();
     forces.zero();
     forces(node_to_print, _y) = F;
   }
 
   void assignMaterials() override {
     this->model->getElementMaterial(parent::type).set(0);
   }
 };
 
 using beam_types = gtest_list_t<std::tuple<element_type_t<_bernoulli_beam_2>,
                                            element_type_t<_bernoulli_beam_3>>>;
 
 TYPED_TEST_SUITE(TestStructBernoulliDynamic, beam_types, );
 
 template <class Type>
 void getElementMassMatrix(const StructuralMaterial & /*material*/, Real /*l*/,
                           Matrix<Real> & /*M*/) {}
 
 template <class Type>
 void getElementStifnessMatrix(const StructuralMaterial & /*material*/,
                               Real /*l*/, Matrix<Real> & /*M*/) {}
 
 template <>
 void getElementMassMatrix<element_type_t<_bernoulli_beam_2>>(
     const StructuralMaterial & material, Real l, Matrix<Real> & M) {
   auto A = material.A;
   auto rho = material.rho;
   // clang-format off
   M = rho * A * l / 420. * Matrix<Real>({
       {140,    0,      0,  70,     0,      0},
       {  0,  156,   22*l,   0,    54,  -13*l},
       {  0, 22*l,  4*l*l,   0,  13*l, -3*l*l},
       { 70,    0,      0, 140,     0,      0},
       {  0,   54,   13*l,   0,   156,  -22*l},
       {  0,-13*l, -3*l*l,   0, -22*l,  4*l*l}});
   // clang-format on
 }
 
 template <>
 void getElementStifnessMatrix<element_type_t<_bernoulli_beam_2>>(
     const StructuralMaterial & material, Real l, Matrix<Real> & K) {
   auto E = material.E;
   auto A = material.A;
   auto I = material.I;
 
   auto l_2 = l * l;
   auto l_3 = l * l * l;
   // clang-format off
   K = Matrix<Real>({
       { E*A/l,           0,          0, -E*A/l,           0,          0},
       {     0,  12*E*I/l_3,  6*E*I/l_2,      0, -12*E*I/l_3,  6*E*I/l_2},
       {     0,   6*E*I/l_2,    4*E*I/l,      0,  -6*E*I/l_2,    2*E*I/l},
       {-E*A/l,           0,          0,  E*A/l,           0,          0},
       {     0, -12*E*I/l_3, -6*E*I/l_2,      0,  12*E*I/l_3, -6*E*I/l_2},
       {     0,   6*E*I/l_2,    2*E*I/l,      0,  -6*E*I/l_2,    4*E*I/l}});
   // clang-format on
 }
 
 template <>
 void getElementMassMatrix<element_type_t<_bernoulli_beam_3>>(
     const StructuralMaterial & material, Real l, Matrix<Real> & M) {
   auto A = material.A;
   auto rho = material.rho;
   // clang-format off
   M = rho * A * l / 420. * Matrix<Real>({
       {140,     0,       0,   0,      0,      0,  70,     0,     0,   0,      0,      0},
       {  0,   156,       0,   0,      0,   22*l,   0,    54,     0,   0,      0,  -13*l},
       {  0,     0,     156,   0,  -22*l,      0,   0,     0,    54,   0,   13*l,      0},
       {  0,     0,       0, 140,      0,      0,   0,     0,     0,  70,      0,      0},
       {  0,     0,   -22*l,   0,  4*l*l,      0,   0,     0, -13*l,   0, -3*l*l,      0},
       {  0,  22*l,       0,   0,      0,  4*l*l,   0,  13*l,     0,   0,      0, -3*l*l},
       { 70,     0,       0,   0,      0,      0, 140,     0,     0,   0,      0,      0},
       {  0,    54,       0,   0,      0,   13*l,   0,   156,     0,   0,      0,  -22*l},
       {  0,     0,      54,   0,  -13*l,      0,   0,     0,   156,   0,   22*l,      0},
       {  0,     0,       0,  70,      0,      0,   0,     0,     0, 140,      0,      0},
       {  0,     0,    13*l,   0, -3*l*l,      0,   0,     0,  22*l,   0,  4*l*l,      0},
       {  0, -13*l,       0,   0,      0, -3*l*l,   0, -22*l,     0,   0,      0,  4*l*l}});
   // clang-format on
 }
 
 template <>
 void getElementStifnessMatrix<element_type_t<_bernoulli_beam_3>>(
     const StructuralMaterial & material, Real l, Matrix<Real> & K) {
   auto E = material.E;
   auto A = material.A;
   auto Iy = material.Iy;
   auto Iz = material.Iz;
   auto GJ = material.GJ;
 
   auto a1 = E * A / l;
   auto b1 = 12 * E * Iz / l / l / l;
   auto b2 = 6 * E * Iz / l / l;
   auto b3 = 4 * E * Iz / l;
   auto b4 = 2 * E * Iz / l;
 
   auto c1 = 12 * E * Iy / l / l / l;
   auto c2 = 6 * E * Iy / l / l;
   auto c3 = 4 * E * Iy / l;
   auto c4 = 2 * E * Iy / l;
 
   auto d1 = GJ / l;
 
   // clang-format off
   K = Matrix<Real>({
       {  a1,   0,   0,   0,   0,   0, -a1,   0,   0,   0,   0,   0},
       {   0,  b1,   0,   0,   0,  b2,   0, -b1,   0,   0,   0,  b2},
       {   0,   0,  c1,   0, -c2,   0,   0,   0, -c1,   0, -c2,   0},
       {   0,   0,   0,  d1,   0,   0,   0,   0,   0, -d1,   0,   0},
       {   0,   0, -c2,   0,  c3,   0,   0,   0,  c2,   0,  c4,   0},
       {   0,  b2,   0,   0,   0,  b3,   0, -b2,   0,   0,   0,  b4},
       { -a1,   0,   0,   0,   0,   0,  a1,   0,   0,   0,   0,   0},
       {   0, -b1,   0,   0,   0, -b2,   0,  b1,   0,   0,   0, -b2},
       {   0,   0, -c1,   0,  c2,   0,   0,   0,  c1,   0,  c2,   0},
       {   0,   0,   0, -d1,   0,   0,   0,   0,   0,  d1,   0,   0},
       {   0,   0, -c2,   0,  c4,   0,   0,   0,  c2,   0,  c3,   0},
       {   0,  b2,   0,   0,   0,  b4,   0, -b2,   0,   0,   0,  b3}});
   // clang-format on
 }
 
 TYPED_TEST(TestStructBernoulliDynamic, TestBeamMatrices) {
   this->model->assembleMatrix("M");
   this->model->assembleMatrix("K");
 
   const auto & K = this->model->getDOFManager().getMatrix("K");
   const auto & M = this->model->getDOFManager().getMatrix("M");
 
-  Matrix<Real> Ka(this->nb_nodes * this->ndof, this->nb_nodes * this->ndof, 0.);
-  Matrix<Real> Ma(this->nb_nodes * this->ndof, this->nb_nodes * this->ndof, 0.);
+  Matrix<Real> Ka(this->nb_nodes * this->ndof, this->nb_nodes * this->ndof);
+  Matrix<Real> Ma(this->nb_nodes * this->ndof, this->nb_nodes * this->ndof);
+  Ka.zero();
+  Ma.zero();
 
   Matrix<Real> Ke(this->ndof * 2, this->ndof * 2);
   Matrix<Real> Me(this->ndof * 2, this->ndof * 2);
 
   getElementMassMatrix<TypeParam>(this->mat, this->le, Me);
   getElementStifnessMatrix<TypeParam>(this->mat, this->le, Ke);
 
   auto assemble = [&](auto && nodes, auto && M, auto && Me) {
     auto n1 = nodes[0];
     auto n2 = nodes[1];
     for (auto i : arange(this->ndof)) {
       for (auto j : arange(this->ndof)) {
         M(n1 * this->ndof + i, n1 * this->ndof + j) += Me(i, j);
         M(n2 * this->ndof + i, n2 * this->ndof + j) +=
             Me(this->ndof + i, this->ndof + j);
         M(n1 * this->ndof + i, n2 * this->ndof + j) += Me(i, this->ndof + j);
         M(n2 * this->ndof + i, n1 * this->ndof + j) += Me(this->ndof + i, j);
       }
     }
   };
 
   auto && connectivities = this->mesh->getConnectivity(this->type);
 
   for (auto && connectivity : make_view(connectivities, 2)) {
     assemble(connectivity, Ka, Ke);
     assemble(connectivity, Ma, Me);
   }
 
   auto tol = 1e-13;
 
   auto Ka_max = Ka.template lpNorm<Eigen::Infinity>();
   auto Ma_max = Ma.template lpNorm<Eigen::Infinity>();
 
   for (auto i : arange(Ka.rows())) {
     for (auto j : arange(Ka.cols())) {
       EXPECT_NEAR(Ka(i, j), K(i, j), tol * Ka_max);
       EXPECT_NEAR(Ma(i, j), M(i, j), tol * Ma_max);
     }
   }
 }
 
 TYPED_TEST(TestStructBernoulliDynamic, TestBeamOscilation) {
   Real time_step = 1e-6;
   this->model->setTimeStep(time_step);
 
   auto & solver = this->model->getNonLinearSolver();
   solver.set("max_iterations", 100);
   solver.set("threshold", 1e-8);
   solver.set("convergence_type", SolveConvergenceCriteria::_solution);
 
   auto node_to_print = this->nb_nodes / 2;
   auto & d = this->model->getDisplacement()(node_to_print, _y);
 
   std::ofstream pos;
   std::string filename = "position" + std::to_string(this->type) + ".csv";
   pos.open(filename);
   if (not pos.good()) {
     AKANTU_ERROR("Cannot open file \"position.csv\"");
   }
   pos << "id,time,position,solution" << std::endl;
 
 //#define debug
 #ifdef debug
   this->model->addDumpFieldVector("displacement");
   this->model->addDumpField("blocked_dofs");
   this->model->addDumpFieldVector("external_force");
   this->model->addDumpFieldVector("internal_force");
   this->model->addDumpFieldVector("acceleration");
   this->model->addDumpFieldVector("velocity");
   this->model->dump();
 #endif
 
   this->model->getDisplacement().set(0.);
 
   Real tol = 1e-6;
   Real time = 0.;
   for (UInt s = 1; s < 300; ++s) {
     EXPECT_NO_THROW(this->model->solveStep());
 
     time = s * time_step;
 
     auto da = analytical_solution(time, this->L, this->mat.rho, this->mat.E,
                                   this->mat.A, this->mat.Iy, this->F);
 
     pos << s << "," << time << "," << d << "," << da << std::endl;
 
 #ifdef debug
     this->model->dump();
 #endif
     EXPECT_NEAR(d, da, tol);
   }
 }
diff --git a/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_discrete_kirchhoff_triangle_18.cc b/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_discrete_kirchhoff_triangle_18.cc
index fb93700cc..4a127609b 100644
--- a/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_discrete_kirchhoff_triangle_18.cc
+++ b/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_discrete_kirchhoff_triangle_18.cc
@@ -1,113 +1,113 @@
 /**
  * @file   test_structural_mechanics_model_discrete_kirchhoff_triangle_18.cc
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Thu Feb 25 2021
  *
  * @brief  Computation of the analytical exemple 1.1 in the TGC vol 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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "sparse_matrix.hh"
 #include "test_structural_mechanics_model_fixture.hh"
 /* -------------------------------------------------------------------------- */
 #include <gtest/gtest.h>
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 class TestStructDKT18 : public TestStructuralFixture<
                             element_type_t<_discrete_kirchhoff_triangle_18>> {
   using parent =
       TestStructuralFixture<element_type_t<_discrete_kirchhoff_triangle_18>>;
 
 public:
   void addMaterials() override {
     mat.E = 1;
     mat.t = 1;
     mat.nu = 0.3;
 
     this->model->addMaterial(mat);
   }
 
   void assignMaterials() override {
     auto & materials = this->model->getElementMaterial(parent::type);
     std::fill(materials.begin(), materials.end(), 0);
   }
 
   void setDirichletBCs() override {
     this->model->getBlockedDOFs().set(true);
     auto center_node = this->model->getBlockedDOFs().end(parent::ndof) - 1;
-    *center_node = {false, false, false, false, false, true};
+    *center_node = Vector<bool>{false, false, false, false, false, true};
 
     this->model->getDisplacement().zero();
     auto disp = ++this->model->getDisplacement().begin(parent::ndof);
 
     // Displacement field from Batoz Vol. 2 p. 392
     // with theta to beta correction from discrete Kirchhoff condition
     // see also the master thesis of Michael Lozano
 
     // clang-format off
 
     // This displacement field tests membrane and bending modes
-    *disp = {40, 20, -800 , -20, 40, 0}; ++disp;
-    *disp = {50, 40, -1400, -40, 50, 0}; ++disp;
-    *disp = {10, 20, -200 , -20, 10, 0}; ++disp;
+    *disp = Vector<Real>{40, 20, -800 , -20, 40, 0}; ++disp;
+    *disp = Vector<Real>{50, 40, -1400, -40, 50, 0}; ++disp;
+    *disp = Vector<Real>{10, 20, -200 , -20, 10, 0}; ++disp;
 
     // This displacement tests the bending mode
     // *disp = {0, 0, -800 , -20, 40, 0}; ++disp;
     // *disp = {0, 0, -1400, -40, 50, 0}; ++disp;
     // *disp = {0, 0, -200 , -20, 10, 0}; ++disp;
 
     // This displacement tests the membrane mode
     // *disp = {40, 20, 0, 0, 0, 0}; ++disp;
     // *disp = {50, 40, 0, 0, 0, 0}; ++disp;
     // *disp = {10, 20, 0, 0, 0, 0}; ++disp;
 
     // clang-format on
   }
 
   void setNeumannBCs() override {}
 
 protected:
   StructuralMaterial mat;
 };
 
 /* -------------------------------------------------------------------------- */
 
 // Batoz Vol 2. patch test, ISBN 2-86601-259-3
 TEST_F(TestStructDKT18, TestDisplacements) {
   model->solveStep();
-  Vector<Real> solution = {22.5, 22.5, -337.5, -22.5, 22.5, 0};
+  Vector<Real> solution = Vector<Real>{22.5, 22.5, -337.5, -22.5, 22.5, 0};
   auto nb_nodes = this->model->getDisplacement().size();
 
   Vector<Real> center_node_disp =
       model->getDisplacement().begin(solution.size())[nb_nodes - 1];
 
   auto error = solution - center_node_disp;
 
-  EXPECT_NEAR(error.norm<L_2>(), 0., 1e-12);
+  EXPECT_NEAR(error.norm(), 0., 1e-12);
 }
diff --git a/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_fixture.hh b/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_fixture.hh
index 86ccef582..bd4fe8fef 100644
--- a/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_fixture.hh
+++ b/test/test_model/test_structural_mechanics_model/test_structural_mechanics_model_fixture.hh
@@ -1,117 +1,117 @@
 /**
  * @file   test_structural_mechanics_model_fixture.hh
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Nov 14 2017
  * @date last modification:  Thu Feb 25 2021
  *
  * @brief  Main test for structural model
  *
  *
  * @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 "element_class_structural.hh"
+#include "element_class.hh"
 #include "structural_mechanics_model.hh"
 #include "test_gtest_utils.hh"
 /* -------------------------------------------------------------------------- */
 #include <gtest/gtest.h>
 #include <vector>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_TEST_STRUCTURAL_MECHANICS_MODEL_FIXTURE_HH_
 #define AKANTU_TEST_STRUCTURAL_MECHANICS_MODEL_FIXTURE_HH_
 
 using namespace akantu;
 
 template <typename type_> class TestStructuralFixture : public ::testing::Test {
 public:
   static constexpr const ElementType type = type_::value;
-  static constexpr const size_t spatial_dimension =
+  static constexpr const Int spatial_dimension =
       ElementClass<type>::getSpatialDimension();
-  static const UInt ndof = ElementClass<type>::getNbDegreeOfFreedom();
+  static const Int ndof = ElementClass<type>::getNbDegreeOfFreedom();
 
   void SetUp() override {
     const auto spatial_dimension = this->spatial_dimension;
     mesh = std::make_unique<Mesh>(spatial_dimension);
     readMesh(makeMeshName());
 
     std::stringstream element_type;
     element_type << this->type;
     model = std::make_unique<StructuralMechanicsModel>(*mesh, _all_dimensions,
                                                        element_type.str());
 
     setNormals();
     initModel();
   }
 
   virtual void initModel() {
     this->addMaterials();
     auto method = getAnalysisMethod();
 
     this->model->initFull(_analysis_method = method);
 
     this->assignMaterials();
 
     this->setDirichletBCs();
     this->setNeumannBCs();
   }
 
   virtual AnalysisMethod getAnalysisMethod() const { return _static; }
 
   virtual void readMesh(std::string filename) {
     mesh->read(filename, _miot_gmsh_struct);
   }
 
   virtual std::string makeMeshName() {
     std::stringstream element_type;
     element_type << type;
     SCOPED_TRACE(element_type.str().c_str());
     return element_type.str() + ".msh";
   }
 
   void TearDown() override {
     model.reset(nullptr);
     mesh.reset(nullptr);
   }
 
   virtual void addMaterials() = 0;
   virtual void assignMaterials() = 0;
   virtual void setDirichletBCs() = 0;
   virtual void setNeumannBCs() = 0;
   virtual void setNormals() {}
 
 protected:
   std::unique_ptr<Mesh> mesh;
   std::unique_ptr<StructuralMechanicsModel> model;
 };
 
 template <typename type_>
 constexpr ElementType TestStructuralFixture<type_>::type;
 template <typename type_>
-constexpr size_t TestStructuralFixture<type_>::spatial_dimension;
-template <typename type_> const UInt TestStructuralFixture<type_>::ndof;
+constexpr Int TestStructuralFixture<type_>::spatial_dimension;
+template <typename type_> const Int TestStructuralFixture<type_>::ndof;
 
-using structural_types = gtest_list_t<StructuralTestElementTypes>;
+using structural_types = gtest_list_t<ElementTypes_t<_ek_structural>>;
 
 #endif /* AKANTU_TEST_STRUCTURAL_MECHANICS_MODEL_FIXTURE_HH_ */
diff --git a/test/test_python_interface/test_common.cc b/test/test_python_interface/test_common.cc
index 29bd144e8..816635a1c 100644
--- a/test/test_python_interface/test_common.cc
+++ b/test/test_python_interface/test_common.cc
@@ -1,156 +1,156 @@
 /**
  * @file   test_common.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Oct 31 2018
  * @date last modification:  Tue Jun 30 2020
  *
  * @brief  pybind11 interface for test
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "py_akantu.hh"
 /* -------------------------------------------------------------------------- */
 #include <pybind11/pybind11.h>
 /* -------------------------------------------------------------------------- */
 #include <map>
 /* -------------------------------------------------------------------------- */
 
 namespace py = pybind11;
 namespace _aka = akantu;
 
 std::map<long, std::shared_ptr<_aka::Array<_aka::Real>>> arrays;
 std::map<long, std::shared_ptr<_aka::Vector<_aka::Real>>> vectors;
 std::map<long, std::shared_ptr<_aka::Matrix<_aka::Real>>> matrices;
 
 PYBIND11_MODULE(py11_akantu_test_common, mod) {
   mod.doc() = "Akantu Test function for common ";
 
   mod.def(
       "createArray",
       [&](_aka::UInt size, _aka::UInt nb_components) {
         auto ptr =
             std::make_shared<_aka::Array<_aka::Real>>(size, nb_components);
         ptr->zero();
-        long addr = (long)ptr->storage();
+        long addr = (long)ptr->data();
         py::print("initial pointer: " + std::to_string(addr));
         arrays[addr] = ptr;
         return std::tuple<long, _aka::Array<_aka::Real> &>(addr, *ptr);
       },
       py::return_value_policy::reference);
   mod.def(
       "getArray",
       [&](long addr) -> _aka::Array<_aka::Real> & {
         auto & array = *arrays[addr];
         py::print("gotten pointer: " + std::to_string((long)array.data()));
         return array;
       },
       py::return_value_policy::reference);
 
   mod.def(
       "copyArray",
       [&](long addr) -> _aka::Array<_aka::Real> {
         auto & array = *arrays[addr];
         py::print("gotten pointer: " + std::to_string((long)array.data()));
         return array;
       },
       py::return_value_policy::copy);
 
   mod.def("getRawPointerArray", [](_aka::Array<_aka::Real> & _data) {
     py::print("received proxy: " + std::to_string((long)&_data));
     py::print("raw pointer: " + std::to_string((long)_data.data()));
     return (long)_data.data();
   });
 
   mod.def(
       "createVector",
       [&](_aka::Int size) {
         auto ptr = std::make_shared<_aka::Vector<_aka::Real>>(size);
         ptr->zero();
         long addr = (long)ptr->data();
         py::print("initial pointer: " + std::to_string(addr));
         vectors[addr] = ptr;
         return std::tuple<long, _aka::Vector<_aka::Real> &>(addr, *ptr);
       },
       py::return_value_policy::reference);
   mod.def(
       "getVector",
       [&](long addr) -> _aka::Vector<_aka::Real> & {
         auto & vector = *vectors[addr];
         py::print("gotten pointer: " + std::to_string((long)vector.data()));
         return vector;
       },
       py::return_value_policy::reference);
 
   mod.def(
       "copyVector",
       [&](long addr) -> _aka::Vector<_aka::Real> {
         auto & vector = *vectors[addr];
         py::print("gotten pointer: " + std::to_string((long)vector.data()));
         return vector;
       },
       py::return_value_policy::copy);
 
   mod.def("getRawPointerVector", [](_aka::Vector<_aka::Real> & _data) {
     py::print("received proxy: " + std::to_string((long)&_data));
     py::print("raw pointer: " + std::to_string((long)_data.data()));
     return (long)_data.data();
   });
 
   mod.def(
       "createMatrix",
-      [&](_aka::UInt size1, _aka::UInt size2) {
+      [&](_aka::Int size1, _aka::Int size2) {
         auto ptr = std::make_shared<_aka::Matrix<_aka::Real>>(size1, size2);
         ptr->zero();
-        long addr = (long)ptr->storage();
+        long addr = (long)ptr->data();
         py::print("initial pointer: " + std::to_string(addr));
         matrices[addr] = ptr;
         return std::tuple<long, _aka::Matrix<_aka::Real> &>(addr, *ptr);
       },
       py::return_value_policy::reference);
   mod.def(
       "getMatrix",
       [&](long addr) -> _aka::Matrix<_aka::Real> & {
         auto & matrix = *matrices[addr];
         py::print("gotten pointer: " + std::to_string((long)matrix.data()));
         return matrix;
       },
       py::return_value_policy::reference);
 
   mod.def(
       "copyMatrix",
       [&](long addr) -> _aka::Matrix<_aka::Real> {
         auto & matrix = *matrices[addr];
         py::print("gotten pointer: " + std::to_string((long)matrix.data()));
         return matrix;
       },
       py::return_value_policy::copy);
 
   mod.def("getRawPointerMatrix", [](_aka::Matrix<_aka::Real> & _data) {
     py::print("received proxy: " + std::to_string((long)&_data));
     py::print("raw pointer: " + std::to_string((long)_data.data()));
     return (long)_data.data();
   });
 } // Module akantu_test_common
diff --git a/test/test_solver/test_petsc_matrix_apply_boundary.cc b/test/test_solver/test_petsc_matrix_apply_boundary.cc
index 3a2682a97..828bd8fa1 100644
--- a/test/test_solver/test_petsc_matrix_apply_boundary.cc
+++ b/test/test_solver/test_petsc_matrix_apply_boundary.cc
@@ -1,150 +1,150 @@
 /**
  * @file   test_petsc_matrix_apply_boundary.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Wed Nov 08 2017
  *
  * @brief  test the applyBoundary method of the PETScMatrix class
  *
  *
  * @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 <cstdlib>
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_csr.hh"
 #include "communicator.hh"
 #include "dof_synchronizer.hh"
 #include "element_synchronizer.hh"
 #include "fe_engine.hh"
 #include "mesh.hh"
 #include "mesh_io.hh"
 #include "mesh_utils.hh"
 #include "petsc_matrix.hh"
 
 #include "mesh_partition_scotch.hh"
 
 using namespace akantu;
 int main(int argc, char * argv[]) {
 
   initialize(argc, argv);
   const ElementType element_type = _triangle_3;
   const GhostType ghost_type = _not_ghost;
-  UInt spatial_dimension = 2;
+  Int spatial_dimension = 2;
 
   const auto & comm = akantu::Communicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   /// read the mesh and partition it
   Mesh mesh(spatial_dimension);
 
   /* ------------------------------------------------------------------------ */
   /* Parallel initialization                                                  */
   /* ------------------------------------------------------------------------ */
   ElementSynchronizer * communicator = NULL;
   if (prank == 0) {
     /// creation mesh
     mesh.read("triangle.msh");
     MeshPartitionScotch * partition =
         new MeshPartitionScotch(mesh, spatial_dimension);
     partition->partitionate(psize);
     communicator =
         ElementSynchronizer::createDistributedSynchronizerMesh(mesh, partition);
     delete partition;
   } else {
     communicator =
         ElementSynchronizer::createDistributedSynchronizerMesh(mesh, NULL);
   }
 
   FEEngine * fem =
       new FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_regular>(
           mesh, spatial_dimension, "my_fem");
 
   DOFSynchronizer dof_synchronizer(mesh, spatial_dimension);
-  UInt nb_global_nodes = mesh.getNbGlobalNodes();
+  Int nb_global_nodes = mesh.getNbGlobalNodes();
 
   dof_synchronizer.initGlobalDOFEquationNumbers();
 
   // fill the matrix with
-  UInt nb_element = mesh.getNbElement(element_type);
-  UInt nb_nodes_per_element = mesh.getNbNodesPerElement(element_type);
-  UInt nb_dofs_per_element = spatial_dimension * nb_nodes_per_element;
+  Int nb_element = mesh.getNbElement(element_type);
+  Int nb_nodes_per_element = mesh.getNbNodesPerElement(element_type);
+  Int nb_dofs_per_element = spatial_dimension * nb_nodes_per_element;
   SparseMatrix K(nb_global_nodes * spatial_dimension, _symmetric);
   K.buildProfile(mesh, dof_synchronizer, spatial_dimension);
   Matrix<Real> element_input(nb_dofs_per_element, nb_dofs_per_element, 1);
   Array<Real> K_e =
       Array<Real>(nb_element, nb_dofs_per_element * nb_dofs_per_element, "K_e");
   Array<Real>::matrix_iterator K_e_it =
       K_e.begin(nb_dofs_per_element, nb_dofs_per_element);
   Array<Real>::matrix_iterator K_e_end =
       K_e.end(nb_dofs_per_element, nb_dofs_per_element);
 
   for (; K_e_it != K_e_end; ++K_e_it)
     *K_e_it = element_input;
 
   // assemble the test matrix
   fem->assembleMatrix(K_e, K, spatial_dimension, element_type, ghost_type);
 
   // create petsc matrix
   PETScMatrix petsc_matrix(nb_global_nodes * spatial_dimension, _symmetric);
 
   petsc_matrix.buildProfile(mesh, dof_synchronizer, spatial_dimension);
 
   // add stiffness matrix to petsc matrix
   petsc_matrix.add(K, 1);
 
   // create boundary array: block all dofs
-  UInt nb_nodes = mesh.getNbNodes();
+  Int nb_nodes = mesh.getNbNodes();
   Array<bool> boundary = Array<bool>(nb_nodes, spatial_dimension, true);
 
   // apply boundary
   petsc_matrix.applyBoundary(boundary);
 
   // test if all entries except the diagonal ones have been zeroed
   Real test_passed = 0;
 
-  for (UInt i = 0; i < nb_nodes * spatial_dimension; ++i) {
+  for (Int i = 0; i < nb_nodes * spatial_dimension; ++i) {
     if (dof_synchronizer.isLocalOrMasterDOF(i)) {
-      for (UInt j = 0; j < nb_nodes * spatial_dimension; ++j) {
+      for (Int j = 0; j < nb_nodes * spatial_dimension; ++j) {
         if (dof_synchronizer.isLocalOrMasterDOF(j)) {
           if (i == j)
             test_passed += petsc_matrix(i, j) - 1;
           else
             test_passed += petsc_matrix(i, j) - 0;
         }
       }
     }
   }
 
   if (std::abs(test_passed) > Math::getTolerance()) {
     finalize();
     return EXIT_FAILURE;
   }
   delete communicator;
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_solver/test_petsc_matrix_diagonal.cc b/test/test_solver/test_petsc_matrix_diagonal.cc
index 52b6cabf6..9c7d4a915 100644
--- a/test/test_solver/test_petsc_matrix_diagonal.cc
+++ b/test/test_solver/test_petsc_matrix_diagonal.cc
@@ -1,163 +1,163 @@
 /**
  * @file   test_petsc_matrix_diagonal.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Wed Nov 08 2017
  *
  * @brief  test the connectivity is correctly represented in the PETScMatrix
  *
  *
  * @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 <iostream>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_csr.hh"
 #include "communicator.hh"
 #include "dof_synchronizer.hh"
 #include "dumper_paraview.hh"
 #include "element_synchronizer.hh"
 #include "fe_engine.hh"
 #include "mesh.hh"
 #include "mesh_io.hh"
 #include "mesh_partition_scotch.hh"
 #include "mesh_utils.hh"
 #include "petsc_matrix.hh"
 
 using namespace akantu;
 int main(int argc, char * argv[]) {
 
   initialize(argc, argv);
   const ElementType element_type = _triangle_3;
   const GhostType ghost_type = _not_ghost;
-  UInt spatial_dimension = 2;
+  Int spatial_dimension = 2;
 
   const auto & comm = akantu::Communicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   /// read the mesh and partition it
   Mesh mesh(spatial_dimension);
 
   /* ------------------------------------------------------------------------ */
   /* Parallel initialization                                                  */
   /* ------------------------------------------------------------------------ */
   ElementSynchronizer * communicator = NULL;
   if (prank == 0) {
     /// creation mesh
     mesh.read("triangle.msh");
     MeshPartitionScotch * partition =
         new MeshPartitionScotch(mesh, spatial_dimension);
     partition->partitionate(psize);
     communicator =
         ElementSynchronizer::createDistributedSynchronizerMesh(mesh, partition);
     delete partition;
   } else {
     communicator =
         ElementSynchronizer::createDistributedSynchronizerMesh(mesh, NULL);
   }
 
   // DumperParaview mesh_dumper("mesh_dumper");
   // mesh_dumper.registerMesh(mesh, spatial_dimension, _not_ghost);
   // mesh_dumper.dump();
 
   /// initialize the FEEngine and the dof_synchronizer
   FEEngine * fem =
       new FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_regular>(
           mesh, spatial_dimension, "my_fem");
 
   DOFSynchronizer dof_synchronizer(mesh, spatial_dimension);
-  UInt nb_global_nodes = mesh.getNbGlobalNodes();
+  Int nb_global_nodes = mesh.getNbGlobalNodes();
 
   dof_synchronizer.initGlobalDOFEquationNumbers();
 
   // construct an Akantu sparse matrix, build the profile and fill the matrix
   // for the given mesh
-  UInt nb_element = mesh.getNbElement(element_type);
-  UInt nb_nodes_per_element = mesh.getNbNodesPerElement(element_type);
-  UInt nb_dofs_per_element = spatial_dimension * nb_nodes_per_element;
+  Int nb_element = mesh.getNbElement(element_type);
+  Int nb_nodes_per_element = mesh.getNbNodesPerElement(element_type);
+  Int nb_dofs_per_element = spatial_dimension * nb_nodes_per_element;
   SparseMatrix K_akantu(nb_global_nodes * spatial_dimension, _unsymmetric);
   K_akantu.buildProfile(mesh, dof_synchronizer, spatial_dimension);
   /// use as elemental matrices a matrix with values equal to 1 every where
   Matrix<Real> element_input(nb_dofs_per_element, nb_dofs_per_element, 1.);
   Array<Real> K_e =
       Array<Real>(nb_element, nb_dofs_per_element * nb_dofs_per_element, "K_e");
   Array<Real>::matrix_iterator K_e_it =
       K_e.begin(nb_dofs_per_element, nb_dofs_per_element);
   Array<Real>::matrix_iterator K_e_end =
       K_e.end(nb_dofs_per_element, nb_dofs_per_element);
 
   for (; K_e_it != K_e_end; ++K_e_it)
     *K_e_it = element_input;
 
   // assemble the test matrix
   fem->assembleMatrix(K_e, K_akantu, spatial_dimension, element_type,
                       ghost_type);
 
   /// construct a PETSc matrix
   PETScMatrix K_petsc(nb_global_nodes * spatial_dimension, _unsymmetric);
   /// build the profile of the PETSc matrix for the mesh of this example
   K_petsc.buildProfile(mesh, dof_synchronizer, spatial_dimension);
   /// add an Akantu sparse matrix to a PETSc sparse matrix
   K_petsc.add(K_akantu, 1);
 
   /// check to how many elements each node is connected
   CSR<Element> node_to_elem;
 
   MeshUtils::buildNode2Elements(mesh, node_to_elem, spatial_dimension);
 
   /// test the diagonal of the PETSc matrix: the diagonal entries
   /// of the PETSc matrix correspond to the number of elements
   /// connected to the node of the dof. Note: for an Akantu matrix this is only
   /// true for the serial case
   Real error = 0.;
   /// loop over all diagonal values of the matrix
-  for (UInt i = 0; i < mesh.getNbNodes(); ++i) {
-    for (UInt j = 0; j < spatial_dimension; ++j) {
-      UInt dof = i * spatial_dimension + j;
+  for (Int i = 0; i < mesh.getNbNodes(); ++i) {
+    for (Int j = 0; j < spatial_dimension; ++j) {
+      Int dof = i * spatial_dimension + j;
       /// for PETSc matrix only DOFs on the processor and be accessed
       if (dof_synchronizer.isLocalOrMasterDOF(dof)) {
-        UInt global_dof = dof_synchronizer.getDOFGlobalID(dof);
+        Int global_dof = dof_synchronizer.getDOFGlobalID(dof);
         std::cout << "Number of elements connected: "
                   << node_to_elem.getNbCols(i) << std::endl;
         std::cout << "K_petsc(" << global_dof << "," << global_dof
                   << ")=" << K_petsc(dof, dof) << std::endl;
         error += std::abs(K_petsc(dof, dof) - node_to_elem.getNbCols(i));
       }
     }
   }
 
   if (error > Math::getTolerance()) {
     std::cout << "error in the stiffness matrix!!!" << std::endl;
     finalize();
     return EXIT_FAILURE;
   }
 
   delete communicator;
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_solver/test_petsc_matrix_profile.cc b/test/test_solver/test_petsc_matrix_profile.cc
index 9ba395d83..8ea42c7a7 100644
--- a/test/test_solver/test_petsc_matrix_profile.cc
+++ b/test/test_solver/test_petsc_matrix_profile.cc
@@ -1,144 +1,144 @@
 /**
  * @file   test_petsc_matrix_profile.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Tue Jan 01 2019
  *
  * @brief  test the profile generation of the PETScMatrix class
  *
  *
  * @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 <cstdlib>
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_csr.hh"
 #include "communicator.hh"
 #include "dof_synchronizer.hh"
 #include "element_synchronizer.hh"
 #include "fe_engine.hh"
 #include "mesh.hh"
 #include "mesh_io.hh"
 #include "mesh_utils.hh"
 #include "sparse_matrix_petsc.hh"
 /// #include "dumper_paraview.hh"
 #include "mesh_partition_scotch.hh"
 
 using namespace akantu;
 int main(int argc, char * argv[]) {
 
   initialize(argc, argv);
   const ElementType element_type = _triangle_3;
   const GhostType ghost_type = _not_ghost;
-  UInt spatial_dimension = 2;
+  Int spatial_dimension = 2;
 
   const auto & comm = akantu::Communicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   /// read the mesh and partition it
   Mesh mesh(spatial_dimension);
 
   /* ------------------------------------------------------------------------ */
   /* Parallel initialization                                                  */
   /* ------------------------------------------------------------------------ */
   ElementSynchronizer * communicator = NULL;
   if (prank == 0) {
     /// creation mesh
     mesh.read("square.msh");
     MeshPartitionScotch * partition =
         new MeshPartitionScotch(mesh, spatial_dimension);
     partition->partitionate(psize);
     communicator =
         ElementSynchronizer::createDistributedSynchronizerMesh(mesh, partition);
     delete partition;
   } else {
     communicator =
         ElementSynchronizer::createDistributedSynchronizerMesh(mesh, NULL);
   }
 
   // dump mesh in paraview
   // DumperParaview mesh_dumper("mesh_dumper");
   // mesh_dumper.registerMesh(mesh, spatial_dimension, _not_ghost);
   // mesh_dumper.dump();
 
   /// initialize the FEEngine and the dof_synchronizer
   FEEngine * fem =
       new FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_regular>(
           mesh, spatial_dimension, "my_fem");
 
   DOFSynchronizer dof_synchronizer(mesh, spatial_dimension);
-  UInt nb_global_nodes = mesh.getNbGlobalNodes();
+  Int nb_global_nodes = mesh.getNbGlobalNodes();
 
   dof_synchronizer.initGlobalDOFEquationNumbers();
 
   // construct an Akantu sparse matrix, build the profile and fill the matrix
   // for the given mesh
-  UInt nb_element = mesh.getNbElement(element_type);
-  UInt nb_nodes_per_element = mesh.getNbNodesPerElement(element_type);
-  UInt nb_dofs_per_element = spatial_dimension * nb_nodes_per_element;
+  Int nb_element = mesh.getNbElement(element_type);
+  Int nb_nodes_per_element = mesh.getNbNodesPerElement(element_type);
+  Int nb_dofs_per_element = spatial_dimension * nb_nodes_per_element;
   SparseMatrix K_akantu(nb_global_nodes * spatial_dimension, _unsymmetric);
   K_akantu.buildProfile(mesh, dof_synchronizer, spatial_dimension);
   /// use as elemental matrices a matrix with values equal to 1 every where
   Matrix<Real> element_input(nb_dofs_per_element, nb_dofs_per_element, 1.);
   Array<Real> K_e =
       Array<Real>(nb_element, nb_dofs_per_element * nb_dofs_per_element, "K_e");
   Array<Real>::matrix_iterator K_e_it =
       K_e.begin(nb_dofs_per_element, nb_dofs_per_element);
   Array<Real>::matrix_iterator K_e_end =
       K_e.end(nb_dofs_per_element, nb_dofs_per_element);
 
   for (; K_e_it != K_e_end; ++K_e_it)
     *K_e_it = element_input;
 
   // assemble the test matrix
   fem->assembleMatrix(K_e, K_akantu, spatial_dimension, element_type,
                       ghost_type);
 
   /// construct a PETSc matrix
   PETScMatrix K_petsc(nb_global_nodes * spatial_dimension, _unsymmetric);
   /// build the profile of the PETSc matrix for the mesh of this example
   K_petsc.buildProfile(mesh, dof_synchronizer, spatial_dimension);
   /// add an Akantu sparse matrix to a PETSc sparse matrix
   K_petsc.add(K_akantu, 1);
 
   /// save the profile
   K_petsc.saveMatrix("profile.txt");
 
   /// print the matrix to screen
   std::ifstream profile;
   profile.open("profile.txt");
   std::string current_line;
   while (getline(profile, current_line))
     std::cout << current_line << std::endl;
   profile.close();
 
   delete communicator;
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_solver/test_petsc_matrix_profile_parallel.cc b/test/test_solver/test_petsc_matrix_profile_parallel.cc
index 164783a19..a29339983 100644
--- a/test/test_solver/test_petsc_matrix_profile_parallel.cc
+++ b/test/test_solver/test_petsc_matrix_profile_parallel.cc
@@ -1,144 +1,144 @@
 /**
  * @file   test_petsc_matrix_profile_parallel.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Tue Jan 01 2019
  *
  * @brief  test the profile generation of the PETScMatrix class in parallel
  *
  *
  * @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 <cstdlib>
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_csr.hh"
 #include "communicator.hh"
 #include "dof_synchronizer.hh"
 #include "element_synchronizer.hh"
 #include "fe_engine.hh"
 #include "mesh.hh"
 #include "mesh_io.hh"
 #include "mesh_utils.hh"
 #include "sparse_matrix_petsc.hh"
 /// #include "dumper_paraview.hh"
 #include "mesh_partition_scotch.hh"
 
 using namespace akantu;
 int main(int argc, char * argv[]) {
 
   initialize(argc, argv);
   const ElementType element_type = _triangle_3;
   const GhostType ghost_type = _not_ghost;
-  UInt spatial_dimension = 2;
+  Int spatial_dimension = 2;
 
   const auto & comm = akantu::Communicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   /// read the mesh and partition it
   Mesh mesh(spatial_dimension);
 
   /* ------------------------------------------------------------------------ */
   /* Parallel initialization                                                  */
   /* ------------------------------------------------------------------------ */
   ElementSynchronizer * communicator = NULL;
   if (prank == 0) {
     /// creation mesh
     mesh.read("square.msh");
     MeshPartitionScotch * partition =
         new MeshPartitionScotch(mesh, spatial_dimension);
     partition->partitionate(psize);
     communicator =
         ElementSynchronizer::createDistributedSynchronizerMesh(mesh, partition);
     delete partition;
   } else {
     communicator =
         ElementSynchronizer::createDistributedSynchronizerMesh(mesh, NULL);
   }
 
   // dump mesh in paraview
   // DumperParaview mesh_dumper("mesh_dumper");
   // mesh_dumper.registerMesh(mesh, spatial_dimension, _not_ghost);
   // mesh_dumper.dump();
 
   /// initialize the FEEngine and the dof_synchronizer
   FEEngine * fem =
       new FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_regular>(
           mesh, spatial_dimension, "my_fem");
 
   DOFSynchronizer dof_synchronizer(mesh, spatial_dimension);
-  UInt nb_global_nodes = mesh.getNbGlobalNodes();
+  Int nb_global_nodes = mesh.getNbGlobalNodes();
 
   dof_synchronizer.initGlobalDOFEquationNumbers();
 
   // construct an Akantu sparse matrix, build the profile and fill the matrix
   // for the given mesh
-  UInt nb_element = mesh.getNbElement(element_type);
-  UInt nb_nodes_per_element = mesh.getNbNodesPerElement(element_type);
-  UInt nb_dofs_per_element = spatial_dimension * nb_nodes_per_element;
+  Int nb_element = mesh.getNbElement(element_type);
+  Int nb_nodes_per_element = mesh.getNbNodesPerElement(element_type);
+  Int nb_dofs_per_element = spatial_dimension * nb_nodes_per_element;
   SparseMatrix K_akantu(nb_global_nodes * spatial_dimension, _unsymmetric);
   K_akantu.buildProfile(mesh, dof_synchronizer, spatial_dimension);
   /// use as elemental matrices a matrix with values equal to 1 every where
   Matrix<Real> element_input(nb_dofs_per_element, nb_dofs_per_element, 1.);
   Array<Real> K_e =
       Array<Real>(nb_element, nb_dofs_per_element * nb_dofs_per_element, "K_e");
   Array<Real>::matrix_iterator K_e_it =
       K_e.begin(nb_dofs_per_element, nb_dofs_per_element);
   Array<Real>::matrix_iterator K_e_end =
       K_e.end(nb_dofs_per_element, nb_dofs_per_element);
 
   for (; K_e_it != K_e_end; ++K_e_it)
     *K_e_it = element_input;
 
   // assemble the test matrix
   fem->assembleMatrix(K_e, K_akantu, spatial_dimension, element_type,
                       ghost_type);
 
   /// construct a PETSc matrix
   PETScMatrix K_petsc(nb_global_nodes * spatial_dimension, _unsymmetric);
   /// build the profile of the PETSc matrix for the mesh of this example
   K_petsc.buildProfile(mesh, dof_synchronizer, spatial_dimension);
   /// add an Akantu sparse matrix to a PETSc sparse matrix
   K_petsc.add(K_akantu, 1);
 
   /// save the profile
   K_petsc.saveMatrix("profile_parallel.txt");
   /// print the matrix to screen
   if (prank == 0) {
     std::ifstream profile;
     profile.open("profile_parallel.txt");
     std::string current_line;
     while (getline(profile, current_line))
       std::cout << current_line << std::endl;
     profile.close();
   }
 
   delete communicator;
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_solver/test_solver_petsc.cc b/test/test_solver/test_solver_petsc.cc
index 0972c9bc2..00177afb9 100644
--- a/test/test_solver/test_solver_petsc.cc
+++ b/test/test_solver/test_solver_petsc.cc
@@ -1,173 +1,173 @@
 /**
  * @file   test_solver_petsc.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Tue Jan 01 2019
  *
  * @brief  test the PETSc solver 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 <cstdlib>
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_csr.hh"
 #include "communicator.hh"
 #include "dof_synchronizer.hh"
 #include "element_synchronizer.hh"
 #include "fe_engine.hh"
 #include "mesh.hh"
 #include "mesh_io.hh"
 #include "mesh_utils.hh"
 #include "solver_petsc.hh"
 #include "sparse_matrix_petsc.hh"
 
 #include "mesh_partition_scotch.hh"
 
 using namespace akantu;
 int main(int argc, char * argv[]) {
 
   initialize(argc, argv);
   const ElementType element_type = _segment_2;
   const GhostType ghost_type = _not_ghost;
-  UInt spatial_dimension = 1;
+  Int spatial_dimension = 1;
 
   const auto & comm = akantu::Communicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   /// read the mesh and partition it
   Mesh mesh(spatial_dimension);
 
   /* ------------------------------------------------------------------------ */
   /* Parallel initialization                                                  */
   /* ------------------------------------------------------------------------ */
   ElementSynchronizer * communicator = NULL;
   if (prank == 0) {
     /// creation mesh
     mesh.read("1D_bar.msh");
     MeshPartitionScotch * partition =
         new MeshPartitionScotch(mesh, spatial_dimension);
     partition->partitionate(psize);
     communicator =
         ElementSynchronizer::createDistributedSynchronizerMesh(mesh, partition);
     delete partition;
   } else {
     communicator =
         ElementSynchronizer::createDistributedSynchronizerMesh(mesh, NULL);
   }
 
   FEEngine * fem =
       new FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_regular>(
           mesh, spatial_dimension, "my_fem");
 
   DOFSynchronizer dof_synchronizer(mesh, spatial_dimension);
-  UInt nb_global_nodes = mesh.getNbGlobalNodes();
+  Int nb_global_nodes = mesh.getNbGlobalNodes();
 
   dof_synchronizer.initGlobalDOFEquationNumbers();
 
   // fill the matrix with
-  UInt nb_element = mesh.getNbElement(element_type);
-  UInt nb_nodes_per_element = mesh.getNbNodesPerElement(element_type);
-  UInt nb_dofs_per_element = spatial_dimension * nb_nodes_per_element;
+  Int nb_element = mesh.getNbElement(element_type);
+  Int nb_nodes_per_element = mesh.getNbNodesPerElement(element_type);
+  Int nb_dofs_per_element = spatial_dimension * nb_nodes_per_element;
   SparseMatrix K(nb_global_nodes * spatial_dimension, _symmetric);
   K.buildProfile(mesh, dof_synchronizer, spatial_dimension);
   Matrix<Real> element_input(nb_dofs_per_element, nb_dofs_per_element, 0);
-  for (UInt i = 0; i < nb_dofs_per_element; ++i) {
-    for (UInt j = 0; j < nb_dofs_per_element; ++j) {
+  for (Int i = 0; i < nb_dofs_per_element; ++i) {
+    for (Int j = 0; j < nb_dofs_per_element; ++j) {
       element_input(i, j) = ((i == j) ? 1 : -1);
     }
   }
   Array<Real> K_e =
       Array<Real>(nb_element, nb_dofs_per_element * nb_dofs_per_element, "K_e");
   Array<Real>::matrix_iterator K_e_it =
       K_e.begin(nb_dofs_per_element, nb_dofs_per_element);
   Array<Real>::matrix_iterator K_e_end =
       K_e.end(nb_dofs_per_element, nb_dofs_per_element);
 
   for (; K_e_it != K_e_end; ++K_e_it)
     *K_e_it = element_input;
 
   // assemble the test matrix
   fem->assembleMatrix(K_e, K, spatial_dimension, element_type, ghost_type);
 
   // apply boundary: block first node
   const Array<Real> & position = mesh.getNodes();
-  UInt nb_nodes = mesh.getNbNodes();
+  Int nb_nodes = mesh.getNbNodes();
   Array<bool> boundary = Array<bool>(nb_nodes, spatial_dimension, false);
-  for (UInt i = 0; i < nb_nodes; ++i) {
+  for (Int i = 0; i < nb_nodes; ++i) {
     if (std::abs(position(i, 0)) < Math::getTolerance())
       boundary(i, 0) = true;
   }
 
   K.applyBoundary(boundary);
 
   /// create the PETSc matrix for the solve step
   PETScMatrix petsc_matrix(nb_global_nodes * spatial_dimension, _symmetric);
   petsc_matrix.buildProfile(mesh, dof_synchronizer, spatial_dimension);
 
   /// copy the stiffness matrix into the petsc matrix
   petsc_matrix.add(K, 1);
 
   // initialize internal forces: they are zero because imposed displacement is
   // zero
   Array<Real> internal_forces(nb_nodes, spatial_dimension, 0.);
 
   // compute residual: apply nodal force on last node
   Array<Real> residual(nb_nodes, spatial_dimension, 0.);
 
-  for (UInt i = 0; i < nb_nodes; ++i) {
+  for (Int i = 0; i < nb_nodes; ++i) {
     if (std::abs(position(i, 0) - 10) < Math::getTolerance())
       residual(i, 0) += 2;
   }
 
   residual -= internal_forces;
 
   /// initialize solver and solution
   Array<Real> solution(nb_nodes, spatial_dimension, 0.);
   SolverPETSc solver(petsc_matrix);
   solver.initialize();
   solver.setOperators();
   solver.setRHS(residual);
   solver.solve(solution);
 
   /// verify solution
   Math::setTolerance(1e-11);
-  for (UInt i = 0; i < nb_nodes; ++i) {
+  for (Int i = 0; i < nb_nodes; ++i) {
     if (!dof_synchronizer.isPureGhostDOF(i) &&
         !Math::are_float_equal(2 * position(i, 0), solution(i, 0))) {
       std::cout << "The solution is not correct!!!!" << std::endl;
       finalize();
       return EXIT_FAILURE;
     }
   }
 
   delete communicator;
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_solver/test_sparse_matrix_product.cc b/test/test_solver/test_sparse_matrix_product.cc
index 9bda5fc60..572884524 100644
--- a/test/test_solver/test_sparse_matrix_product.cc
+++ b/test/test_solver/test_sparse_matrix_product.cc
@@ -1,123 +1,123 @@
 /**
  * @file   test_sparse_matrix_product.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Tue Jan 01 2019
  *
  * @brief  test the matrix vector product in parallel
  *
  *
  * @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 <iostream>
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "dof_synchronizer.hh"
 #include "element_synchronizer.hh"
 #include "mesh.hh"
 #include "mesh_partition_scotch.hh"
 #include "sparse_matrix_aij.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   initialize(argc, argv);
-  const UInt spatial_dimension = 2;
-  const UInt nb_dof = 2;
+  const Int spatial_dimension = 2;
+  const Int nb_dof = 2;
 
   const auto & comm = Communicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   Mesh mesh(spatial_dimension);
   mesh.read("bar.msh");
   mesh.distribute();
 
-  UInt nb_nodes = mesh.getNbNodes();
+  Int nb_nodes = mesh.getNbNodes();
   DOFManagerDefault dof_manager(mesh, "test_dof_manager");
 
   Array<Real> test_synchronize(nb_nodes, nb_dof, "Test vector");
   dof_manager.registerDOFs("test_synchronize", test_synchronize, _dst_nodal);
 
   if (prank == 0)
     std::cout << "Creating a SparseMatrix" << std::endl;
 
   auto & A = dynamic_cast<SparseMatrixAIJ &>(
       dof_manager.getNewMatrix("A", _symmetric));
 
   Array<Real> dof_vector(nb_nodes, nb_dof, "vector");
 
   if (prank == 0)
     std::cout << "Filling the matrix" << std::endl;
 
-  for (UInt i = 0; i < nb_nodes * nb_dof; ++i) {
+  for (Int i = 0; i < nb_nodes * nb_dof; ++i) {
     if (dof_manager.isLocalOrMasterDOF(i))
       A.add(i, i, 2.);
   }
 
   std::stringstream str;
   str << "Matrix_" << prank << ".mtx";
   A.saveMatrix(str.str());
 
-  for (UInt n = 0; n < nb_nodes; ++n) {
-    for (UInt d = 0; d < nb_dof; ++d) {
+  for (Int n = 0; n < nb_nodes; ++n) {
+    for (Int d = 0; d < nb_dof; ++d) {
       dof_vector(n, d) = 1.;
     }
   }
 
   Array<Real> dof_vector_tmp(dof_vector);
 
   if (prank == 0)
     std::cout << "Computing x = A * x" << std::endl;
   A.matVecMul(dof_vector, dof_vector_tmp);
   dof_vector.copy(dof_vector_tmp);
 
   auto & sync =
       dynamic_cast<DOFManagerDefault &>(dof_manager).getSynchronizer();
 
   if (prank == 0)
     std::cout << "Gathering the results on proc 0" << std::endl;
   if (psize > 1) {
     if (prank == 0) {
       Array<Real> gathered;
       sync.gather(dof_vector, gathered);
 
       debug::setDebugLevel(dblTest);
       std::cout << gathered << std::endl;
       debug::setDebugLevel(dblWarning);
     } else {
       sync.gather(dof_vector);
     }
   } else {
     debug::setDebugLevel(dblTest);
     std::cout << dof_vector << std::endl;
     debug::setDebugLevel(dblWarning);
   }
 
   finalize();
 
   return 0;
 }
diff --git a/test/test_solver/test_sparse_matrix_profile.cc b/test/test_solver/test_sparse_matrix_profile.cc
index facf232c1..3a29d74c3 100644
--- a/test/test_solver/test_sparse_matrix_profile.cc
+++ b/test/test_solver/test_sparse_matrix_profile.cc
@@ -1,76 +1,76 @@
 /**
  * @file   test_sparse_matrix_profile.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Tue Aug 29 2017
  *
  * @brief  test the profile generation of the SparseMatrix 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 "dof_manager_default.hh"
 #include "mesh.hh"
 #include "sparse_matrix.hh"
 /* -------------------------------------------------------------------------- */
 #include <cstdlib>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   initialize(argc, argv);
 
-  UInt spatial_dimension = 2;
+  Int spatial_dimension = 2;
   Mesh mesh(spatial_dimension);
   mesh.read("triangle.msh");
 
-  UInt nb_nodes = mesh.getNbNodes();
+  Int nb_nodes = mesh.getNbNodes();
 
   DOFManagerDefault dof_manager(mesh, "test_dof_manager");
   Array<Real> test_synchronize(nb_nodes, spatial_dimension, "Test vector");
   dof_manager.registerDOFs("test_synchronize", test_synchronize, _dst_nodal);
 
   auto & A = dof_manager.getNewMatrix("A", _symmetric);
 
-  for (UInt i = 0; i < 10; ++i) {
+  for (Int i = 0; i < 10; ++i) {
     A.add(i, i);
   }
 
   A.add(0, 9);
   A.saveProfile("profile_hand.mtx");
 
-  for (UInt i = 0; i < 10; ++i) {
+  for (Int i = 0; i < 10; ++i) {
     A.add(i, i, i * 10);
   }
   A.add(0, 9, 100);
 
   A.saveMatrix("matrix_hand.mtx");
 
   /* ------------------------------------------------------------------------ */
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_solver/test_sparse_matrix_profile_parallel.cc b/test/test_solver/test_sparse_matrix_profile_parallel.cc
index c4b43dde1..cfd569c78 100644
--- a/test/test_solver/test_sparse_matrix_profile_parallel.cc
+++ b/test/test_solver/test_sparse_matrix_profile_parallel.cc
@@ -1,114 +1,114 @@
 /**
  * @file   test_sparse_matrix_profile_parallel.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Wed Nov 08 2017
  *
  * @brief  test the sparse matrix class in parallel
  *
  *
  * @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 "communicator.hh"
 #include "mesh.hh"
 #include "mesh_io_msh.hh"
 #include "mesh_partition_scotch.hh"
 #include "solver_mumps.hh"
 #include "sparse_matrix.hh"
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 /* Main                                                                       */
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   akantu::initialize(argc, argv);
 
   int dim = 2;
   //#ifdef AKANTU_USE_IOHELPER
   // akantu::ElementType type = akantu::_triangle_6;
   //#endif //AKANTU_USE_IOHELPER
   akantu::Mesh mesh(dim);
 
   //  akantu::debug::setDebugLevel(akantu::dblDump);
 
   akantu::StaticCommunicator * comm =
       akantu::Communicator::getStaticCommunicator();
   akantu::Int psize = comm->getNbProc();
   akantu::Int prank = comm->whoAmI();
 
-  akantu::UInt n = 0;
+  akantu::Int n = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Parallel initialization                                                  */
   /* ------------------------------------------------------------------------ */
   akantu::Communicator * communicator;
   if (prank == 0) {
     akantu::MeshIOMSH mesh_io;
     mesh_io.read("triangle.msh", mesh);
     akantu::MeshPartition * partition =
         new akantu::MeshPartitionScotch(mesh, dim);
 
     //    partition->reorder();
     mesh_io.write("triangle_reorder.msh", mesh);
 
     n = mesh.getNbNodes();
 
     partition->partitionate(psize);
     communicator =
         akantu::Communicator::createCommunicatorDistributeMesh(mesh, partition);
     delete partition;
   } else {
     communicator =
         akantu::Communicator::createCommunicatorDistributeMesh(mesh, NULL);
   }
 
   std::cout << "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA "
             << mesh.getNbGlobalNodes() << std::endl;
 
   akantu::SparseMatrix sparse_matrix(mesh, akantu::_symmetric, 2, "mesh");
   sparse_matrix.buildProfile();
 
   akantu::Solver * solver = new akantu::SolverMumps(sparse_matrix);
 
   if (prank == 0) {
-    for (akantu::UInt i = 0; i < n; ++i) {
+    for (akantu::Int i = 0; i < n; ++i) {
       solver->getRHS().data()[i] = 1.;
     }
   }
 
   akantu::debug::setDebugLevel(akantu::dblDump);
   solver->initialize();
 
   std::stringstream sstr;
   sstr << "profile_" << prank << ".mtx";
   sparse_matrix.saveProfile(sstr.str());
 
   akantu::finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_solver/test_sparse_solver_mumps.cc b/test/test_solver/test_sparse_solver_mumps.cc
index a96055b2b..e1b1dd582 100644
--- a/test/test_solver/test_sparse_solver_mumps.cc
+++ b/test/test_solver/test_sparse_solver_mumps.cc
@@ -1,169 +1,169 @@
 /**
  * @file   test_sparse_solver_mumps.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri May 19 2017
  * @date last modification:  Sun Dec 30 2018
  *
  * @brief  test the matrix vector product in parallel
  *
  *
  * @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 "aka_common.hh"
 #include "dof_synchronizer.hh"
 #include "element_synchronizer.hh"
 #include "mesh.hh"
 #include "mesh_accessor.hh"
 #include "mesh_partition_scotch.hh"
 #include "sparse_matrix_aij.hh"
 #include "sparse_solver_mumps.hh"
 #include "terms_to_assemble.hh"
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 void genMesh(Mesh & mesh, UInt nb_nodes);
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   initialize(argc, argv);
   const UInt spatial_dimension = 1;
   const UInt nb_global_dof = 11;
   const auto & comm = Communicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   Mesh mesh(spatial_dimension);
 
   if (prank == 0) {
     genMesh(mesh, nb_global_dof);
-    RandomGenerator<UInt>::seed(1496137735);
+    RandomGenerator<Idx>::seed(1496137735);
   } else {
-    RandomGenerator<UInt>::seed(2992275470);
+    RandomGenerator<Idx>::seed(2992275470);
   }
 
   mesh.distribute();
   UInt node = 0;
   for (auto pos : mesh.getNodes()) {
     std::cout << prank << " " << node << " pos: " << pos << " ["
               << mesh.getNodeGlobalId(node) << "] " << mesh.getNodeFlag(node)
               << std::endl;
     ++node;
   }
   UInt nb_nodes = mesh.getNbNodes();
 
   DOFManagerDefault dof_manager(mesh, "test_dof_manager");
 
   Array<Real> x(nb_nodes);
   dof_manager.registerDOFs("x", x, _dst_nodal);
 
   const auto & local_equation_number =
       dof_manager.getLocalEquationsNumbers("x");
 
   auto & A = dof_manager.getNewMatrix("A", _symmetric);
 
   Array<Real> b(nb_nodes);
   TermsToAssemble terms;
 
   for (UInt i = 0; i < nb_nodes; ++i) {
     if (dof_manager.isLocalOrMasterDOF(i)) {
       auto li = local_equation_number(i);
       auto gi = dof_manager.localToGlobalEquationNumber(li);
       terms(i, i) = 1. / (1. + gi);
     }
   }
 
   dof_manager.assemblePreassembledMatrix("x", "x", "A", terms);
 
   std::stringstream str;
   str << "Matrix_" << prank << ".mtx";
   A.saveMatrix(str.str());
 
   for (UInt n = 0; n < nb_nodes; ++n) {
     b(n) = 1.;
   }
 
   SparseSolverMumps solver(dof_manager, "A");
 
   solver.solve(x, b);
 
   auto && check = [&](auto && xs) {
     debug::setDebugLevel(dblTest);
     std::cout << xs << std::endl;
     debug::setDebugLevel(dblWarning);
 
     UInt d = 1.;
     for (auto x : xs) {
       if (std::abs(x - d) / d > 1e-15)
         AKANTU_EXCEPTION("Error in the solution: " << x << " != " << d << " ["
                                                    << (std::abs(x - d) / d)
                                                    << "].");
       ++d;
     }
   };
 
   if (psize > 1) {
     auto & sync =
         dynamic_cast<DOFManagerDefault &>(dof_manager).getSynchronizer();
 
     if (prank == 0) {
       Array<Real> x_gathered(dof_manager.getSystemSize());
       sync.gather(x, x_gathered);
       check(x_gathered);
     } else {
       sync.gather(x);
     }
   } else {
     check(x);
   }
 
   finalize();
 
   return 0;
 }
 
 /* -------------------------------------------------------------------------- */
 void genMesh(Mesh & mesh, UInt nb_nodes) {
   MeshAccessor mesh_accessor(mesh);
   Array<Real> & nodes = mesh_accessor.getNodes();
-  Array<UInt> & conn = mesh_accessor.getConnectivity(_segment_2);
+  Array<Idx> & conn = mesh_accessor.getConnectivity(_segment_2);
 
   nodes.resize(nb_nodes);
 
-  for (UInt n = 0; n < nb_nodes; ++n) {
+  for (Int n = 0; n < nb_nodes; ++n) {
     nodes(n, _x) = n * (1. / (nb_nodes - 1));
   }
 
   conn.resize(nb_nodes - 1);
-  for (UInt n = 0; n < nb_nodes - 1; ++n) {
+  for (Int n = 0; n < nb_nodes - 1; ++n) {
     conn(n, 0) = n;
     conn(n, 1) = n + 1;
   }
 
   mesh_accessor.makeReady();
 }
diff --git a/test/test_synchronizer/test_data_accessor.hh b/test/test_synchronizer/test_data_accessor.hh
index 64ced744c..5ebc859f4 100644
--- a/test/test_synchronizer/test_data_accessor.hh
+++ b/test/test_synchronizer/test_data_accessor.hh
@@ -1,125 +1,106 @@
 /**
  * @file   test_data_accessor.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Fri Jan 26 2018
  *
  * @brief  Data Accessor class for testing
  *
  *
  * @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 "data_accessor.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 #include <gtest/gtest.h>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 /* -------------------------------------------------------------------------- */
 
 class TestAccessor : public DataAccessor<Element> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   inline TestAccessor(const Mesh & mesh,
                       const ElementTypeMapArray<Real> & barycenters);
 
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Barycenter, barycenters, Real);
 
   /* ------------------------------------------------------------------------ */
   /* Ghost Synchronizer inherited members                                     */
   /* ------------------------------------------------------------------------ */
 protected:
-  inline UInt getNbData(const Array<Element> & elements,
-                        const SynchronizationTag & tag) const;
+  inline Int getNbData(const Array<Element> & elements,
+                       const SynchronizationTag & tag) const;
   inline void packData(CommunicationBuffer & buffer,
                        const Array<Element> & elements,
                        const SynchronizationTag & tag) const;
   inline void unpackData(CommunicationBuffer & buffer,
                          const Array<Element> & elements,
                          const SynchronizationTag & tag);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   const ElementTypeMapArray<Real> & barycenters;
   const Mesh & mesh;
 };
 
 /* -------------------------------------------------------------------------- */
 /* TestSynchronizer implementation                                            */
 /* -------------------------------------------------------------------------- */
 inline TestAccessor::TestAccessor(const Mesh & mesh,
                                   const ElementTypeMapArray<Real> & barycenters)
     : barycenters(barycenters), mesh(mesh) {}
 
-inline UInt TestAccessor::getNbData(const Array<Element> & elements,
-                                    const SynchronizationTag &) const {
-  if (elements.size())
-    // return Mesh::getSpatialDimension(elements(0).type) * sizeof(Real) *
-    // elements.size();
-    return mesh.getSpatialDimension() * sizeof(Real) * elements.size();
-  else
-    return 0;
+inline Int TestAccessor::getNbData(const Array<Element> & elements,
+                                   const SynchronizationTag &) const {
+  return mesh.getSpatialDimension() * sizeof(Real) * elements.size();
 }
 
 inline void TestAccessor::packData(CommunicationBuffer & buffer,
                                    const Array<Element> & elements,
                                    const SynchronizationTag &) const {
-  UInt spatial_dimension = mesh.getSpatialDimension();
-  Array<Element>::const_iterator<Element> bit = elements.begin();
-  Array<Element>::const_iterator<Element> bend = elements.end();
-  for (; bit != bend; ++bit) {
-    const Element & element = *bit;
-
-    Vector<Real> bary(
-        this->barycenters(element.type, element.ghost_type).data() +
-            element.element * spatial_dimension,
-        spatial_dimension);
+  for (const auto & element : elements) {
+    auto && bary = this->barycenters.get(element);
     buffer << bary;
   }
 }
 
 inline void TestAccessor::unpackData(CommunicationBuffer & buffer,
                                      const Array<Element> & elements,
                                      const SynchronizationTag &) {
-  UInt spatial_dimension = mesh.getSpatialDimension();
-
   for (const auto & element : elements) {
-    Vector<Real> barycenter_loc(
-        this->barycenters(element.type, element.ghost_type).data() +
-            element.element * spatial_dimension,
-        spatial_dimension);
-
-    Vector<Real> bary(spatial_dimension);
+    auto && barycenter_loc = this->barycenters.get(element);
+    Vector<Real> bary(barycenter_loc.size());
     buffer >> bary;
 
     auto dist = (barycenter_loc - bary).template lpNorm<Eigen::Infinity>();
     EXPECT_NEAR(0, dist, 1e-15);
   }
 }
diff --git a/test/test_synchronizer/test_dof_synchronizer.cc b/test/test_synchronizer/test_dof_synchronizer.cc
index 773683e93..fd7b046a4 100644
--- a/test/test_synchronizer/test_dof_synchronizer.cc
+++ b/test/test_synchronizer/test_dof_synchronizer.cc
@@ -1,148 +1,148 @@
 /**
  * @file   test_dof_synchronizer.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Wed Jan 15 2020
  *
  * @brief  Test the functionality of the DOFSynchronizer 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 "aka_common.hh"
 #include "communicator.hh"
 #include "dof_synchronizer.hh"
 #include "element_synchronizer.hh"
 #include "mesh_io.hh"
 #include "mesh_partition_scotch.hh"
 
 /* -------------------------------------------------------------------------- */
 #ifdef AKANTU_USE_IOHELPER
 #include "io_helper.hh"
 #endif // AKANTU_USE_IOHELPER
 
 /* -------------------------------------------------------------------------- */
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
   const UInt spatial_dimension = 2;
 
   initialize(argc, argv);
 
   const auto & comm = akantu::Communicator::getStaticCommunicator();
   Int prank = comm.whoAmI();
 
   Mesh mesh(spatial_dimension);
 
   if (prank == 0)
     mesh.read("bar.msh");
   mesh.distribute();
 
   DOFManagerDefault dof_manager(mesh, "test_dof_manager");
 
   UInt nb_nodes = mesh.getNbNodes();
 
   /* ------------------------------------------------------------------------ */
   /* test the synchronization                                                 */
   /* ------------------------------------------------------------------------ */
   Array<Real> test_synchronize(nb_nodes, spatial_dimension, "Test vector");
   dof_manager.registerDOFs("test_synchronize", test_synchronize, _dst_nodal);
 
-  auto & equation_number =
+  const auto & equation_number =
       dof_manager.getLocalEquationsNumbers("test_synchronize");
 
-  DOFSynchronizer & dof_synchronizer = dof_manager.getSynchronizer();
+  auto & dof_synchronizer = dof_manager.getSynchronizer();
 
   std::cout << "Synchronizing a dof vector" << std::endl;
 
   Array<Int> local_data_array(dof_manager.getLocalSystemSize(), 2);
   auto it_data = local_data_array.begin(2);
 
-  for (UInt local_dof = 0; local_dof < dof_manager.getLocalSystemSize();
+  for (Int local_dof = 0; local_dof < dof_manager.getLocalSystemSize();
        ++local_dof) {
-    UInt equ_number = equation_number(local_dof);
+    auto equ_number = equation_number(local_dof);
     Vector<Int> val;
     if (dof_manager.isLocalOrMasterDOF(equ_number)) {
-      UInt global_dof = dof_manager.localToGlobalEquationNumber(local_dof);
+      Int global_dof = dof_manager.localToGlobalEquationNumber(local_dof);
       val = {0, 1};
-      val += global_dof * 2;
+      val.array() += global_dof * 2;
     } else {
       val = {-1, -1};
     }
 
     Vector<Int> data = it_data[local_dof];
     data = val;
   }
 
   dof_synchronizer.synchronizeArray(local_data_array);
 
   auto test_data = [&]() -> void {
     auto it_data = local_data_array.begin(2);
     for (UInt local_dof = 0; local_dof < dof_manager.getLocalSystemSize();
          ++local_dof) {
-      UInt equ_number = equation_number(local_dof);
+      Int equ_number = equation_number(local_dof);
 
       Vector<Int> exp_val;
 
       UInt global_dof = dof_manager.localToGlobalEquationNumber(local_dof);
 
       if (dof_manager.isLocalOrMasterDOF(equ_number) ||
           dof_manager.isSlaveDOF(equ_number)) {
         exp_val = {0, 1};
-        exp_val += global_dof * 2;
+        exp_val.array() += global_dof * 2;
       } else {
         exp_val = {-1, -1};
       }
 
       Vector<Int> val = it_data[local_dof];
       if (exp_val != val) {
         std::cerr << "Failed !" << prank << " DOF: " << global_dof << " - l"
                   << local_dof << " value:" << val << " expected: " << exp_val
                   << std::endl;
         exit(1);
       }
     }
   };
 
   test_data();
 
   if (prank == 0) {
     Array<Int> test_gathered(dof_manager.getSystemSize(), 2);
     dof_synchronizer.gather(local_data_array, test_gathered);
 
     local_data_array.set(-1);
     dof_synchronizer.scatter(local_data_array, test_gathered);
   } else {
     dof_synchronizer.gather(local_data_array);
 
     local_data_array.set(-1);
     dof_synchronizer.scatter(local_data_array);
   }
 
   test_data();
 
   finalize();
 
   return 0;
 }
diff --git a/test/test_synchronizer/test_node_synchronizer.cc b/test/test_synchronizer/test_node_synchronizer.cc
index 4508419d4..d5dde8e99 100644
--- a/test/test_synchronizer/test_node_synchronizer.cc
+++ b/test/test_synchronizer/test_node_synchronizer.cc
@@ -1,213 +1,213 @@
 /**
  * @file   test_node_synchronizer.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu May 11 2017
  * @date last modification:  Wed Jan 15 2020
  *
  * @brief  test the default node synchronizer present in the mesh
  *
  *
  * @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 "test_synchronizers_fixture.hh"
 /* -------------------------------------------------------------------------- */
 #include "communicator.hh"
 #include "data_accessor.hh"
 #include "mesh.hh"
 #include "node_synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 #include <chrono>
 #include <limits>
 #include <random>
 #include <thread>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 class DataAccessorTest : public DataAccessor<UInt> {
 public:
   explicit DataAccessorTest(Array<int> & data) : data(data) {}
 
-  UInt getNbData(const Array<UInt> & nodes, const SynchronizationTag &) const {
+  Int getNbData(const Array<UInt> & nodes, const SynchronizationTag &) const {
     return nodes.size() * sizeof(int);
   }
 
   void packData(CommunicationBuffer & buffer, const Array<UInt> & nodes,
                 const SynchronizationTag &) const {
     for (auto node : nodes) {
       buffer << data(node);
     }
   }
 
   void unpackData(CommunicationBuffer & buffer, const Array<UInt> & nodes,
                   const SynchronizationTag &) {
     for (auto node : nodes) {
       buffer >> data(node);
     }
   }
 
 protected:
   Array<int> & data;
 };
 
 class TestNodeSynchronizerFixture : public TestSynchronizerFixture {
 public:
   static constexpr int max_int = std::numeric_limits<int>::max();
 
   void SetUp() override {
     TestSynchronizerFixture::SetUp();
     this->distribute();
 
     UInt nb_nodes = this->mesh->getNbNodes();
 
     node_data = std::make_unique<Array<int>>(nb_nodes);
     for (auto && data : enumerate(*node_data)) {
       auto n = std::get<0>(data);
       auto & d = std::get<1>(data);
       UInt gn = this->mesh->getNodeGlobalId(n);
 
       if (this->mesh->isMasterNode(n))
         d = gn;
       else if (this->mesh->isLocalNode(n))
         d = -gn;
       else if (this->mesh->isSlaveNode(n))
         d = max_int;
       else
         d = -max_int;
     }
 
     data_accessor = std::make_unique<DataAccessorTest>(*node_data);
   }
 
   void TearDown() override {
     data_accessor.reset(nullptr);
     node_data.reset(nullptr);
   }
 
   void checkData() {
     for (auto && data : enumerate(*this->node_data)) {
       auto n = std::get<0>(data);
       auto & d = std::get<1>(data);
       UInt gn = this->mesh->getNodeGlobalId(n);
 
       if (this->mesh->isMasterNode(n))
         EXPECT_EQ(d, gn);
 
       else if (this->mesh->isLocalNode(n))
         EXPECT_EQ(d, -gn);
 
       else if (this->mesh->isSlaveNode(n))
         EXPECT_EQ(d, gn);
 
       else
 
         EXPECT_EQ(d, -max_int);
     }
   }
 
 protected:
   std::unique_ptr<Array<int>> node_data;
   std::unique_ptr<DataAccessorTest> data_accessor;
 };
 
 /* -------------------------------------------------------------------------- */
 constexpr int TestNodeSynchronizerFixture::max_int;
 
 /* -------------------------------------------------------------------------- */
 TEST_F(TestNodeSynchronizerFixture, SynchroneOnce) {
   auto & synchronizer = this->mesh->getNodeSynchronizer();
   synchronizer.synchronizeOnce(*this->data_accessor, SynchronizationTag::_test);
   this->checkData();
 }
 
 /* -------------------------------------------------------------------------- */
 TEST_F(TestNodeSynchronizerFixture, Synchrone) {
   auto & node_synchronizer = this->mesh->getNodeSynchronizer();
   node_synchronizer.synchronize(*this->data_accessor,
                                 SynchronizationTag::_test);
   this->checkData();
 }
 
 /* -------------------------------------------------------------------------- */
 TEST_F(TestNodeSynchronizerFixture, Asynchrone) {
   auto & synchronizer = this->mesh->getNodeSynchronizer();
   synchronizer.asynchronousSynchronize(*this->data_accessor,
                                        SynchronizationTag::_test);
 
   std::random_device r;
   std::default_random_engine engine(r());
   std::uniform_int_distribution<int> uniform_dist(10, 100);
   std::chrono::microseconds delay(uniform_dist(engine));
 
   std::this_thread::sleep_for(delay);
 
   synchronizer.waitEndSynchronize(*this->data_accessor,
                                   SynchronizationTag::_test);
   this->checkData();
 }
 
 /* -------------------------------------------------------------------------- */
 TEST_F(TestNodeSynchronizerFixture, Gather) {
   auto & synchronizer = this->mesh->getNodeSynchronizer();
 
   const auto & comm = akantu::Communicator::getStaticCommunicator();
   Int prank = comm.whoAmI();
 
   if (prank == 0) {
     Array<int> all_data(this->mesh->getNbGlobalNodes());
     synchronizer.gather(*(this->node_data), all_data);
     for (auto && data : enumerate(all_data)) {
       EXPECT_EQ(std::get<0>(data), std::abs(std::get<1>(data)));
     }
   } else {
     synchronizer.gather(*(this->node_data));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 TEST_F(TestNodeSynchronizerFixture, Scatter) {
   Array<int> local_data(this->mesh->getNbNodes(), 1, this->max_int);
   auto & synchronizer = this->mesh->getNodeSynchronizer();
 
   if (prank == 0) {
     Array<int> all_data(this->mesh->getNbGlobalNodes());
     for (auto && data : enumerate(all_data)) {
       std::get<1>(data) = std::get<0>(data);
     }
     synchronizer.scatter(local_data, all_data);
   } else {
     synchronizer.scatter(local_data);
   }
 
   for (auto && data : enumerate(local_data)) {
     auto && n = std::get<0>(data);
     auto && d = std::get<1>(data);
     UInt gn = this->mesh->getNodeGlobalId(n);
     if (this->mesh->isPureGhostNode(n)) {
       EXPECT_EQ(d, this->max_int);
     } else {
       EXPECT_EQ(d, gn);
     }
   }
 }
diff --git a/test/test_synchronizer/test_synchronizers_fixture.hh b/test/test_synchronizer/test_synchronizers_fixture.hh
index 08daef52f..08704d3da 100644
--- a/test/test_synchronizer/test_synchronizers_fixture.hh
+++ b/test/test_synchronizer/test_synchronizers_fixture.hh
@@ -1,83 +1,83 @@
 /**
  * @file   test_synchronizers_fixture.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jan 26 2018
  * @date last modification:  Wed Feb 28 2018
  *
  * @brief  Fixture for synchronizer tests
  *
  *
  * @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 "aka_iterators.hh"
 #include "communicator.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 #include <gtest/gtest.h>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 class TestSynchronizerFixture : public ::testing::Test {
 public:
   virtual void SetUp() {
     const UInt spatial_dimension = 3;
 
     mesh = std::make_unique<Mesh>(spatial_dimension);
 
     const auto & comm = Communicator::getStaticCommunicator();
     prank = comm.whoAmI();
     psize = comm.getNbProc();
 
     if (prank == 0) {
       this->mesh->read("cube.msh");
     }
   }
 
   virtual void TearDown() { this->mesh.reset(nullptr); }
 
   void initBarycenters(ElementTypeMapArray<Real> & barycenters, Mesh & mesh) {
     auto spatial_dimension = mesh.getSpatialDimension();
     barycenters.initialize(mesh, _spatial_dimension = _all_dimensions,
                            _nb_component = spatial_dimension,
                            _with_nb_element = true);
 
     for (auto && ghost_type : ghost_types) {
       for (const auto & type : mesh.elementTypes(_all_dimensions, ghost_type)) {
         for (auto && data : enumerate(
                  make_view(barycenters(type, ghost_type), spatial_dimension))) {
-          Element element{type, UInt(std::get<0>(data)), ghost_type};
+          Element element{type, std::get<0>(data), ghost_type};
           mesh.getBarycenter(element, std::get<1>(data));
         }
       }
     }
   }
 
   void distribute() { this->mesh->distribute(); }
 
 protected:
   std::unique_ptr<Mesh> mesh;
   Int prank;
   Int psize;
 };