diff --git a/.clang-tidy b/.clang-tidy
index be034c548..a0f636675 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,4 +1,4 @@
-Checks:          'modernize-use-override, modernize-use-nullptr'
+Checks:          'modernize-use-*, performance-*'
 AnalyzeTemporaryDtors: false
-HeaderFilterRegex: '.*'
+HeaderFilterRegex: 'src/.*'
 FormatStyle:     file
diff --git a/.linters/clang-format-linter/lint/linter/ClangFormatLinter.php b/.linters/clang-format-linter/lint/linter/ClangFormatLinter.php
index 3d6153e1b..c1bf34850 100644
--- a/.linters/clang-format-linter/lint/linter/ClangFormatLinter.php
+++ b/.linters/clang-format-linter/lint/linter/ClangFormatLinter.php
@@ -1,79 +1,88 @@
 <?php
 
 /**
  * Uses the clang format to format C/C++/Obj-C code
  */
 final class ClangFormatLinter extends ArcanistExternalLinter {
-
   public function getInfoName() {
     return 'clang-format';
   }
 
   public function getInfoURI() {
-    return '';
+    return 'https://clang.llvm.org/docs/ClangFormat.html';
   }
 
   public function getInfoDescription() {
     return pht('Use clang-format for processing specified files.');
   }
 
   public function getLinterName() {
     return 'clang-format';
   }
 
   public function getLinterConfigurationName() {
     return 'clang-format';
   }
 
   public function getLinterConfigurationOptions() {
     $options = array(
     );
 
     return $options + parent::getLinterConfigurationOptions();
   }
 
   public function getDefaultBinary() {
     return 'clang-format';
   }
 
+  public function getVersion() {
+    list($stdout) = execx('%C -version', $this->getExecutableCommand());
+    $matches = array();
+    if (preg_match('/^(?P<version>\d+\.\d+\.\d+)$/', $stdout, $matches)) {
+      return $matches['version'];
+    } else {
+      return false;
+    }
+  }
+
   public function getInstallInstructions() {
-    return pht('Make sure clang-format is in directory specified by $PATH');
+    return pht('On a apt based system, apt-get install clang-format. Othewhy install following the instructions on installing tool inb clang, and make sure clang-format is in directory specified by $PATH');
   }
 
   public function shouldExpectCommandErrors() {
     return false;
   }
 
   protected function getMandatoryFlags() {
     return array(
     );
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     $ok = ($err == 0);
 
     if (!$ok) {
       return false;
     }
 
     $root = $this->getProjectRoot();
     $path = Filesystem::resolvePath($path, $root);
     $orig = file_get_contents($path);
     if ($orig == $stdout) {
       return array();
     }
 
     $message = id(new ArcanistLintMessage())
       ->setPath($path)
       ->setLine(1)
       ->setChar(1)
       ->setGranularity(ArcanistLinter::GRANULARITY_FILE)
       ->setCode('CFMT')
       ->setSeverity(ArcanistLintSeverity::SEVERITY_AUTOFIX)
       ->setName('Code style violation')
       ->setDescription("'$path' has code style errors.")
       ->setOriginalText($orig)
       ->setReplacementText($stdout);
     return array($message);
   }
 }
diff --git a/python/swig/mesh.i b/python/swig/mesh.i
index c5b86abce..57ede82de 100644
--- a/python/swig/mesh.i
+++ b/python/swig/mesh.i
@@ -1,177 +1,177 @@
 /**
  * @file   mesh.i
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Dec 12 2014
  * @date last modification: Wed Jan 13 2016
  *
  * @brief  mesh wrapper
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 %{
 #include "mesh.hh"
 #include "node_group.hh"
 #include "solid_mechanics_model.hh"
 #include "dumpable_inline_impl.hh"
 
 using akantu::IntegrationPoint;
 using akantu::Vector;
 using akantu::ElementTypeMapArray;
 using akantu::MatrixProxy;
 using akantu::Matrix;
 using akantu::UInt;
 using akantu::Real;
 using akantu::Array;
 using akantu::SolidMechanicsModel;
-
 %}
 
 
 namespace akantu {
   %ignore NewNodesEvent;
   %ignore RemovedNodesEvent;
   %ignore NewElementsEvent;
   %ignore RemovedElementsEvent;
   %ignore MeshEventHandler;
   %ignore MeshEvent< UInt >;
   %ignore MeshEvent< Element >;
   %ignore Mesh::extractNodalCoordinatesFromPBCElement;
   %ignore Mesh::getGroupDumer;
   %ignore Mesh::getFacetLocalConnectivity;
   %ignore Mesh::getAllFacetTypes;
+  %ignore Mesh::getCommunicator;
 }
 
 print_self(Mesh)
 
 // Swig considers enums to be ints, and it creates a conflict with two versions of getNbElement()
 %rename(getNbElementByDimension)
 akantu::Mesh::getNbElement(const UInt spatial_dimension = _all_dimensions,
                            const GhostType& ghost_type = _not_ghost,
                            const ElementKind& kind = _ek_not_defined) const;
 
 %extend akantu::Mesh {
 
   void resizeMesh(UInt nb_nodes, UInt nb_element, const ElementType & type) {
     Array<Real> & nodes = const_cast<Array<Real> &>($self->getNodes());
     nodes.resize(nb_nodes);
 
     $self->addConnectivityType(type);
     Array<UInt> & connectivity = const_cast<Array<UInt> &>($self->getConnectivity(type));
     connectivity.resize(nb_element);
   }
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
   Array<Real> & getCohesiveBarycenter(SpacialDirection dir) {
     UInt spatial_dimension = $self->getSpatialDimension();
     ElementTypeMapArray<Real> & barycenter =
         $self->registerData<Real>("barycenter");
     $self->initElementTypeMapArray(barycenter, 1, spatial_dimension, false,
                                    akantu::_ek_cohesive, true);
     akantu::ElementType type = *($self->firstType(
         spatial_dimension, akantu::_not_ghost, akantu::_ek_cohesive));
 
     Vector<Real> bary(spatial_dimension);
     Array<Real> & bary_coh = barycenter(type);
     for (UInt i = 0; i < $self->getNbElement(type); ++i) {
       bary.clear();
       $self->getBarycenter(i, type, bary.storage());
       bary_coh(i) = bary(dir);
     }
     return bary_coh;
   }
 #endif
 }
 
 %extend akantu::GroupManager {
   void createGroupsFromStringMeshData(const std::string & dataset_name) {
     $self->createGroupsFromMeshData<std::string>(dataset_name);
   }
 
   void createGroupsFromUIntMeshData(const std::string & dataset_name) {
     $self->createGroupsFromMeshData<akantu::UInt>(dataset_name);
   }
 }
 
 %extend akantu::NodeGroup {
   akantu::Array<akantu::Real> & getGroupedNodes(akantu::Array<akantu::Real, true> & surface_array, Mesh & mesh) {
     akantu::Array<akantu::UInt> group_node = $self->getNodes();
     akantu::Array<akantu::Real> & full_array = mesh.getNodes();
     surface_array.resize(group_node.getSize());
 
     for (UInt i = 0; i < group_node.getSize(); ++i) {
       for (UInt cmp = 0; cmp < full_array.getNbComponent(); ++cmp) {
 
         surface_array(i,cmp) = full_array(group_node(i),cmp);
       }
     }
 
     akantu::Array<akantu::Real> & res(surface_array);
     return res;
   }
 
   akantu::Array<akantu::Real> & getGroupedArray(akantu::Array<akantu::Real, true> & surface_array, akantu::SolidMechanicsModel & model, int type) {
     akantu::Array<akantu::Real> * full_array;
 
     switch (type) {
 
     case 0 : full_array = new akantu::Array<akantu::Real>(model.getDisplacement());
       break;
     case 1 : full_array = new akantu::Array<akantu::Real>(model.getVelocity());
       break;
     case 2 : full_array = new akantu::Array<akantu::Real>(model.getForce());
       break;
     }
     akantu::Array<akantu::UInt> group_node = $self->getNodes();
     surface_array.resize(group_node.getSize());
 
     for (UInt i = 0; i < group_node.getSize(); ++i) {
       for (UInt cmp = 0; cmp < full_array->getNbComponent(); ++cmp) {
 
         surface_array(i,cmp) = (*full_array)(group_node(i),cmp);
       }
     }
 
     akantu::Array<akantu::Real> & res(surface_array);
     return res;
   }
 }
 
 %include "group_manager.hh"
 
 %include "element_group.hh"
 %include "node_group.hh"
 %include "dumper_iohelper.hh"
 %include "dumpable_iohelper.hh"
 %include "mesh.hh"
 
 namespace akantu{
 %extend Dumpable {
     void addDumpFieldExternalReal(const std::string & field_id,
                                   const Array<Real> & field){
       $self->addDumpFieldExternal<Real>(field_id,field);
     }
   }
  }
diff --git a/src/common/aka_array.hh b/src/common/aka_array.hh
index 646801a86..c580f85f1 100644
--- a/src/common/aka_array.hh
+++ b/src/common/aka_array.hh
@@ -1,365 +1,371 @@
 /**
  * @file   aka_array.hh
  *
  * @author Till Junge <till.junge@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  Array container for Akantu
  * This container differs from the std::vector from the fact it as 2 dimensions
  * a main dimension and the size stored per entries
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_VECTOR_HH__
 #define __AKANTU_VECTOR_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 /* -------------------------------------------------------------------------- */
 #include <typeinfo>
 #include <vector>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /// class that afford to store vectors in static memory
 class ArrayBase {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   explicit ArrayBase(ID id = "");
 
   virtual ~ArrayBase();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the amount of space allocated in bytes
   inline UInt getMemorySize() const;
 
   /// set the size to zero without freeing the allocated space
   inline void empty();
 
   /// function to print the containt of the class
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors */
   /* ------------------------------------------------------------------------ */
 public:
   /// Get the real size allocated in memory
   AKANTU_GET_MACRO(AllocatedSize, allocated_size, UInt);
   /// Get the Size of the Array
   UInt getSize() const __attribute__((deprecated)) { return size_; }
   UInt size() const { return size_; }
   /// Get the number of components
   AKANTU_GET_MACRO(NbComponent, nb_component, UInt);
   /// Get the name of th array
   AKANTU_GET_MACRO(ID, id, const ID &);
   /// Set the name of th array
   AKANTU_SET_MACRO(ID, id, const ID &);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// id of the vector
   ID id;
 
   /// the size allocated
   UInt allocated_size{0};
 
   /// the size used
   UInt size_{0};
 
   /// number of components
   UInt nb_component{1};
 
   /// size of the stored type
   UInt size_of_type{0};
 };
 
 /* -------------------------------------------------------------------------- */
 namespace {
   template <std::size_t dim, typename T> struct IteratorHelper {};
 
   template <typename T> struct IteratorHelper<0, T> { using type = T; };
   template <typename T> struct IteratorHelper<1, T> { using type = Vector<T>; };
   template <typename T> struct IteratorHelper<2, T> { using type = Matrix<T>; };
   template <typename T> struct IteratorHelper<3, T> {
     using type = Tensor3<T>;
   };
 
   template <std::size_t dim, typename T>
   using IteratorHelper_t = typename IteratorHelper<dim, T>::type;
 } // namespace
 
 /* -------------------------------------------------------------------------- */
 template <typename T, bool is_scal> class Array : public ArrayBase {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   using value_type = T;
   using reference = value_type &;
   using pointer_type = value_type *;
   using const_reference = const value_type &;
 
   /// Allocation of a new vector
   explicit inline Array(UInt size = 0, UInt nb_component = 1,
                         const ID & id = "");
 
   /// Allocation of a new vector with a default value
   Array(UInt size, UInt nb_component, const value_type def_values[],
         const ID & id = "");
 
   /// Allocation of a new vector with a default value
   Array(UInt size, UInt nb_component, const_reference value,
         const ID & id = "");
 
   /// Copy constructor (deep copy if deep=true)
   Array(const Array<value_type, is_scal> & vect, bool deep = true,
         const ID & id = "");
 
 #ifndef SWIG
   /// Copy constructor (deep copy)
   explicit Array(const std::vector<value_type> & vect);
 #endif
 
   inline ~Array() override;
 
   Array & operator=(const Array & a) {
     /// this is to let STL allocate and copy arrays in the case of
     /// std::vector::resize
     AKANTU_DEBUG_ASSERT(this->size == 0, "Cannot copy akantu::Array");
     return const_cast<Array &>(a);
   }
 
 #ifndef SWIG
   /* ------------------------------------------------------------------------ */
   /* Iterator                                                                 */
   /* ------------------------------------------------------------------------ */
   /// \todo protected: does not compile with intel  check why
 public:
   template <class R, class it, class IR = R, bool is_tensor_ = is_tensor<R>{}>
   class iterator_internal;
 
 public:
   /* ------------------------------------------------------------------------ */
 
   /* ------------------------------------------------------------------------ */
   template <typename R = T> class const_iterator;
   template <typename R = T> class iterator;
 
   /* ------------------------------------------------------------------------ */
 
   /// iterator for Array of nb_component = 1
   using scalar_iterator = iterator<T>;
   /// const_iterator for Array of nb_component = 1
   using const_scalar_iterator = const_iterator<T>;
 
   /// iterator returning Vectors of size n  on entries of Array with
   /// nb_component = n
   using vector_iterator = iterator<Vector<T>>;
   /// const_iterator returning Vectors of n size on entries of Array with
   /// nb_component = n
   using const_vector_iterator = const_iterator<Vector<T>>;
 
   /// iterator returning Matrices of size (m, n) on entries of Array with
   /// nb_component = m*n
   using matrix_iterator = iterator<Matrix<T>>;
   /// const iterator returning Matrices of size (m, n) on entries of Array with
   /// nb_component = m*n
   using const_matrix_iterator = const_iterator<Matrix<T>>;
 
   /// iterator returning Tensor3 of size (m, n, k) on entries of Array with
   /// nb_component = m*n*k
   using tensor3_iterator = iterator<Tensor3<T>>;
   /// const iterator returning Tensor3 of size (m, n, k) on entries of Array
   /// with nb_component = m*n*k
   using const_tensor3_iterator = const_iterator<Tensor3<T>>;
 
   /* ------------------------------------------------------------------------ */
   template <typename... Ns> inline decltype(auto) begin(Ns&&... n);
   template <typename... Ns> inline decltype(auto) end(Ns&&... n);
 
   template <typename... Ns> inline decltype(auto) begin(Ns&&... n) const;
   template <typename... Ns> inline decltype(auto) end(Ns&&... n) const;
 
   template <typename... Ns> inline decltype(auto) begin_reinterpret(Ns&&... n);
   template <typename... Ns> inline decltype(auto) end_reinterpret(Ns&&... n);
 
   template <typename... Ns>
   inline decltype(auto) begin_reinterpret(Ns&&... n) const;
   template <typename... Ns>
   inline decltype(auto) end_reinterpret(Ns&&... n) const;
 #endif // SWIG
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// append a tuple of size nb_component containing value
   inline void push_back(const_reference value);
   /// append a vector
   // inline void push_back(const value_type new_elem[]);
 
+#ifndef SWIG
   /// append a Vector or a Matrix
   template <template <typename> class C,
             typename = std::enable_if_t<is_tensor<C<T>>{}>>
   inline void push_back(const C<T> & new_elem);
   /// append the value of the iterator
   template <typename Ret> inline void push_back(const iterator<Ret> & it);
 
   /// erase the value at position i
   inline void erase(UInt i);
   /// ask Nico, clarify
   template <typename R> inline iterator<R> erase(const iterator<R> & it);
+#endif
 
   /// changes the allocated size but not the size
   virtual void reserve(UInt size);
 
   /// change the size of the Array
   virtual void resize(UInt size);
 
   /// change the size of the Array and initialize the values
   virtual void resize(UInt size, const T & val);
 
   /// change the number of components by interlacing data
   /// @param multiplicator number of interlaced components add
   /// @param block_size blocks of data in the array
   /// Examaple for block_size = 2, multiplicator = 2
   /// array = oo oo oo -> new array = oo nn nn oo nn nn oo nn nn
   void extendComponentsInterlaced(UInt multiplicator, UInt stride);
 
   /// search elem in the vector, return  the position of the first occurrence or
   /// -1 if not found
   UInt find(const_reference elem) const;
 
   /// @see Array::find(const_reference elem) const
   UInt find(T elem[]) const;
 
+#ifndef SWIG
   /// @see Array::find(const_reference elem) const
   template <template <typename> class C,
             typename = std::enable_if_t<is_tensor<C<T>>{}>>
   inline UInt find(const C<T> & elem);
+#endif
 
   /// set all entries of the array to 0
   inline void clear() { std::fill_n(values, size_ * nb_component, T()); }
 
   /// set all entries of the array to the value t
   /// @param t value to fill the array with
   inline void set(T t) { std::fill_n(values, size_ * nb_component, t); }
 
+#ifndef SWIG
   /// set all tuples of the array to a given vector or matrix
   /// @param vm Matrix or Vector to fill the array with
   template <template <typename> class C,
             typename = std::enable_if_t<is_tensor<C<T>>{}>>
   inline void set(const C<T> & vm);
+#endif
 
   /// Append the content of the other array to the current one
   void append(const Array<T> & other);
 
   /// copy another Array in the current Array, the no_sanity_check allows you to
   /// force the copy in cases where you know what you do with two non matching
   /// Arrays in terms of n
   void copy(const Array<T, is_scal> & other, bool no_sanity_check = false);
 
   /// give the address of the memory allocated for this vector
   T * storage() const { return values; };
 
   /// function to print the containt of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
 protected:
   /// perform the allocation for the constructors
   void allocate(UInt size, UInt nb_component = 1);
 
   /// resize initializing with uninitialized_fill if fill is set
   void resizeUnitialized(UInt new_size, bool fill, const T & val = T());
 
   /* ------------------------------------------------------------------------ */
   /* Operators                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// substraction entry-wise
   Array<T, is_scal> & operator-=(const Array<T, is_scal> & other);
   /// addition entry-wise
   Array<T, is_scal> & operator+=(const Array<T, is_scal> & other);
   /// multiply evry entry by alpha
   Array<T, is_scal> & operator*=(const T & alpha);
 
   /// check if the array are identical entry-wise
   bool operator==(const Array<T, is_scal> & other) const;
   /// @see Array::operator==(const Array<T, is_scal> & other) const
   bool operator!=(const Array<T, is_scal> & other) const;
 
   /// return a reference to the j-th entry of the i-th tuple
   inline reference operator()(UInt i, UInt j = 0);
   /// return a const reference to the j-th entry of the i-th tuple
   inline const_reference operator()(UInt i, UInt j = 0) const;
 
   /// return a reference to the ith component of the 1D array
   inline reference operator[](UInt i);
   /// return a const reference to the ith component of the 1D array
   inline const_reference operator[](UInt i) const;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// array of values
   T * values; // /!\ very dangerous
 };
 
 /* -------------------------------------------------------------------------- */
 /* Inline Functions Array<T, is_scal>                                         */
 /* -------------------------------------------------------------------------- */
 template <typename T, bool is_scal>
 inline std::ostream & operator<<(std::ostream & stream,
                                  const Array<T, is_scal> & _this) {
   _this.printself(stream);
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /* Inline Functions ArrayBase                                                 */
 /* -------------------------------------------------------------------------- */
 inline std::ostream & operator<<(std::ostream & stream,
                                  const ArrayBase & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #include "aka_array_tmpl.hh"
 #include "aka_types.hh"
 
 #endif /* __AKANTU_VECTOR_HH__ */
diff --git a/src/common/aka_array_tmpl.hh b/src/common/aka_array_tmpl.hh
index 9a2c7b0bb..f71b5924a 100644
--- a/src/common/aka_array_tmpl.hh
+++ b/src/common/aka_array_tmpl.hh
@@ -1,1252 +1,1256 @@
 /**
  * @file   aka_array_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Jul 15 2010
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  Inline functions of the classes Array<T> and ArrayBase
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 /* Inline Functions Array<T>                                                 */
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 /* -------------------------------------------------------------------------- */
 #include <memory>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_ARRAY_TMPL_HH__
 #define __AKANTU_AKA_ARRAY_TMPL_HH__
 
 namespace akantu {
 
 namespace debug {
   struct ArrayException : public Exception {};
 } // namespace debug
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline T & Array<T, is_scal>::operator()(UInt i, UInt j) {
   AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < size_) && (j < nb_component),
                       "The value at position ["
                           << i << "," << j << "] is out of range in array \""
                           << id << "\"");
   return values[i * nb_component + j];
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline const T & Array<T, is_scal>::operator()(UInt i, UInt j) const {
   AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < size_) && (j < nb_component),
                       "The value at position ["
                           << i << "," << j << "] is out of range in array \""
                           << id << "\"");
   return values[i * nb_component + j];
 }
 
 template <class T, bool is_scal>
 inline T & Array<T, is_scal>::operator[](UInt i) {
   AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < size_ * nb_component),
                       "The value at position ["
                           << i << "] is out of range in array \"" << id
                           << "\"");
   return values[i];
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline const T & Array<T, is_scal>::operator[](UInt i) const {
   AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < size_ * nb_component),
                       "The value at position ["
                           << i << "] is out of range in array \"" << id
                           << "\"");
   return values[i];
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * append a tuple to the array with the value value for all components
  * @param value the new last tuple or the array will contain nb_component copies
  * of value
  */
 template <class T, bool is_scal>
 inline void Array<T, is_scal>::push_back(const T & value) {
   resizeUnitialized(size_ + 1, true, value);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * append a tuple to the array
  * @param new_elem a C-array containing the values to be copied to the end of
  * the array */
 // template <class T, bool is_scal>
 // inline void Array<T, is_scal>::push_back(const T new_elem[]) {
 //   UInt pos = size_;
 
 //   resizeUnitialized(size_ + 1, false);
 
 //   T * tmp = values + nb_component * pos;
 //   std::uninitialized_copy(new_elem, new_elem + nb_component, tmp);
 // }
 
 /* -------------------------------------------------------------------------- */
+#ifndef SWIG
 /**
  * append a matrix or a vector to the array
  * @param new_elem a reference to a Matrix<T> or Vector<T> */
 template <class T, bool is_scal>
 template <template <typename> class C, typename>
 inline void Array<T, is_scal>::push_back(const C<T> & new_elem) {
   AKANTU_DEBUG_ASSERT(
       nb_component == new_elem.size(),
       "The vector("
           << new_elem.size()
           << ") as not a size compatible with the Array (nb_component="
           << nb_component << ").");
   UInt pos = size_;
   resizeUnitialized(size_ + 1, false);
 
   T * tmp = values + nb_component * pos;
   std::uninitialized_copy(new_elem.storage(), new_elem.storage() + nb_component,
                           tmp);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * append a tuple to the array
  * @param it an iterator to the tuple to be copied to the end of the array */
 template <class T, bool is_scal>
 template <class Ret>
 inline void
 Array<T, is_scal>::push_back(const Array<T, is_scal>::iterator<Ret> & it) {
   UInt pos = size_;
 
   resizeUnitialized(size_ + 1, false);
 
   T * tmp = values + nb_component * pos;
   T * new_elem = it.data();
   std::uninitialized_copy(new_elem, new_elem + nb_component, tmp);
 }
-
+#endif
 /* -------------------------------------------------------------------------- */
 /**
  * erase an element. If the erased element is not the last of the array, the
  * last element is moved into the hole in order to maintain contiguity. This
  * may invalidate existing iterators (For instance an iterator obtained by
  * Array::end() is no longer correct) and will change the order of the
  * elements.
  * @param i index of element to erase
  */
 template <class T, bool is_scal> inline void Array<T, is_scal>::erase(UInt i) {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG_ASSERT((size_ > 0), "The array is empty");
   AKANTU_DEBUG_ASSERT((i < size_), "The element at position ["
                                        << i << "] is out of range (" << i
                                        << ">=" << size_ << ")");
 
   if (i != (size_ - 1)) {
     for (UInt j = 0; j < nb_component; ++j) {
       values[i * nb_component + j] = values[(size_ - 1) * nb_component + j];
     }
   }
 
   resize(size_ - 1);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Subtract another array entry by entry from this array in place. Both arrays
  * must
  * have the same size and nb_component. If the arrays have different shapes,
  * code compiled in debug mode will throw an expeption and optimised code
  * will behave in an unpredicted manner
  * @param other array to subtract from this
  * @return reference to modified this
  */
 template <class T, bool is_scal>
 Array<T, is_scal> & Array<T, is_scal>::
 operator-=(const Array<T, is_scal> & vect) {
   AKANTU_DEBUG_ASSERT((size_ == vect.size_) &&
                           (nb_component == vect.nb_component),
                       "The too array don't have the same sizes");
 
   T * a = values;
   T * b = vect.storage();
   for (UInt i = 0; i < size_ * nb_component; ++i) {
     *a -= *b;
     ++a;
     ++b;
   }
 
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Add another array entry by entry to this array in place. Both arrays must
  * have the same size and nb_component. If the arrays have different shapes,
  * code compiled in debug mode will throw an expeption and optimised code
  * will behave in an unpredicted manner
  * @param other array to add to this
  * @return reference to modified this
  */
 template <class T, bool is_scal>
 Array<T, is_scal> & Array<T, is_scal>::
 operator+=(const Array<T, is_scal> & vect) {
   AKANTU_DEBUG_ASSERT((size_ == vect.size) &&
                           (nb_component == vect.nb_component),
                       "The too array don't have the same sizes");
 
   T * a = values;
   T * b = vect.storage();
   for (UInt i = 0; i < size_ * nb_component; ++i) {
     *a++ += *b++;
   }
 
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Multiply all entries of this array by a scalar in place
  * @param alpha scalar multiplicant
  * @return reference to modified this
  */
 template <class T, bool is_scal>
 Array<T, is_scal> & Array<T, is_scal>::operator*=(const T & alpha) {
   T * a = values;
   for (UInt i = 0; i < size_ * nb_component; ++i) {
     *a++ *= alpha;
   }
 
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Compare this array element by element to another.
  * @param other array to compare to
  * @return true it all element are equal and arrays have the same shape, else
  * false
  */
 template <class T, bool is_scal>
 bool Array<T, is_scal>::operator==(const Array<T, is_scal> & array) const {
   bool equal = nb_component == array.nb_component && size_ == array.size_ &&
                id == array.id;
   if (!equal)
     return false;
 
   if (values == array.storage())
     return true;
   else
     return std::equal(values, values + size_ * nb_component, array.storage());
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 bool Array<T, is_scal>::operator!=(const Array<T, is_scal> & array) const {
   return !operator==(array);
 }
 
 /* -------------------------------------------------------------------------- */
+#ifndef SWIG
 /**
  * set all tuples of the array to a given vector or matrix
  * @param vm Matrix or Vector to fill the array with
  */
 template <class T, bool is_scal>
 template <template <typename> class C, typename>
 inline void Array<T, is_scal>::set(const C<T> & vm) {
   AKANTU_DEBUG_ASSERT(
       nb_component == vm.size(),
       "The size of the object does not match the number of components");
   for (T * it = values; it < values + nb_component * size_;
        it += nb_component) {
     std::copy(vm.storage(), vm.storage() + nb_component, it);
   }
 }
-
+#endif
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 void Array<T, is_scal>::append(const Array<T> & other) {
   AKANTU_DEBUG_ASSERT(
       nb_component == other.nb_component,
       "Cannot append an array with a different number of component");
   UInt old_size = this->size_;
   this->resizeUnitialized(this->size_ + other.size(), false);
 
   T * tmp = values + nb_component * old_size;
   std::uninitialized_copy(other.storage(),
                           other.storage() + other.size() * nb_component, tmp);
 }
 
 /* -------------------------------------------------------------------------- */
 /* Functions Array<T, is_scal>                                                */
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(UInt size, UInt nb_component, const ID & id)
     : ArrayBase(id), values(nullptr) {
   AKANTU_DEBUG_IN();
   allocate(size, nb_component);
 
   if (!is_scal) {
     T val = T();
     std::uninitialized_fill(values, values + size * nb_component, val);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(UInt size, UInt nb_component, const T def_values[],
                          const ID & id)
     : ArrayBase(id), values(NULL) {
   AKANTU_DEBUG_IN();
   allocate(size, nb_component);
 
   T * tmp = values;
 
   for (UInt i = 0; i < size; ++i) {
     tmp = values + nb_component * i;
     std::uninitialized_copy(def_values, def_values + nb_component, tmp);
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(UInt size, UInt nb_component, const T & value,
                          const ID & id)
     : ArrayBase(id), values(nullptr) {
   AKANTU_DEBUG_IN();
   allocate(size, nb_component);
 
   std::uninitialized_fill_n(values, size * nb_component, value);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(const Array<T, is_scal> & vect, bool deep,
                          const ID & id)
     : ArrayBase(vect) {
   AKANTU_DEBUG_IN();
   this->id = (id == "") ? vect.id : id;
 
   if (deep) {
     allocate(vect.size_, vect.nb_component);
     T * tmp = values;
     std::uninitialized_copy(vect.storage(),
                             vect.storage() + size_ * nb_component, tmp);
   } else {
     this->values = vect.storage();
     this->size_ = vect.size_;
     this->nb_component = vect.nb_component;
     this->allocated_size = vect.allocated_size;
     this->size_of_type = vect.size_of_type;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 #ifndef SWIG
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(const std::vector<T> & vect) {
   AKANTU_DEBUG_IN();
   this->id = "";
 
   allocate(vect.size(), 1);
   T * tmp = values;
   std::uninitialized_copy(&(vect[0]), &(vect[size_ - 1]), tmp);
 
   AKANTU_DEBUG_OUT();
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal> Array<T, is_scal>::~Array() {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG(dblAccessory,
                "Freeing " << printMemorySize<T>(allocated_size * nb_component)
                           << " (" << id << ")");
 
   if (values) {
     if (!is_scal)
       for (UInt i = 0; i < size_ * nb_component; ++i) {
         T * obj = values + i;
         obj->~T();
       }
     free(values);
   }
   size_ = allocated_size = 0;
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * perform the allocation for the constructors
  * @param size is the size of the array
  * @param nb_component is the number of component of the array
  */
 template <class T, bool is_scal>
 void Array<T, is_scal>::allocate(UInt size, UInt nb_component) {
   AKANTU_DEBUG_IN();
   if (size == 0) {
     values = nullptr;
   } else {
     values = static_cast<T *>(malloc(nb_component * size * sizeof(T)));
     AKANTU_DEBUG_ASSERT(values != nullptr,
                         "Cannot allocate "
                             << printMemorySize<T>(size * nb_component) << " ("
                             << id << ")");
   }
 
   if (values == nullptr) {
     this->size_ = this->allocated_size = 0;
   } else {
     AKANTU_DEBUG(dblAccessory, "Allocated "
                                    << printMemorySize<T>(size * nb_component)
                                    << " (" << id << ")");
     this->size_ = this->allocated_size = size;
   }
 
   this->size_of_type = sizeof(T);
   this->nb_component = nb_component;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 void Array<T, is_scal>::reserve(UInt new_size) {
   UInt tmp_size = this->size_;
   resizeUnitialized(new_size, false);
   this->size_ = tmp_size;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the size of the array and allocate or free memory if needed. If the
  * size increases, the new tuples are filled with zeros
  * @param new_size new number of tuples contained in the array */
 template <class T, bool is_scal> void Array<T, is_scal>::resize(UInt new_size) {
   resizeUnitialized(new_size, !is_scal);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the size of the array and allocate or free memory if needed. If the
  * size increases, the new tuples are filled with zeros
  * @param new_size new number of tuples contained in the array */
 template <class T, bool is_scal>
 void Array<T, is_scal>::resize(UInt new_size, const T & val) {
   this->resizeUnitialized(new_size, true, val);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the size of the array and allocate or free memory if needed.
  * @param new_size new number of tuples contained in the array */
 template <class T, bool is_scal>
 void Array<T, is_scal>::resizeUnitialized(UInt new_size, bool fill,
                                           const T & val) {
   //  AKANTU_DEBUG_IN();
   // free some memory
   if (new_size <= allocated_size) {
     if (!is_scal) {
       T * old_values = values;
       if (new_size < size_) {
         for (UInt i = new_size * nb_component; i < size_ * nb_component; ++i) {
           T * obj = old_values + i;
           obj->~T();
         }
       }
     }
 
     if (allocated_size - new_size > AKANTU_MIN_ALLOCATION) {
       AKANTU_DEBUG(dblAccessory,
                    "Freeing " << printMemorySize<T>((allocated_size - size_) *
                                                     nb_component)
                               << " (" << id << ")");
 
       // Normally there are no allocation problem when reducing an array
       if (new_size == 0) {
         free(values);
         values = nullptr;
       } else {
         auto * tmp_ptr = static_cast<T *>(
             realloc(values, new_size * nb_component * sizeof(T)));
 
         if (tmp_ptr == nullptr) {
           AKANTU_EXCEPTION("Cannot free data ("
                            << id << ")"
                            << " [current allocated size : " << allocated_size
                            << " | "
                            << "requested size : " << new_size << "]");
         }
         values = tmp_ptr;
       }
       allocated_size = new_size;
     }
   } else {
     // allocate more memory
     UInt size_to_alloc = (new_size - allocated_size < AKANTU_MIN_ALLOCATION)
                              ? allocated_size + AKANTU_MIN_ALLOCATION
                              : new_size;
 
     auto * tmp_ptr = static_cast<T *>(
         realloc(values, size_to_alloc * nb_component * sizeof(T)));
     AKANTU_DEBUG_ASSERT(
         tmp_ptr != nullptr,
         "Cannot allocate " << printMemorySize<T>(size_to_alloc * nb_component));
     if (tmp_ptr == nullptr) {
       AKANTU_DEBUG_ERROR("Cannot allocate more data ("
                          << id << ")"
                          << " [current allocated size : " << allocated_size
                          << " | "
                          << "requested size : " << new_size << "]");
     }
 
     AKANTU_DEBUG(dblAccessory,
                  "Allocating " << printMemorySize<T>(
                      (size_to_alloc - allocated_size) * nb_component));
 
     allocated_size = size_to_alloc;
     values = tmp_ptr;
   }
 
   if (fill && this->size_ < new_size) {
     std::uninitialized_fill(values + size_ * nb_component,
                             values + new_size * nb_component, val);
   }
 
   size_ = new_size;
   //  AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the number of components by interlacing data
  * @param multiplicator number of interlaced components add
  * @param block_size blocks of data in the array
  * Examaple for block_size = 2, multiplicator = 2
  * array = oo oo oo -> new array = oo nn nn oo nn nn oo nn nn */
 template <class T, bool is_scal>
 void Array<T, is_scal>::extendComponentsInterlaced(UInt multiplicator,
                                                    UInt block_size) {
   AKANTU_DEBUG_IN();
 
   if (multiplicator == 1)
     return;
 
   AKANTU_DEBUG_ASSERT(multiplicator > 1, "invalid multiplicator");
   AKANTU_DEBUG_ASSERT(nb_component % block_size == 0,
                       "stride must divide actual number of components");
 
   values = static_cast<T *>(
       realloc(values, nb_component * multiplicator * size_ * sizeof(T)));
 
   UInt new_component = nb_component / block_size * multiplicator;
 
   for (UInt i = 0, k = size_ - 1; i < size_; ++i, --k) {
     for (UInt j = 0; j < new_component; ++j) {
       UInt m = new_component - j - 1;
       UInt n = m / multiplicator;
       for (UInt l = 0, p = block_size - 1; l < block_size; ++l, --p) {
         values[k * nb_component * multiplicator + m * block_size + p] =
             values[k * nb_component + n * block_size + p];
       }
     }
   }
 
   nb_component = nb_component * multiplicator;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * search elem in the array, return  the position of the first occurrence or
  * -1 if not found
  *  @param elem the element to look for
  *  @return index of the first occurrence of elem or -1 if elem is not present
  */
 template <class T, bool is_scal>
 UInt Array<T, is_scal>::find(const T & elem) const {
   AKANTU_DEBUG_IN();
 
   auto begin = this->begin();
   auto end = this->end();
   auto it = std::find(begin, end, elem);
 
   AKANTU_DEBUG_OUT();
   return (it != end) ? it - begin : UInt(-1);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal> UInt Array<T, is_scal>::find(T elem[]) const {
   AKANTU_DEBUG_IN();
   T * it = values;
   UInt i = 0;
   for (; i < size_; ++i) {
     if (*it == elem[0]) {
       T * cit = it;
       UInt c = 0;
       for (; (c < nb_component) && (*cit == elem[c]); ++c, ++cit)
         ;
       if (c == nb_component) {
         AKANTU_DEBUG_OUT();
         return i;
       }
     }
     it += nb_component;
   }
   return UInt(-1);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <template <typename> class C, typename>
 inline UInt Array<T, is_scal>::find(const C<T> & elem) {
   AKANTU_DEBUG_ASSERT(elem.size() == nb_component,
                       "Cannot find an element with a wrong size ("
                           << elem.size() << ") != " << nb_component);
   return this->find(elem.storage());
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * copy the content of another array. This overwrites the current content.
  * @param other Array to copy into this array. It has to have the same
  * nb_component as this. If compiled in debug mode, an incorrect other will
  * result in an exception being thrown. Optimised code may result in
  * unpredicted behaviour.
  */
 template <class T, bool is_scal>
 void Array<T, is_scal>::copy(const Array<T, is_scal> & vect,
                              bool no_sanity_check) {
   AKANTU_DEBUG_IN();
 
   if (!no_sanity_check)
     if (vect.nb_component != nb_component)
       AKANTU_DEBUG_ERROR(
           "The two arrays do not have the same number of components");
 
   resize((vect.size_ * vect.nb_component) / nb_component);
 
   T * tmp = values;
   std::uninitialized_copy(vect.storage(), vect.storage() + size_ * nb_component,
                           tmp);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_scal> class ArrayPrintHelper {
 public:
   template <typename T>
   static void print_content(const Array<T> & vect, std::ostream & stream,
                             int indent) {
     if (AKANTU_DEBUG_TEST(dblDump) || AKANTU_DEBUG_LEVEL_IS_TEST()) {
       std::string space;
       for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
         ;
 
       stream << space << " + values         : {";
       for (UInt i = 0; i < vect.size(); ++i) {
         stream << "{";
         for (UInt j = 0; j < vect.getNbComponent(); ++j) {
           stream << vect(i, j);
           if (j != vect.getNbComponent() - 1)
             stream << ", ";
         }
         stream << "}";
         if (i != vect.size() - 1)
           stream << ", ";
       }
       stream << "}" << std::endl;
     }
   }
 };
 
 template <> class ArrayPrintHelper<false> {
 public:
   template <typename T>
   static void print_content(__attribute__((unused)) const Array<T> & vect,
                             __attribute__((unused)) std::ostream & stream,
                             __attribute__((unused)) int indent) {}
 };
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 void Array<T, is_scal>::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   std::streamsize prec = stream.precision();
   std::ios_base::fmtflags ff = stream.flags();
 
   stream.setf(std::ios_base::showbase);
   stream.precision(2);
 
   stream << space << "Array<" << debug::demangle(typeid(T).name()) << "> ["
          << std::endl;
   stream << space << " + id             : " << this->id << std::endl;
   stream << space << " + size           : " << this->size_ << std::endl;
   stream << space << " + nb_component   : " << this->nb_component << std::endl;
   stream << space << " + allocated size : " << this->allocated_size
          << std::endl;
   stream << space << " + memory size    : "
          << printMemorySize<T>(allocated_size * nb_component) << std::endl;
   if (!AKANTU_DEBUG_LEVEL_IS_TEST())
     stream << space << " + address        : " << std::hex << this->values
            << std::dec << std::endl;
 
   stream.precision(prec);
   stream.flags(ff);
 
   ArrayPrintHelper<is_scal>::print_content(*this, stream, indent);
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 /* Inline Functions ArrayBase                                                */
 /* -------------------------------------------------------------------------- */
 
 inline UInt ArrayBase::getMemorySize() const {
   return allocated_size * nb_component * size_of_type;
 }
 
 inline void ArrayBase::empty() { size_ = 0; }
 
+#ifndef SWIG
 /* -------------------------------------------------------------------------- */
 /* Iterators                                                                  */
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <class R, class daughter, class IR, bool is_tensor>
 class Array<T, is_scal>::iterator_internal {
 public:
   using value_type = R;
   using pointer = R *;
   using reference = R &;
   using proxy = typename R::proxy;
   using const_proxy = const typename R::proxy;
   using const_reference = const R &;
   using internal_value_type = IR;
   using internal_pointer = IR *;
   using difference_type = std::ptrdiff_t;
   using iterator_category = std::random_access_iterator_tag;
 
 public:
   iterator_internal() = default;
 
   iterator_internal(pointer_type data, UInt _offset)
       : _offset(_offset), initial(data), ret(nullptr), ret_ptr(data) {
     AKANTU_DEBUG_ERROR(
         "The constructor should never be called it is just an ugly trick...");
   }
 
   iterator_internal(std::unique_ptr<internal_value_type> && wrapped)
       : _offset(wrapped->size()), initial(wrapped->storage()),
         ret(std::move(wrapped)), ret_ptr(ret->storage()) {}
 
   iterator_internal(const iterator_internal & it) {
     if (this != &it) {
       this->_offset = it._offset;
       this->initial = it.initial;
       this->ret_ptr = it.ret_ptr;
       this->ret = std::make_unique<internal_value_type>(*it.ret, false);
     }
   }
 
   iterator_internal(iterator_internal && it) = default;
 
   virtual ~iterator_internal() = default;
 
   inline iterator_internal & operator=(const iterator_internal & it) {
     if (this != &it) {
       this->_offset = it._offset;
       this->initial = it.initial;
       this->ret_ptr = it.ret_ptr;
       if (this->ret)
         this->ret->shallowCopy(*it.ret);
       else
         this->ret = std::make_unique<internal_value_type>(*it.ret, false);
     }
     return *this;
   }
 
   UInt getCurrentIndex() {
     return (this->ret_ptr - this->initial) / this->_offset;
   };
 
   inline reference operator*() {
     ret->values = ret_ptr;
     return *ret;
   };
   inline const_reference operator*() const {
     ret->values = ret_ptr;
     return *ret;
   };
   inline pointer operator->() {
     ret->values = ret_ptr;
     return ret.get();
   };
   inline daughter & operator++() {
     ret_ptr += _offset;
     return static_cast<daughter &>(*this);
   };
   inline daughter & operator--() {
     ret_ptr -= _offset;
     return static_cast<daughter &>(*this);
   };
 
   inline daughter & operator+=(const UInt n) {
     ret_ptr += _offset * n;
     return static_cast<daughter &>(*this);
   }
   inline daughter & operator-=(const UInt n) {
     ret_ptr -= _offset * n;
     return static_cast<daughter &>(*this);
   }
 
   inline proxy operator[](const UInt n) {
     ret->values = ret_ptr + n * _offset;
     return proxy(*ret);
   }
   inline const_proxy operator[](const UInt n) const {
     ret->values = ret_ptr + n * _offset;
     return const_proxy(*ret);
   }
 
   inline bool operator==(const iterator_internal & other) const {
     return this->ret_ptr == other.ret_ptr;
   }
   inline bool operator!=(const iterator_internal & other) const {
     return this->ret_ptr != other.ret_ptr;
   }
   inline bool operator<(const iterator_internal & other) const {
     return this->ret_ptr < other.ret_ptr;
   }
   inline bool operator<=(const iterator_internal & other) const {
     return this->ret_ptr <= other.ret_ptr;
   }
   inline bool operator>(const iterator_internal & other) const {
     return this->ret_ptr > other.ret_ptr;
   }
   inline bool operator>=(const iterator_internal & other) const {
     return this->ret_ptr >= other.ret_ptr;
   }
 
   inline daughter operator+(difference_type n) {
     daughter tmp(static_cast<daughter &>(*this));
     tmp += n;
     return tmp;
   }
   inline daughter operator-(difference_type n) {
     daughter tmp(static_cast<daughter &>(*this));
     tmp -= n;
     return tmp;
   }
 
   inline difference_type operator-(const iterator_internal & b) {
     return (this->ret_ptr - b.ret_ptr) / _offset;
   }
 
   inline pointer_type data() const { return ret_ptr; }
   inline difference_type offset() const { return _offset; }
 
 protected:
   UInt _offset{0};
   pointer_type initial{nullptr};
   std::unique_ptr<internal_value_type> ret{nullptr};
   pointer_type ret_ptr{nullptr};
 };
 
 /* -------------------------------------------------------------------------- */
 /**
  * Specialization for scalar types
  */
 template <class T, bool is_scal>
 template <class R, class daughter, class IR>
 class Array<T, is_scal>::iterator_internal<R, daughter, IR, false> {
 public:
   using value_type = R;
   using pointer = R *;
   using reference = R &;
   using const_reference = const R &;
   using internal_value_type = IR;
   using internal_pointer = IR *;
   using difference_type = std::ptrdiff_t;
   using iterator_category = std::random_access_iterator_tag;
 
 public:
   iterator_internal(pointer data = nullptr) : ret(data), initial(data){};
   iterator_internal(const iterator_internal & it) = default;
   iterator_internal(iterator_internal && it) = default;
 
   virtual ~iterator_internal() = default;
 
   inline iterator_internal & operator=(const iterator_internal & it) = default;
 
   UInt getCurrentIndex() { return (this->ret - this->initial); };
 
   inline reference operator*() { return *ret; };
   inline const_reference operator*() const { return *ret; };
   inline pointer operator->() { return ret; };
   inline daughter & operator++() {
     ++ret;
     return static_cast<daughter &>(*this);
   };
   inline daughter & operator--() {
     --ret;
     return static_cast<daughter &>(*this);
   };
 
   inline daughter & operator+=(const UInt n) {
     ret += n;
     return static_cast<daughter &>(*this);
   }
   inline daughter & operator-=(const UInt n) {
     ret -= n;
     return static_cast<daughter &>(*this);
   }
 
   inline reference operator[](const UInt n) { return ret[n]; }
 
   inline bool operator==(const iterator_internal & other) const {
     return ret == other.ret;
   }
   inline bool operator!=(const iterator_internal & other) const {
     return ret != other.ret;
   }
   inline bool operator<(const iterator_internal & other) const {
     return ret < other.ret;
   }
   inline bool operator<=(const iterator_internal & other) const {
     return ret <= other.ret;
   }
   inline bool operator>(const iterator_internal & other) const {
     return ret > other.ret;
   }
   inline bool operator>=(const iterator_internal & other) const {
     return ret >= other.ret;
   }
 
   inline daughter operator-(difference_type n) { return daughter(ret - n); }
   inline daughter operator+(difference_type n) { return daughter(ret + n); }
 
   inline difference_type operator-(const iterator_internal & b) {
     return ret - b.ret;
   }
 
   inline pointer data() const { return ret; }
 
 protected:
   pointer ret{nullptr};
   pointer initial{nullptr};
 };
 
 /* -------------------------------------------------------------------------- */
 /* Begin/End functions implementation                                         */
 /* -------------------------------------------------------------------------- */
 namespace detail {
   template <class Tuple, size_t... Is>
   constexpr auto take_front_impl(Tuple && t, std::index_sequence<Is...>) {
     return std::make_tuple(std::get<Is>(std::forward<Tuple>(t))...);
   }
 
   template <size_t N, class Tuple> constexpr auto take_front(Tuple && t) {
     return take_front_impl(std::forward<Tuple>(t),
                            std::make_index_sequence<N>{});
   }
 
   template <typename... V>
   constexpr auto product_all(V &&... v) ->
       typename std::common_type<V...>::type {
     typename std::common_type<V...>::type result = 1;
     (void)std::initializer_list<int>{(result *= v, 0)...};
     return result;
   }
 
   template <typename... T> std::string to_string_all(T &&... t) {
     if (sizeof...(T) == 0)
       return "";
 
     std::stringstream ss;
     bool noComma = true;
     ss << "(";
     (void)std::initializer_list<bool>{
         (ss << (noComma ? "" : ", ") << t, noComma = false)...};
     ss << ")";
     return ss.str();
   }
 
   template <std::size_t N> struct InstantiationHelper {
     template <typename type, typename T, typename... Ns>
     static auto instantiate(T && data, Ns... ns) {
       return std::make_unique<type>(data, ns...);
     }
   };
 
   template <> struct InstantiationHelper<0> {
     template <typename type, typename T> static auto instantiate(T && data) {
       return data;
     }
   };
 
   template <typename Arr, typename T, typename... Ns>
   decltype(auto) get_iterator(Arr && array, T * data, Ns &&... ns) {
     using type = IteratorHelper_t<sizeof...(Ns) - 1, T>;
     using array_type = std::decay_t<Arr>;
     using iterator =
         std::conditional_t<std::is_const<Arr>::value,
                            typename array_type::template const_iterator<type>,
                            typename array_type::template iterator<type>>;
     if (array.getNbComponent() * array.size() !=
         product_all(std::forward<Ns>(ns)...)) {
       AKANTU_CUSTOM_EXCEPTION_INFO(
           debug::ArrayException(),
           "The iterator on Array "
               << to_string_all(array.size(), array.getNbComponent())
               << "is not compatible with the type "
               << debug::demangle(typeid(type).name()) << to_string_all(ns...));
     }
 
     auto && wrapped = aka::apply(
         [&](auto... n) {
           return InstantiationHelper<sizeof...(n)>::template instantiate<type>(
               data, n...);
         },
         take_front<sizeof...(Ns) - 1>(std::make_tuple(ns...)));
 
     return iterator(std::move(wrapped));
   }
 } // namespace detail
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::begin(Ns &&... ns) {
   return detail::get_iterator(*this, values, std::forward<Ns>(ns)..., size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::end(Ns &&... ns) {
   return detail::get_iterator(*this, values + nb_component * size_,
                               std::forward<Ns>(ns)..., size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::begin(Ns &&... ns) const {
   return detail::get_iterator(*this, values, std::forward<Ns>(ns)..., size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::end(Ns &&... ns) const {
   return detail::get_iterator(*this, values + nb_component * size_,
                               std::forward<Ns>(ns)..., size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::begin_reinterpret(Ns &&... ns) {
   return detail::get_iterator(*this, values, std::forward<Ns>(ns)...);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::end_reinterpret(Ns &&... ns) {
   return detail::get_iterator(
       *this, values + detail::product_all(std::forward<Ns>(ns)...),
       std::forward<Ns>(ns)...);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::begin_reinterpret(Ns &&... ns) const {
   return detail::get_iterator(*this, values, std::forward<Ns>(ns)...);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::end_reinterpret(Ns &&... ns) const {
   return detail::get_iterator(
       *this, values + detail::product_all(std::forward<Ns>(ns)...),
       std::forward<Ns>(ns)...);
 }
 
 /* -------------------------------------------------------------------------- */
 /* Views                                                                      */
 /* -------------------------------------------------------------------------- */
 namespace detail {
   template <typename Array, typename... Ns> class ArrayView {
     using tuple = std::tuple<Ns...>;
 
   public:
     ArrayView(Array && array, Ns &&... ns)
         : array(std::forward<Array>(array)),
           sizes(std::forward<Ns>(ns)...){};
 
     decltype(auto) begin() {
       return aka::apply(
           [&](auto &&... ns) { return array.begin_reinterpret(ns...); }, sizes);
     }
 
     decltype(auto) end() {
       return aka::apply(
           [&](auto &&... ns) { return array.end_reinterpret(ns...); }, sizes);
     }
 
     decltype(auto) size() {
       return std::get<std::tuple_size<tuple>::value - 1>(sizes);
     }
 
   private:
     Array array;
     tuple sizes;
   };
 } // namespace detail
 
 /* -------------------------------------------------------------------------- */
 template <typename Array, typename... Ns>
 decltype(auto) make_view(Array && array, Ns &&... ns) {
   auto size = std::forward<decltype(array)>(array).size() *
               std::forward<decltype(array)>(array).getNbComponent() /
               detail::product_all(ns...);
 
   return detail::ArrayView<Array, Ns..., decltype(size)>(
       std::forward<Array>(array), std::forward<Ns>(ns)...,
       std::forward<decltype(size)>(size));
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <typename R>
 class Array<T, is_scal>::const_iterator
     : public iterator_internal<const R, Array<T, is_scal>::const_iterator<R>,
                                R> {
 public:
   typedef iterator_internal<const R, const_iterator, R> parent;
   using value_type = typename parent::value_type;
   using pointer = typename parent::pointer;
   using reference = typename parent::reference;
   using difference_type = typename parent::difference_type;
   using iterator_category = typename parent::iterator_category;
 
 public:
   const_iterator() : parent(){};
   // const_iterator(pointer_type data, UInt offset) : parent(data, offset) {}
   // const_iterator(pointer warped) : parent(warped) {}
   // const_iterator(const parent & it) : parent(it) {}
 
   const_iterator(const const_iterator & it) = default;
   const_iterator(const_iterator && it) = default;
 
   template <typename P, typename = std::enable_if_t<not is_tensor<P>{}>>
   const_iterator(P * data) : parent(data) {}
 
   template <typename UP_P, typename = std::enable_if_t<
                                is_tensor<typename UP_P::element_type>::value>>
   const_iterator(UP_P && tensor) : parent(std::forward<UP_P>(tensor)) {}
 
   const_iterator & operator=(const const_iterator & it) = default;
 };
 
 template <class T, class R, bool is_tensor_ = is_tensor<R>{}>
 struct ConstConverterIteratorHelper {
   using const_iterator = typename Array<T>::template const_iterator<R>;
   using iterator = typename Array<T>::template iterator<R>;
 
   static inline const_iterator convert(const iterator & it) {
     return const_iterator(std::unique_ptr<R>(new R(*it, false)));
   }
 };
 
 template <class T, class R> struct ConstConverterIteratorHelper<T, R, false> {
   using const_iterator = typename Array<T>::template const_iterator<R>;
   using iterator = typename Array<T>::template iterator<R>;
   static inline const_iterator convert(const iterator & it) {
     return const_iterator(it.data());
   }
 };
 
 template <class T, bool is_scal>
 template <typename R>
 class Array<T, is_scal>::iterator
     : public iterator_internal<R, Array<T, is_scal>::iterator<R>> {
 public:
   using parent = iterator_internal<R, iterator>;
   using value_type = typename parent::value_type;
   using pointer = typename parent::pointer;
   using reference = typename parent::reference;
   using difference_type = typename parent::difference_type;
   using iterator_category = typename parent::iterator_category;
 
 public:
   iterator() : parent(){};
   iterator(const iterator & it) = default;
   iterator(iterator && it) = default;
 
   template <typename P, typename = std::enable_if_t<not is_tensor<P>::value>>
   iterator(P * data) : parent(data) {}
 
   template <typename UP_P, typename = std::enable_if_t<
                                is_tensor<typename UP_P::element_type>::value>>
   iterator(UP_P && tensor) : parent(std::forward<UP_P>(tensor)) {}
 
   iterator & operator=(const iterator & it) = default;
 
   operator const_iterator<R>() {
     return ConstConverterIteratorHelper<T, R>::convert(*this);
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <typename R>
 inline typename Array<T, is_scal>::template iterator<R>
 Array<T, is_scal>::erase(const iterator<R> & it) {
   T * curr = it.data();
   UInt pos = (curr - values) / nb_component;
   erase(pos);
   iterator<R> rit = it;
   return --rit;
 }
+#endif
 
 } // namespace akantu
 
 #endif /* __AKANTU_AKA_ARRAY_TMPL_HH__ */
diff --git a/src/common/aka_csr.hh b/src/common/aka_csr.hh
index 2422d5b44..7da74c725 100644
--- a/src/common/aka_csr.hh
+++ b/src/common/aka_csr.hh
@@ -1,259 +1,259 @@
 /**
  * @file   aka_csr.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Apr 20 2011
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  A compresed sparse row structure based on akantu Arrays
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "aka_common.hh"
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_CSR_HH__
 #define __AKANTU_AKA_CSR_HH__
 
 namespace akantu {
 
 /**
  * This class  can be  used to  store the structure  of a  sparse matrix  or for
  * vectors with variable number of component per element
  *
  * @param nb_rows number of rows of a matrix or size of a vector.
  */
 template <typename T> class CSR {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   explicit CSR(UInt nb_rows = 0)
       : nb_rows(nb_rows), rows_offsets(nb_rows + 1, 1, "rows_offsets"),
         rows(0, 1, "rows") {
     rows_offsets.clear();
   };
 
-  virtual ~CSR(){};
+  virtual ~CSR() = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// does nothing
   inline void beginInsertions(){};
 
   /// insert a new entry val in row row
   inline UInt insertInRow(UInt row, const T & val) {
     UInt pos = rows_offsets(row)++;
     rows(pos) = val;
     return pos;
   }
 
   /// access an element of the matrix
   inline const T & operator()(UInt row, UInt col) const {
     AKANTU_DEBUG_ASSERT(rows_offsets(row + 1) - rows_offsets(row) > col,
                         "This element is not present in this CSR");
     return rows(rows_offsets(row) + col);
   }
 
   /// access an element of the matrix
   inline T & operator()(UInt row, UInt col) {
     AKANTU_DEBUG_ASSERT(rows_offsets(row + 1) - rows_offsets(row) > col,
                         "This element is not present in this CSR");
     return rows(rows_offsets(row) + col);
   }
 
   inline void endInsertions() {
     for (UInt i = nb_rows; i > 0; --i)
       rows_offsets(i) = rows_offsets(i - 1);
     rows_offsets(0) = 0;
   }
 
   inline void countToCSR() {
     for (UInt i = 1; i < nb_rows; ++i)
       rows_offsets(i) += rows_offsets(i - 1);
     for (UInt i = nb_rows; i >= 1; --i)
       rows_offsets(i) = rows_offsets(i - 1);
     rows_offsets(0) = 0;
   }
 
   inline void clearRows() {
     rows_offsets.clear();
     rows.resize(0);
   };
 
   inline void resizeRows(UInt nb_rows) {
     this->nb_rows = nb_rows;
     rows_offsets.resize(nb_rows + 1);
     rows_offsets.clear();
   }
 
   inline void resizeCols() { rows.resize(rows_offsets(nb_rows)); }
 
   inline void copy(Array<UInt> & offsets, Array<T> & values) {
     offsets.copy(rows_offsets);
     values.copy(rows);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// returns the number of rows
   inline UInt getNbRows() const { return rows_offsets.size() - 1; };
 
   /// returns the number of non-empty columns in a given row
   inline UInt getNbCols(UInt row) const {
     return rows_offsets(row + 1) - rows_offsets(row);
   };
 
   /// returns the offset (start of columns) for a given row
   inline UInt & rowOffset(UInt row) { return rows_offsets(row); };
 
   /// iterator on a row
   template <class R>
   class iterator_internal
       : public std::iterator<std::bidirectional_iterator_tag, R> {
   public:
     typedef std::iterator<std::bidirectional_iterator_tag, R> _parent;
-    typedef typename _parent::pointer pointer;
-    typedef typename _parent::reference reference;
+    using pointer = typename _parent::pointer;
+    using reference = typename _parent::reference;
 
     explicit iterator_internal(pointer x = nullptr) : pos(x){};
     iterator_internal(const iterator_internal & it) : pos(it.pos){};
 
     iterator_internal & operator++() {
       ++pos;
       return *this;
     };
     iterator_internal operator++(int) {
       iterator tmp(*this);
       operator++();
       return tmp;
     };
 
     iterator_internal & operator--() {
       --pos;
       return *this;
     };
     iterator_internal operator--(int) {
       iterator_internal tmp(*this);
       operator--();
       return tmp;
     };
 
     bool operator==(const iterator_internal & rhs) { return pos == rhs.pos; };
     bool operator!=(const iterator_internal & rhs) { return pos != rhs.pos; };
     reference operator*() { return *pos; };
     pointer operator->() const { return pos; };
 
   private:
     pointer pos;
   };
 
-  typedef iterator_internal<T> iterator;
-  typedef iterator_internal<const T> const_iterator;
+  using iterator = iterator_internal<T>;
+  using const_iterator = iterator_internal<const T>;
 
   inline iterator begin(UInt row) {
     return iterator(rows.storage() + rows_offsets(row));
   };
   inline iterator end(UInt row) {
     return iterator(rows.storage() + rows_offsets(row + 1));
   };
 
   inline const_iterator begin(UInt row) const {
     return const_iterator(rows.storage() + rows_offsets(row));
   };
   inline const_iterator end(UInt row) const {
     return const_iterator(rows.storage() + rows_offsets(row + 1));
   };
 
   inline iterator rbegin(UInt row) {
     return iterator(rows.storage() + rows_offsets(row + 1) - 1);
   };
   inline iterator rend(UInt row) {
     return iterator(rows.storage() + rows_offsets(row) - 1);
   };
 
   inline const Array<UInt> & getRowsOffset() const { return rows_offsets; };
   inline const Array<T> & getRows() const { return rows; };
   inline Array<T> & getRows() { return rows; };
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   UInt nb_rows;
 
   /// array of size nb_rows containing the offset where the values are stored in
   Array<UInt> rows_offsets;
 
   /// compressed row values, values of row[i] are stored between rows_offsets[i]
   /// and rows_offsets[i+1]
   Array<T> rows;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Data CSR                                                                   */
 /* -------------------------------------------------------------------------- */
 
 /**
  * Inherits from  CSR<UInt> and  can contain information  such as  matrix values
  * where the mother class would be a CSR structure for row and cols
  *
  * @return nb_rows
  */
 template <class T> class DataCSR : public CSR<UInt> {
 public:
   DataCSR(UInt nb_rows = 0) : CSR<UInt>(nb_rows), data(0, 1){};
 
   inline void resizeCols() {
     CSR<UInt>::resizeCols();
     data.resize(rows_offsets(nb_rows));
   }
 
   inline const Array<T> & getData() const { return data; };
 
 private:
   Array<T> data;
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 //#include "aka_csr_inline_impl.cc"
 
 /// standard output stream operator
 // inline std::ostream & operator <<(std::ostream & stream, const CSR & _this)
 // {
 //   _this.printself(stream);
 //   return stream;
 // }
 
 } // akantu
 
 #endif /* __AKANTU_AKA_CSR_HH__ */
diff --git a/src/common/aka_error.cc b/src/common/aka_error.cc
index 04209802d..6eebb30a7 100644
--- a/src/common/aka_error.cc
+++ b/src/common/aka_error.cc
@@ -1,355 +1,355 @@
 /**
  * @file   aka_error.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Sep 06 2010
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  handling of errors
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_error.hh"
 #include "aka_common.hh"
 #include "aka_config.hh"
 /* -------------------------------------------------------------------------- */
 #include <csignal>
 #include <iostream>
 
 #if (defined(READLINK_COMMAND) || defined(ADDR2LINE_COMMAND)) &&               \
     (not defined(_WIN32))
 #include <execinfo.h>
 #include <sys/wait.h>
 #endif
 
 #include <cmath>
 #include <cstring>
 #include <cxxabi.h>
 #include <fstream>
 #include <iomanip>
 #include <map>
 #include <sys/types.h>
 #include <unistd.h>
 
 #if defined(AKANTU_CORE_CXX11)
 #include <chrono>
 #elif defined(AKANTU_USE_OBSOLETE_GETTIMEOFDAY)
 #include <sys/time.h>
 #else
 #include <time.h>
 #endif
 
 #ifdef AKANTU_USE_MPI
 #include <mpi.h>
 #endif
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 namespace debug {
 
   static void printBacktraceAndExit(int) { std::terminate(); }
 
   /* ------------------------------------------------------------------------ */
   void initSignalHandler() { std::signal(SIGSEGV, &printBacktraceAndExit); }
 
   /* ------------------------------------------------------------------------ */
   std::string demangle(const char * symbol) {
     int status;
     std::string result;
     char * demangled_name;
 
     if ((demangled_name = abi::__cxa_demangle(symbol, nullptr, nullptr,
                                               &status)) != nullptr) {
       result = demangled_name;
       free(demangled_name);
     } else {
       result = symbol;
     }
 
     return result;
   }
 
 /* ------------------------------------------------------------------------ */
 #if (defined(READLINK_COMMAND) || defined(ADDR2LINK_COMMAND)) &&               \
     (not defined(_WIN32))
-  std::string exec(std::string cmd) {
+  std::string exec(const std::string & cmd) {
     FILE * pipe = popen(cmd.c_str(), "r");
     if (!pipe)
       return "";
     char buffer[1024];
     std::string result = "";
     while (!feof(pipe)) {
       if (fgets(buffer, 128, pipe) != nullptr)
         result += buffer;
     }
 
     result = result.substr(0, result.size() - 1);
     pclose(pipe);
     return result;
   }
 #endif
 
   /* ------------------------------------------------------------------------ */
   void printBacktrace(__attribute__((unused)) int sig) {
     AKANTU_DEBUG_INFO("Caught  signal " << sig << "!");
 
 #if not defined(_WIN32)
 #if defined(READLINK_COMMAND) && defined(ADDR2LINE_COMMAND)
     std::string me = "";
     char buf[1024];
     /* The manpage says it won't null terminate.  Let's zero the buffer. */
     memset(buf, 0, sizeof(buf));
     /* Note we use sizeof(buf)-1 since we may need an extra char for NUL. */
     if (readlink("/proc/self/exe", buf, sizeof(buf) - 1))
       me = std::string(buf);
 
     std::ifstream inmaps;
     inmaps.open("/proc/self/maps");
     std::map<std::string, size_t> addr_map;
     std::string line;
     while (inmaps.good()) {
       std::getline(inmaps, line);
       std::stringstream sstr(line);
 
       size_t first = line.find('-');
       std::stringstream sstra(line.substr(0, first));
       size_t addr;
       sstra >> std::hex >> addr;
 
       std::string lib;
       sstr >> lib; sstr >> lib;
       sstr >> lib; sstr >> lib;
       sstr >> lib; sstr >> lib;
       if (lib != "" && addr_map.find(lib) == addr_map.end()) {
         addr_map[lib] = addr;
       }
     }
 
     if (me != "")
       addr_map[me] = 0;
 #endif
 
     /// \todo for windows this part could be coded using CaptureStackBackTrace
     /// and SymFromAddr
     const size_t max_depth = 100;
     size_t stack_depth;
     void * stack_addrs[max_depth];
     char ** stack_strings;
 
     size_t i;
     stack_depth = backtrace(stack_addrs, max_depth);
     stack_strings = backtrace_symbols(stack_addrs, stack_depth);
 
     std::cerr << "BACKTRACE :  " << stack_depth << " stack frames."
               << std::endl;
-    size_t w = size_t(std::floor(log(double(stack_depth)) / std::log(10.)) + 1);
+    auto w = size_t(std::floor(log(double(stack_depth)) / std::log(10.)) + 1);
 
     /// -1 to remove the call to the printBacktrace function
     for (i = 1; i < stack_depth; i++) {
       std::cerr << std::dec << "  [" << std::setw(w) << i << "] ";
       std::string bt_line(stack_strings[i]);
       size_t first, second;
 
       if ((first = bt_line.find('(')) != std::string::npos &&
           (second = bt_line.find('+')) != std::string::npos) {
         std::string location = bt_line.substr(0, first);
 #if defined(READLINK_COMMAND)
         location = exec(std::string(BOOST_PP_STRINGIZE(READLINK_COMMAND)) +
                         std::string(" -f ") + location);
 #endif
         std::string call =
             demangle(bt_line.substr(first + 1, second - first - 1).c_str());
         size_t f = bt_line.find('[');
         size_t s = bt_line.find(']');
         std::string address = bt_line.substr(f + 1, s - f - 1);
         std::stringstream sstra(address);
         size_t addr;
         sstra >> std::hex >> addr;
 
         std::cerr << location << " [" << call << "]";
 
 #if defined(READLINK_COMMAND) && defined(ADDR2LINE_COMMAND)
-        std::map<std::string, size_t>::iterator it = addr_map.find(location);
+        auto it = addr_map.find(location);
         if (it != addr_map.end()) {
           std::stringstream syscom;
           syscom << BOOST_PP_STRINGIZE(ADDR2LINE_COMMAND) << " 0x" << std::hex
                  << (addr - it->second) << " -i -e " << location;
           std::string line = exec(syscom.str());
           std::cerr << " (" << line << ")" << std::endl;
         } else {
 #endif
           std::cerr << " (0x" << std::hex << addr << ")" << std::endl;
 #if defined(READLINK_COMMAND) && defined(ADDR2LINE_COMMAND)
         }
 #endif
       } else {
         std::cerr << bt_line << std::endl;
       }
     }
 
     free(stack_strings);
 
     std::cerr << "END BACKTRACE" << std::endl;
 #endif
   }
 
   /* ------------------------------------------------------------------------ */
   namespace {
     void terminate_handler() {
       auto eptr = std::current_exception();
       auto t = abi::__cxa_current_exception_type();
       auto name = t ? demangle(t->name()) : std::string("unknown");
       try {
         if (eptr)
           std::rethrow_exception(eptr);
         else
           std::cerr << "!! Execution terminated for unknown reasons !!"
                     << std::endl;
       } catch (std::exception & e) {
         std::cerr << "!! Uncaught exception of type " << name
                   << " !!\nwhat(): \"" << e.what() << "\"" << std::endl;
       } catch (...) {
         std::cerr << "!! Something strange of type \"" << name
                   << "\" was thrown.... !!" << std::endl;
       }
 
       if (debugger.printBacktrace())
         printBacktrace(15);
     }
   } // namespace
   /* ------------------------------------------------------------------------ */
   /* ------------------------------------------------------------------------ */
   Debugger::Debugger() {
     cout = &std::cerr;
     level = dblWarning;
     parallel_context = "";
     file_open = false;
     print_backtrace = false;
 
     initSignalHandler();
     std::set_terminate(terminate_handler);
   }
 
   /* ------------------------------------------------------------------------ */
   Debugger::~Debugger() {
     if (file_open) {
       dynamic_cast<std::ofstream *>(cout)->close();
       delete cout;
     }
   }
 
   /* ------------------------------------------------------------------------ */
   void Debugger::exit(int status) {
     if (status != 0)
       std::terminate();
 
     std::exit(0);
   }
 
   /*------------------------------------------------------------------------- */
   void Debugger::throwException(const std::string & info,
                                 const std::string & file, unsigned int line,
                                 __attribute__((unused)) bool silent,
                                 __attribute__((unused))
                                 const std::string & location) const
       noexcept(false) {
 
 #if !defined(AKANTU_NDEBUG)
     if (!silent) {
       printMessage("###", dblWarning, info + location);
     }
 #endif
 
     debug::Exception ex(info, file, line);
     throw ex;
   }
 
   /* ------------------------------------------------------------------------ */
   void Debugger::printMessage(const std::string & prefix,
                               const DebugLevel & level,
                               const std::string & info) const {
     if (this->level >= level) {
 #if defined(AKANTU_CORE_CXX11)
       double timestamp =
           std::chrono::duration_cast<std::chrono::duration<double, std::micro>>(
               std::chrono::system_clock::now().time_since_epoch())
               .count();
 #elif defined(AKANTU_USE_OBSOLETE_GETTIMEOFDAY)
       struct timeval time;
       gettimeofday(&time, NULL);
       double timestamp = time.tv_sec * 1e6 + time.tv_usec; /*in us*/
 #else
       struct timespec time;
       clock_gettime(CLOCK_REALTIME_COARSE, &time);
       double timestamp = time.tv_sec * 1e6 + time.tv_nsec * 1e-3; /*in us*/
 #endif
       *(cout) << parallel_context << "{" << (size_t)timestamp << "} " << prefix
               << " " << info << std::endl;
     }
   }
 
   /* ------------------------------------------------------------------------ */
   void Debugger::setDebugLevel(const DebugLevel & level) {
     this->level = level;
   }
 
   /* ------------------------------------------------------------------------ */
   const DebugLevel & Debugger::getDebugLevel() const { return this->level; }
 
   /* ------------------------------------------------------------------------ */
   void Debugger::setLogFile(const std::string & filename) {
     if (file_open) {
       dynamic_cast<std::ofstream *>(cout)->close();
       delete cout;
     }
 
-    std::ofstream * fileout = new std::ofstream(filename.c_str());
+    auto * fileout = new std::ofstream(filename.c_str());
     file_open = true;
     cout = fileout;
   }
 
   std::ostream & Debugger::getOutputStream() { return *cout; }
 
   /* ------------------------------------------------------------------------ */
   void Debugger::setParallelContext(int rank, int size) {
     std::stringstream sstr;
     UInt pad = std::ceil(std::log10(size));
     sstr << "<" << getpid() << ">[R" << std::setfill(' ') << std::right
          << std::setw(pad) << rank << "|S" << size << "] ";
     parallel_context = sstr.str();
   }
 
   void setDebugLevel(const DebugLevel & level) {
     debugger.setDebugLevel(level);
   }
 
   const DebugLevel & getDebugLevel() { return debugger.getDebugLevel(); }
 
   /* --------------------------------------------------------------------------
    */
   void exit(int status) { debugger.exit(status); }
 
 } // namespace debug
 } // namespace akantu
diff --git a/src/common/aka_error.hh b/src/common/aka_error.hh
index 0e77daed5..ff2e2675f 100644
--- a/src/common/aka_error.hh
+++ b/src/common/aka_error.hh
@@ -1,338 +1,338 @@
 /**
  * @file   aka_error.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Jun 14 2010
  * @date last modification: Mon Jul 13 2015
  *
  * @brief  error management and internal exceptions
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include <sstream>
 #include <typeinfo>
 #include <utility>
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __AKANTU_ERROR_HH__
 #define __AKANTU_ERROR_HH__
 
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 enum DebugLevel {
   dbl0 = 0,
   dblError = 0,
   dblAssert = 0,
   dbl1 = 1,
   dblException = 1,
   dblCritical = 1,
   dbl2 = 2,
   dblMajor = 2,
   dbl3 = 3,
   dblCall = 3,
   dblSecondary = 3,
   dblHead = 3,
   dbl4 = 4,
   dblWarning = 4,
   dbl5 = 5,
   dblInfo = 5,
   dbl6 = 6,
   dblIn = 6,
   dblOut = 6,
   dbl7 = 7,
   dbl8 = 8,
   dblTrace = 8,
   dbl9 = 9,
   dblAccessory = 9,
   dbl10 = 10,
   dblDebug = 42,
   dbl100 = 100,
   dblDump = 100,
   dblTest = 1337
 };
 
 /* -------------------------------------------------------------------------- */
 #define AKANTU_LOCATION                                                        \
   "(" << __func__ << "(): " << __FILE__ << ":" << __LINE__ << ")"
 
 /* -------------------------------------------------------------------------- */
 namespace debug {
   void setDebugLevel(const DebugLevel & level);
   const DebugLevel & getDebugLevel();
 
   void initSignalHandler();
   std::string demangle(const char * symbol);
-  std::string exec(std::string cmd);
+  std::string exec(const std::string & cmd);
 
   void printBacktrace(int sig);
 
   void exit(int status) __attribute__((noreturn));
   /* ------------------------------------------------------------------------ */
   /// exception class that can be thrown by akantu
   class Exception : public std::exception {
     /* ---------------------------------------------------------------------- */
     /* Constructors/Destructors                                               */
     /* ---------------------------------------------------------------------- */
   protected:
     explicit Exception(std::string info = "")
         : _info(std::move(info)), _file("") {}
 
   public:
     //! full constructor
     Exception(std::string info, std::string file, unsigned int line)
         : _info(std::move(info)), _file(std::move(file)), _line(line) {}
 
     //! destructor
     ~Exception() noexcept override = default;
 
     /* ---------------------------------------------------------------------- */
     /*  Methods */
     /* ---------------------------------------------------------------------- */
   public:
     const char * what() const noexcept override { return _info.c_str(); }
 
     virtual const std::string info() const noexcept {
       std::stringstream stream;
       stream << debug::demangle(typeid(*this).name()) << " : " << _info << " ["
              << _file << ":" << _line << "]";
       return stream.str();
     }
 
   public:
     void setInfo(const std::string & info) { _info = info; }
     void setFile(const std::string & file) { _file = file; }
     void setLine(unsigned int line) { _line = line; }
     /* ---------------------------------------------------------------------- */
     /* Class Members                                                          */
     /* ---------------------------------------------------------------------- */
   protected:
     /// exception description and additionals
     std::string _info;
 
   private:
     /// file it is thrown from
     std::string _file;
 
     /// ligne it is thrown from
     unsigned int _line{0};
   };
 
   class CriticalError : public Exception {};
   class AssertException : public Exception {};
 
   /// standard output stream operator
   inline std::ostream & operator<<(std::ostream & stream,
                                    const Exception & _this) {
     stream << _this.what();
     return stream;
   }
 
   /* --------------------------------------------------------------------------
    */
   class Debugger {
   public:
     Debugger();
     virtual ~Debugger();
     Debugger(const Debugger &) = default;
     Debugger & operator=(const Debugger &) = default;
 
     void exit(int status) __attribute__((noreturn));
 
     void throwException(const std::string & info, const std::string & file,
                         unsigned int line, bool, const std::string &) const
         noexcept(false) __attribute__((noreturn));
 
     /*----------------------------------------------------------------------- */
     template <class Except>
     void throwCustomException(const Except & ex, const std::string & info,
                               const std::string & file, unsigned int line) const
         noexcept(false) __attribute__((noreturn));
     /*----------------------------------------------------------------------- */
     template <class Except>
     void throwCustomException(const Except & ex, const std::string & file,
                               unsigned int line) const noexcept(false)
         __attribute__((noreturn));
 
     void printMessage(const std::string & prefix, const DebugLevel & level,
                       const std::string & info) const;
 
     void setOutStream(std::ostream & out) { cout = &out; }
     std::ostream & getOutStream() { return *cout; }
 
   public:
     void setParallelContext(int rank, int size);
 
     void setDebugLevel(const DebugLevel & level);
     const DebugLevel & getDebugLevel() const;
 
     void setLogFile(const std::string & filename);
     std::ostream & getOutputStream();
 
     inline bool testLevel(const DebugLevel & level) const {
       return (this->level >= (level));
     }
 
     void printBacktrace(bool on_off) { this->print_backtrace = on_off; }
     bool printBacktrace() { return this->print_backtrace; }
 
   private:
     std::string parallel_context;
     std::ostream * cout;
     bool file_open;
     DebugLevel level;
     bool print_backtrace;
   };
 
   extern Debugger debugger;
 } // namespace debug
 
 /* -------------------------------------------------------------------------- */
 #define AKANTU_STRINGSTREAM_IN(_str, _sstr)                                    \
   ;                                                                            \
   do {                                                                         \
     std::stringstream _dbg_s_info;                                             \
     _dbg_s_info << _sstr;                                                      \
     _str = _dbg_s_info.str();                                                  \
   } while (false)
 
 /* -------------------------------------------------------------------------- */
 #define AKANTU_EXCEPTION(info) AKANTU_EXCEPTION_(info, false)
 
 #define AKANTU_SILENT_EXCEPTION(info) AKANTU_EXCEPTION_(info, true)
 
 #define AKANTU_EXCEPTION_(info, silent)                                        \
   do {                                                                         \
     std::stringstream _dbg_str;                                                \
     _dbg_str << info;                                                          \
     std::stringstream _dbg_loc;                                                \
     _dbg_loc << AKANTU_LOCATION;                                               \
     ::akantu::debug::debugger.throwException(                                  \
         _dbg_str.str(), __FILE__, __LINE__, silent, _dbg_loc.str());           \
   } while (false)
 
 #define AKANTU_CUSTOM_EXCEPTION_INFO(ex, info)                                 \
   do {                                                                         \
     std::stringstream _dbg_str;                                                \
     _dbg_str << info;                                                          \
     ::akantu::debug::debugger.throwCustomException(ex, _dbg_str.str(),         \
                                                    __FILE__, __LINE__);        \
   } while (false)
 
 #define AKANTU_CUSTOM_EXCEPTION(ex)                                            \
   do {                                                                         \
     ::akantu::debug::debugger.throwCustomException(ex, __FILE__, __LINE__);    \
   } while (false)
 
 /* -------------------------------------------------------------------------- */
 #ifdef AKANTU_NDEBUG
 #define AKANTU_DEBUG_TEST(level) (false)
 #define AKANTU_DEBUG_LEVEL_IS_TEST()                                           \
   (::akantu::debug::debugger.testLevel(dblTest))
 #define AKANTU_DEBUG(level, info)
 #define AKANTU_DEBUG_(pref, level, info)
 #define AKANTU_DEBUG_IN()
 #define AKANTU_DEBUG_OUT()
 #define AKANTU_DEBUG_INFO(info)
 #define AKANTU_DEBUG_WARNING(info)
 #define AKANTU_DEBUG_TRACE(info)
 #define AKANTU_DEBUG_ASSERT(test, info)
 #define AKANTU_DEBUG_ERROR(info)                                               \
   AKANTU_CUSTOM_EXCEPTION_INFO(::akantu::debug::CriticalError(), info)
 #define AKANTU_DEBUG_TO_IMPLEMENT() ::akantu::debug::debugger.exit(EXIT_FAILURE)
 
 /* -------------------------------------------------------------------------- */
 #else
 #define AKANTU_DEBUG(level, info) AKANTU_DEBUG_("   ", level, info)
 
 #define AKANTU_DEBUG_(pref, level, info)                                       \
   do {                                                                         \
     std::string _dbg_str;                                                      \
     AKANTU_STRINGSTREAM_IN(_dbg_str, info << " " << AKANTU_LOCATION);          \
     ::akantu::debug::debugger.printMessage(pref, level, _dbg_str);             \
   } while (false)
 
 #define AKANTU_DEBUG_TEST(level) (::akantu::debug::debugger.testLevel(level))
 
 #define AKANTU_DEBUG_LEVEL_IS_TEST()                                           \
   (::akantu::debug::debugger.testLevel(dblTest))
 
 #define AKANTU_DEBUG_IN()                                                      \
   AKANTU_DEBUG_("==>", ::akantu::dblIn, __func__ << "()")
 
 #define AKANTU_DEBUG_OUT()                                                     \
   AKANTU_DEBUG_("<==", ::akantu::dblOut, __func__ << "()")
 
 #define AKANTU_DEBUG_INFO(info) AKANTU_DEBUG_("---", ::akantu::dblInfo, info)
 
 #define AKANTU_DEBUG_WARNING(info)                                             \
   AKANTU_DEBUG_("/!\\", ::akantu::dblWarning, info)
 
 #define AKANTU_DEBUG_TRACE(info) AKANTU_DEBUG_(">>>", ::akantu::dblTrace, info)
 
 #define AKANTU_DEBUG_ASSERT(test, info)                                        \
   do {                                                                         \
     if (not (test))                                                     \
       AKANTU_CUSTOM_EXCEPTION_INFO(::akantu::debug::AssertException(),         \
                                    "assert [" << #test << "] " << info);       \
   } while (false)
 
 #define AKANTU_DEBUG_ERROR(info)                                               \
   do {                                                                         \
     AKANTU_DEBUG_("!!! ", ::akantu::dblError, info);                           \
     std::terminate();                                                          \
   } while (false)
 
 #define AKANTU_DEBUG_TO_IMPLEMENT()                                            \
   AKANTU_DEBUG_ERROR(__func__ << " : not implemented yet !")
 #endif // AKANTU_NDEBUG
 
 /* -------------------------------------------------------------------------- */
 
 namespace debug {
   /* ------------------------------------------------------------------------ */
   template <class Except>
   void Debugger::throwCustomException(const Except & ex,
                                       const std::string & info,
                                       const std::string & file,
                                       unsigned int line) const noexcept(false) {
     auto & nc_ex = const_cast<Except &>(ex);
     nc_ex.setInfo(info);
     nc_ex.setFile(file);
     nc_ex.setLine(line);
     throw ex;
   }
   /* ------------------------------------------------------------------------ */
   template <class Except>
   void Debugger::throwCustomException(const Except & ex,
                                       const std::string & file,
                                       unsigned int line) const noexcept(false) {
     auto & nc_ex = const_cast<Except &>(ex);
     nc_ex.setFile(file);
     nc_ex.setLine(line);
     throw ex;
   }
 } // namespace debug
 } // namespace akantu
 
 #endif /* __AKANTU_ERROR_HH__ */
diff --git a/src/common/aka_event_handler_manager.hh b/src/common/aka_event_handler_manager.hh
index e91b181f6..599d58d2e 100644
--- a/src/common/aka_event_handler_manager.hh
+++ b/src/common/aka_event_handler_manager.hh
@@ -1,125 +1,125 @@
 /**
  * @file   aka_event_handler_manager.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Wed Dec 16 2015
  *
  * @brief  Base of Event Handler classes
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_EVENT_HANDLER_MANAGER_HH__
 #define __AKANTU_AKA_EVENT_HANDLER_MANAGER_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <list>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 template <class EventHandler> class EventHandlerManager {
 private:
   typedef std::pair<EventHandlerPriority, EventHandler *> priority_value;
-  typedef std::list<priority_value> priority_list;
+  using priority_list = std::list<priority_value>;
   struct KeyComp {
     bool operator()(const priority_value & a, const priority_value & b) const {
       return (a.first < b.first);
     }
     bool operator()(const priority_value & a, UInt b) const {
       return (a.first < b);
     }
   };
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-  virtual ~EventHandlerManager(){};
+  virtual ~EventHandlerManager() = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// register a new EventHandler to the Manager. The register object
   /// will then be informed about the events the manager observes.
   void registerEventHandler(EventHandler & event_handler,
                             EventHandlerPriority priority = _ehp_highest) {
     auto it = this->searchEventHandler(event_handler);
 
     if (it != this->event_handlers.end()) {
       AKANTU_EXCEPTION("This event handler was already registered");
     }
 
     auto pos =
         std::lower_bound(this->event_handlers.begin(),
                          this->event_handlers.end(), priority, KeyComp());
 
     this->event_handlers.insert(pos, std::make_pair(priority, &event_handler));
   }
 
   /// unregister a EventHandler object. This object will not be
   /// notified anymore about the events this manager observes.
   void unregisterEventHandler(EventHandler & event_handler) {
     auto it = this->searchEventHandler(event_handler);
 
     if (it == this->event_handlers.end()) {
       AKANTU_EXCEPTION("This event handler is not registered");
     }
 
     this->event_handlers.erase(it);
   }
 
   /// Notify all the registered EventHandlers about the event that just occured.
   template <class Event> void sendEvent(const Event & event) {
     for (auto & pair : this->event_handlers)
       pair.second->sendEvent(event);
   }
 
 private:
   typename priority_list::iterator searchEventHandler(EventHandler & handler) {
     auto it = this->event_handlers.begin();
     auto end = this->event_handlers.end();
 
     for (; it != end && it->second != &handler; ++it)
       ;
 
     return it;
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// list of the event handlers
   priority_list event_handlers;
 };
 
 } // namespace akantu
 
 #endif /* __AKANTU_AKA_EVENT_HANDLER_MANAGER_HH__ */
diff --git a/src/common/aka_grid_dynamic.hh b/src/common/aka_grid_dynamic.hh
index f0600ad1a..db86a0bdb 100644
--- a/src/common/aka_grid_dynamic.hh
+++ b/src/common/aka_grid_dynamic.hh
@@ -1,512 +1,512 @@
 /**
  * @file   aka_grid_dynamic.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Feb 21 2013
  * @date last modification: Sat Sep 26 2015
  *
  * @brief  Grid that is auto balanced
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "aka_common.hh"
 #include "aka_types.hh"
 
 #include <iostream>
 
 /* -------------------------------------------------------------------------- */
 #include <map>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_GRID_DYNAMIC_HH__
 #define __AKANTU_AKA_GRID_DYNAMIC_HH__
 
 namespace akantu {
 
 class Mesh;
 
 template <typename T> class SpatialGrid {
 public:
   explicit SpatialGrid(UInt dimension)
       : dimension(dimension), spacing(dimension), center(dimension),
         lower(dimension), upper(dimension), empty_cell() {}
 
   SpatialGrid(UInt dimension, const Vector<Real> & spacing,
               const Vector<Real> & center)
       : dimension(dimension), spacing(spacing), center(center),
         lower(dimension), upper(dimension), empty_cell() {
     for (UInt i = 0; i < dimension; ++i) {
       lower(i) = std::numeric_limits<Real>::max();
       upper(i) = -std::numeric_limits<Real>::max();
     }
   }
 
   virtual ~SpatialGrid() = default;
 
   class neighbor_cells_iterator;
   class cells_iterator;
 
   class CellID {
   public:
     CellID() : ids() {}
     explicit CellID(UInt dimention) : ids(dimention) {}
     void setID(UInt dir, Int id) { ids(dir) = id; }
     Int getID(UInt dir) const { return ids(dir); }
 
     bool operator<(const CellID & id) const {
       return std::lexicographical_compare(
           ids.storage(), ids.storage() + ids.size(), id.ids.storage(),
           id.ids.storage() + id.ids.size());
     }
 
     bool operator==(const CellID & id) const {
       return std::equal(ids.storage(), ids.storage() + ids.size(),
                         id.ids.storage());
     }
 
     bool operator!=(const CellID & id) const { return !(operator==(id)); }
 
     class neighbor_cells_iterator
         : private std::iterator<std::forward_iterator_tag, UInt> {
     public:
       neighbor_cells_iterator(const CellID & cell_id, bool end)
           : cell_id(cell_id), position(cell_id.ids.size(), end ? 1 : -1) {
 
         this->updateIt();
         if (end)
           this->it++;
       }
 
       neighbor_cells_iterator & operator++() {
         UInt i = 0;
         for (; i < position.size() && position(i) == 1; ++i)
           ;
 
         if (i == position.size()) {
           ++it;
           return *this;
         }
 
         for (UInt j = 0; j < i; ++j)
           position(j) = -1;
         position(i)++;
         updateIt();
 
         return *this;
       }
 
       neighbor_cells_iterator operator++(int) {
         neighbor_cells_iterator tmp(*this);
         operator++();
         return tmp;
       };
 
       bool operator==(const neighbor_cells_iterator & rhs) const {
         return cell_id == rhs.cell_id && it == rhs.it;
       };
       bool operator!=(const neighbor_cells_iterator & rhs) const {
         return !operator==(rhs);
       };
 
       CellID operator*() const {
         CellID cur_cell_id(cell_id);
         cur_cell_id.ids += position;
         return cur_cell_id;
       };
 
     private:
       void updateIt() {
         it = 0;
         for (UInt i = 0; i < position.size(); ++i)
           it = it * 3 + (position(i) + 1);
       }
 
     private:
       /// central cell id
       const CellID & cell_id;
       // number representing the current neighbor in base 3;
       UInt it;
       // current cell shift
       Vector<Int> position;
     };
 
     class Neighbors {
     public:
       explicit Neighbors(const CellID & cell_id) : cell_id(cell_id) {}
       decltype(auto) begin() { return neighbor_cells_iterator(cell_id, false); }
       decltype(auto) end() { return neighbor_cells_iterator(cell_id, true); }
 
     private:
       const CellID & cell_id;
     };
 
     decltype(auto) neighbors() { return Neighbors(*this); }
 
   private:
     friend class cells_iterator;
     Vector<Int> ids;
   };
 
   /* ------------------------------------------------------------------------ */
   class Cell {
   public:
     using iterator = typename std::vector<T>::iterator;
     using const_iterator = typename std::vector<T>::const_iterator;
 
     Cell() : id(), data() {}
 
     explicit Cell(const CellID & cell_id) : id(cell_id), data() {}
 
     bool operator==(const Cell & cell) const { return id == cell.id; }
     bool operator!=(const Cell & cell) const { return id != cell.id; }
 
     Cell & add(const T & d) {
       data.push_back(d);
       return *this;
     }
 
     iterator begin() { return data.begin(); }
     const_iterator begin() const { return data.begin(); }
 
     iterator end() { return data.end(); }
     const_iterator end() const { return data.end(); }
 
   private:
     CellID id;
     std::vector<T> data;
   };
 
 private:
   using cells_container = std::map<CellID, Cell>;
 
 public:
   const Cell & getCell(const CellID & cell_id) const {
     auto it = cells.find(cell_id);
     if (it != cells.end())
       return it->second;
     return empty_cell;
   }
 
   decltype(auto) beginCell(const CellID & cell_id) {
     auto it = cells.find(cell_id);
     if (it != cells.end())
       return it->second.begin();
     return empty_cell.begin();
   }
 
   decltype(auto) endCell(const CellID & cell_id) {
     auto it = cells.find(cell_id);
     if (it != cells.end())
       return it->second.end();
     return empty_cell.end();
   }
 
   decltype(auto) beginCell(const CellID & cell_id) const {
     auto it = cells.find(cell_id);
     if (it != cells.end())
       return it->second.begin();
     return empty_cell.begin();
   }
 
   decltype(auto) endCell(const CellID & cell_id) const {
     auto it = cells.find(cell_id);
     if (it != cells.end())
       return it->second.end();
     return empty_cell.end();
   }
 
   /* ------------------------------------------------------------------------ */
   class cells_iterator
       : private std::iterator<std::forward_iterator_tag, CellID> {
   public:
     explicit cells_iterator(typename std::map<CellID, Cell>::const_iterator it)
         : it(it) {}
 
     cells_iterator & operator++() {
       this->it++;
       return *this;
     }
 
     cells_iterator operator++(int) {
       cells_iterator tmp(*this);
       operator++();
       return tmp;
     };
 
     bool operator==(const cells_iterator & rhs) const { return it == rhs.it; };
     bool operator!=(const cells_iterator & rhs) const {
       return !operator==(rhs);
     };
 
     CellID operator*() const {
       CellID cur_cell_id(this->it->first);
       return cur_cell_id;
     };
 
   private:
     /// map iterator
     typename std::map<CellID, Cell>::const_iterator it;
   };
 
 public:
   template <class vector_type>
   Cell & insert(const T & d, const vector_type & position) {
     auto && cell_id = getCellID(position);
     auto && it = cells.find(cell_id);
     if (it == cells.end()) {
       Cell cell(cell_id);
       auto & tmp = (cells[cell_id] = cell).add(d);
 
       for (UInt i = 0; i < dimension; ++i) {
         Real posl = center(i) + cell_id.getID(i) * spacing(i);
         Real posu = posl + spacing(i);
         if (posl < lower(i))
           lower(i) = posl;
         if (posu > upper(i))
           upper(i) = posu;
       }
       return tmp;
     } else {
       return it->second.add(d);
     }
   }
 
   /* ------------------------------------------------------------------------ */
   inline decltype(auto) begin() const {
     auto begin = this->cells.begin();
     return cells_iterator(begin);
   }
 
   inline decltype(auto) end() const {
     auto end = this->cells.end();
     return cells_iterator(end);
   }
 
   template <class vector_type>
   CellID getCellID(const vector_type & position) const {
     CellID cell_id(dimension);
     for (UInt i = 0; i < dimension; ++i) {
       cell_id.setID(i, getCellID(position(i), i));
     }
     return cell_id;
   }
 
   void printself(std::ostream & stream, int indent = 0) const {
     std::string space;
     for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
       ;
 
     std::streamsize prec = stream.precision();
     std::ios_base::fmtflags ff = stream.flags();
 
     stream.setf(std::ios_base::showbase);
     stream.precision(5);
 
     stream << space << "SpatialGrid<" << debug::demangle(typeid(T).name())
            << "> [" << std::endl;
     stream << space << " + dimension    : " << this->dimension << std::endl;
     stream << space << " + lower bounds : {";
     for (UInt i = 0; i < lower.size(); ++i) {
       if (i != 0)
         stream << ", ";
       stream << lower(i);
     };
     stream << "}" << std::endl;
     stream << space << " + upper bounds : {";
     for (UInt i = 0; i < upper.size(); ++i) {
       if (i != 0)
         stream << ", ";
       stream << upper(i);
     };
     stream << "}" << std::endl;
     stream << space << " + spacing : {";
     for (UInt i = 0; i < spacing.size(); ++i) {
       if (i != 0)
         stream << ", ";
       stream << spacing(i);
     };
     stream << "}" << std::endl;
     stream << space << " + center : {";
     for (UInt i = 0; i < center.size(); ++i) {
       if (i != 0)
         stream << ", ";
       stream << center(i);
     };
     stream << "}" << std::endl;
 
     stream << space << " + nb_cells     : " << this->cells.size() << "/";
     Vector<Real> dist(this->dimension);
     dist = upper;
     dist -= lower;
     for (UInt i = 0; i < this->dimension; ++i) {
       dist(i) /= spacing(i);
     }
     UInt nb_cells = std::ceil(dist(0));
     for (UInt i = 1; i < this->dimension; ++i) {
       nb_cells *= std::ceil(dist(i));
     }
     stream << nb_cells << std::endl;
     stream << space << "]" << std::endl;
 
     stream.precision(prec);
     stream.flags(ff);
   }
 
   void saveAsMesh(Mesh & mesh) const;
 
 private:
   /* --------------------------------------------------------------------------
    */
   inline UInt getCellID(Real position, UInt direction) const {
     AKANTU_DEBUG_ASSERT(direction < center.size(), "The direction asked ("
                                                        << direction
                                                        << ") is out of range "
                                                        << center.size());
     Real dist_center = position - center(direction);
     Int id = std::floor(dist_center / spacing(direction));
     // if(dist_center < 0) id--;
     return id;
   }
 
   friend class GridSynchronizer;
 
 public:
   AKANTU_GET_MACRO(LowerBounds, lower, const Vector<Real> &);
   AKANTU_GET_MACRO(UpperBounds, upper, const Vector<Real> &);
   AKANTU_GET_MACRO(Spacing, spacing, const Vector<Real> &);
 
 protected:
   UInt dimension;
 
   cells_container cells;
 
   Vector<Real> spacing;
   Vector<Real> center;
 
   Vector<Real> lower;
   Vector<Real> upper;
 
   Cell empty_cell;
 };
 
 /// standard output stream operator
 template <typename T>
 inline std::ostream & operator<<(std::ostream & stream,
                                  const SpatialGrid<T> & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 #include "mesh.hh"
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename T> void SpatialGrid<T>::saveAsMesh(Mesh & mesh) const {
-  Array<Real> & nodes = const_cast<Array<Real> &>(mesh.getNodes());
+  auto & nodes = const_cast<Array<Real> &>(mesh.getNodes());
 
   ElementType type;
   switch (dimension) {
   case 1:
     type = _segment_2;
     break;
   case 2:
     type = _quadrangle_4;
     break;
   case 3:
     type = _hexahedron_8;
     break;
   }
 
   mesh.addConnectivityType(type);
   auto & connectivity = const_cast<Array<UInt> &>(mesh.getConnectivity(type));
   auto & uint_data = mesh.getDataPointer<UInt>("tag_1", type);
 
   Vector<Real> pos(dimension);
 
   UInt global_id = 0;
   for (auto & cell_pair : cells) {
     UInt cur_node = nodes.size();
     UInt cur_elem = connectivity.size();
     const CellID & cell_id = cell_pair.first;
 
     for (UInt i = 0; i < dimension; ++i)
       pos(i) = center(i) + cell_id.getID(i) * spacing(i);
     nodes.push_back(pos);
     for (UInt i = 0; i < dimension; ++i)
       pos(i) += spacing(i);
     nodes.push_back(pos);
 
     connectivity.push_back(cur_node);
     switch (dimension) {
     case 1:
       connectivity(cur_elem, 1) = cur_node + 1;
       break;
     case 2:
       pos(0) -= spacing(0);
       nodes.push_back(pos);
       pos(0) += spacing(0);
       pos(1) -= spacing(1);
       nodes.push_back(pos);
       connectivity(cur_elem, 1) = cur_node + 3;
       connectivity(cur_elem, 2) = cur_node + 1;
       connectivity(cur_elem, 3) = cur_node + 2;
       break;
     case 3:
       pos(1) -= spacing(1);
       pos(2) -= spacing(2);
       nodes.push_back(pos);
       pos(1) += spacing(1);
       nodes.push_back(pos);
       pos(0) -= spacing(0);
       nodes.push_back(pos);
 
       pos(1) -= spacing(1);
       pos(2) += spacing(2);
       nodes.push_back(pos);
       pos(0) += spacing(0);
       nodes.push_back(pos);
       pos(0) -= spacing(0);
       pos(1) += spacing(1);
       nodes.push_back(pos);
 
       connectivity(cur_elem, 1) = cur_node + 2;
       connectivity(cur_elem, 2) = cur_node + 3;
       connectivity(cur_elem, 3) = cur_node + 4;
       connectivity(cur_elem, 4) = cur_node + 5;
       connectivity(cur_elem, 5) = cur_node + 6;
       connectivity(cur_elem, 6) = cur_node + 1;
       connectivity(cur_elem, 7) = cur_node + 7;
       break;
     }
     uint_data.push_back(global_id);
 
     ++global_id;
   }
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_AKA_GRID_DYNAMIC_HH__ */
diff --git a/src/common/aka_memory.cc b/src/common/aka_memory.cc
index 748167122..3dca00a23 100644
--- a/src/common/aka_memory.cc
+++ b/src/common/aka_memory.cc
@@ -1,64 +1,65 @@
 /**
  * @file   aka_memory.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  static memory wrapper
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
+#include <utility>
+
 #include "aka_memory.hh"
 #include "aka_static_memory.hh"
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
-Memory::Memory(ID id, MemoryID memory_id) : static_memory(StaticMemory::getStaticMemory()),
-                                            id(id),
-                                            memory_id(memory_id) {
-}
+Memory::Memory(ID id, MemoryID memory_id)
+    : static_memory(StaticMemory::getStaticMemory()), id(std::move(id)),
+      memory_id(memory_id) {}
 
 /* -------------------------------------------------------------------------- */
 Memory::~Memory() {
   if(StaticMemory::isInstantiated()) {
     std::list<ID>::iterator it;
     for (it = handeld_vectors_id.begin(); it != handeld_vectors_id.end(); ++it) {
       AKANTU_DEBUG(dblAccessory, "Deleting the vector " << *it);
       static_memory.sfree(memory_id, *it);
     }
     static_memory.destroy();
   }
 
   handeld_vectors_id.clear();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
 
 
diff --git a/src/common/aka_memory.hh b/src/common/aka_memory.hh
index 04d942c02..55e8c076d 100644
--- a/src/common/aka_memory.hh
+++ b/src/common/aka_memory.hh
@@ -1,115 +1,115 @@
 /**
  * @file   aka_memory.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  wrapper for the static_memory, all object which wants
  * to access the static_memory as to inherit from the class memory
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __AKANTU_MEMORY_HH__
 #define __AKANTU_MEMORY_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_static_memory.hh"
 #include "aka_array.hh"
 
 /* -------------------------------------------------------------------------- */
 #include <list>
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 class Memory {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 protected:
   Memory(ID id, MemoryID memory_id = 0);
 
   virtual ~Memory();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 protected:
   /// malloc
   template <class T>
   inline Array<T> & alloc(const ID & name, UInt size, UInt nb_component);
 
   /// malloc
   template <class T>
   inline Array<T> & alloc(const ID & name, UInt size, UInt nb_component,
                           const T & init_value);
 
   /* ------------------------------------------------------------------------ */
   /// free an array
-  inline void dealloc(ID name);
+  inline void dealloc(const ID & name);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 protected:
   template <typename T> inline Array<T> & getArray(const ID & name);
 
   template <typename T> inline const Array<T> & getArray(const ID & name) const;
 
 public:
   AKANTU_GET_MACRO(MemoryID, memory_id, const MemoryID &);
 
   AKANTU_GET_MACRO(ID, id, const ID &);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// the static memory instance
   StaticMemory & static_memory;
 
   /// list of allocated vectors id
   std::list<ID> handeld_vectors_id;
 
 protected:
   ID id;
 
   /// the id registred in the static memory
   MemoryID memory_id;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 #if defined(AKANTU_INCLUDE_INLINE_IMPL)
 #include "aka_memory_inline_impl.cc"
 #endif
 
 } // akantu
 
 #endif /* __AKANTU_MEMORY_HH__ */
diff --git a/src/common/aka_memory_inline_impl.cc b/src/common/aka_memory_inline_impl.cc
index 19dde0512..b7a864564 100644
--- a/src/common/aka_memory_inline_impl.cc
+++ b/src/common/aka_memory_inline_impl.cc
@@ -1,66 +1,66 @@
 /**
  * @file   aka_memory_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Jul 15 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Implementation of the inline functions of the class Memory
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 template<class T> inline Array<T> & Memory::alloc(const ID & name,
 						    UInt size,
 						    UInt nb_component) {
   handeld_vectors_id.push_back(name);
   return static_memory.smalloc<T>(memory_id, name,
 				   size, nb_component);
 }
 
 /* -------------------------------------------------------------------------- */
 template<class T> inline Array<T> & Memory::alloc(const ID & name,
 						   UInt size,
 						   UInt nb_component,
 						   const T & init_value) {
   handeld_vectors_id.push_back(name);
   return static_memory.smalloc<T>(memory_id, name,
                                   size, nb_component, init_value);
 }
 
 /* -------------------------------------------------------------------------- */
-inline void Memory::dealloc(ID name) {
+inline void Memory::dealloc(const ID & name) {
   AKANTU_DEBUG(dblAccessory, "Deleting the vector " << name);
   static_memory.sfree(memory_id, name);
   handeld_vectors_id.remove(name);
 }
 
 /* -------------------------------------------------------------------------- */
 template<class T> inline Array<T> & Memory::getArray(const ID & name) {
   return static_cast< Array<T> & >(const_cast<ArrayBase &>(static_memory.getArray(memory_id, name)));
 }
 
 /* -------------------------------------------------------------------------- */
 template<class T> inline const Array<T> & Memory::getArray(const ID & name) const {
   return static_cast< Array<T> & >(const_cast<ArrayBase &>(static_memory.getArray(memory_id, name)));
 }
diff --git a/src/common/aka_static_memory.cc b/src/common/aka_static_memory.cc
index d9d258834..e613d8bdb 100644
--- a/src/common/aka_static_memory.cc
+++ b/src/common/aka_static_memory.cc
@@ -1,156 +1,156 @@
 /**
  * @file   aka_static_memory.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Wed Jan 06 2016
  *
  * @brief  Memory management
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <stdexcept>
 #include <sstream>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_static_memory.hh"
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
 bool StaticMemory::is_instantiated = false;
 StaticMemory * StaticMemory::single_static_memory = nullptr;
 UInt StaticMemory::nb_reference = 0;
 
 /* -------------------------------------------------------------------------- */
 StaticMemory & StaticMemory::getStaticMemory() {
   if(!single_static_memory) {
     single_static_memory = new StaticMemory();
     is_instantiated = true;
   }
 
   nb_reference++;
 
   return *single_static_memory;
 }
 
 /* -------------------------------------------------------------------------- */
 void StaticMemory::destroy() {
   nb_reference--;
   if(nb_reference == 0) {
     delete single_static_memory;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 StaticMemory::~StaticMemory() {
   AKANTU_DEBUG_IN();
 
   MemoryMap::iterator memory_it;
   for(memory_it = memories.begin(); memory_it != memories.end(); ++memory_it) {
     ArrayMap::iterator vector_it;
     for(vector_it = (memory_it->second).begin();
 	vector_it != (memory_it->second).end();
 	++vector_it) {
       delete vector_it->second;
     }
     (memory_it->second).clear();
   }
   memories.clear();
   is_instantiated = false;
   StaticMemory::single_static_memory = nullptr;
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 void StaticMemory::sfree(const MemoryID & memory_id,
 			 const ID & name) {
   AKANTU_DEBUG_IN();
 
   try {
-    ArrayMap & vectors = const_cast<ArrayMap &>(getMemory(memory_id));
+    auto & vectors = const_cast<ArrayMap &>(getMemory(memory_id));
     ArrayMap::iterator vector_it;
     vector_it = vectors.find(name);
     if(vector_it != vectors.end()) {
       AKANTU_DEBUG_INFO("Array " << name << " removed from the static memory number " << memory_id);
       delete vector_it->second;
       vectors.erase(vector_it);
       AKANTU_DEBUG_OUT();
       return;
     }
   } catch (debug::Exception e) {
     AKANTU_EXCEPTION("The memory " << memory_id << " does not exist (perhaps already freed) ["
 		     << e.what() << "]");
     AKANTU_DEBUG_OUT();
     return;
   }
 
   AKANTU_DEBUG_INFO("The vector " << name << " does not exist (perhaps already freed)");
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StaticMemory::printself(std::ostream & stream, int indent) const{
   std::string space = "";
   for(Int i = 0; i < indent; i++, space += AKANTU_INDENT);
 
   std::streamsize prec       = stream.precision();
   stream.precision(2);
 
   stream << space << "StaticMemory [" << std::endl;
   UInt nb_memories = memories.size();
   stream << space << " + nb memories : " << nb_memories << std::endl;
 
   Real tot_size = 0;
   MemoryMap::const_iterator memory_it;
   for(memory_it = memories.begin(); memory_it != memories.end(); ++memory_it) {
     Real mem_size = 0;
 
     stream << space << AKANTU_INDENT << "Memory [" << std::endl;
     UInt mem_id = memory_it->first;
     stream << space << AKANTU_INDENT << " + memory id   : "
 	   << mem_id << std::endl;
     UInt nb_vectors = (memory_it->second).size();
     stream << space << AKANTU_INDENT << " + nb vectors  : "
 	   << nb_vectors << std::endl;
     stream.precision(prec);
     ArrayMap::const_iterator vector_it;
     for(vector_it = (memory_it->second).begin();
 	vector_it != (memory_it->second).end();
 	++vector_it) {
       (vector_it->second)->printself(stream, indent + 2);
       mem_size += (vector_it->second)->getMemorySize();
     }
     stream << space << AKANTU_INDENT << " + total size  : " << printMemorySize<char>(mem_size) << std::endl;
     stream << space << AKANTU_INDENT << "]" << std::endl;
     tot_size += mem_size;
   }
   stream << space << " + total size  : " << printMemorySize<char>(tot_size) << std::endl;
   stream << space << "]" << std::endl;
 
   stream.precision(prec);
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/common/aka_static_memory.hh b/src/common/aka_static_memory.hh
index 43e4a4415..da2b49f7e 100644
--- a/src/common/aka_static_memory.hh
+++ b/src/common/aka_static_memory.hh
@@ -1,157 +1,156 @@
 /**
  * @file   aka_static_memory.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Memory management
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  * @section DESCRIPTION
  *
  * The class handling the memory, allocation/reallocation/desallocation
  * The objects can register their array and ask for allocation or realocation
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_STATIC_MEMORY_HH__
 #define __AKANTU_STATIC_MEMORY_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_array.hh"
 
 /* -------------------------------------------------------------------------- */
 #include <map>
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
 typedef std::map<ID, ArrayBase *> ArrayMap;
 typedef std::map<MemoryID, ArrayMap> MemoryMap;
 
 /**
  * @class StaticMemory
  * @brief Class for memory management common to all objects (this class as to
  * be accessed by an interface class memory)
  */
 class StaticMemory {
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 private:
   /// Default constructor
-  StaticMemory(){};
-
+  StaticMemory() = default;
 public:
   virtual ~StaticMemory();
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// Get the global instance of the StaticMemory
   static StaticMemory & getStaticMemory();
 
   static bool isInstantiated() { return is_instantiated; };
 
   /// remove a reference on the static memory
   void destroy();
 
   /// access to an Array
   inline const ArrayBase & getArray(const MemoryID & memory_id,
                                     const ID & name) const;
 
   /// get all vectors of a memory
   inline const ArrayMap & getMemory(const MemoryID & memory_id) const;
 
   /* ------------------------------------------------------------------------ */
   /* Class Methods                                                            */
   /* ------------------------------------------------------------------------ */
 public:
   /**
    * Allocation of an array of type
    *
    * @param memory_id the id of the memory accessing to the static memory
    * @param name name of the array (for example connectivity)
    * @param size number of size (for example number of nodes)
    * @param nb_component number of component (for example spatial dimension)
    * @param type the type code of the array to be allocated
    *
    * @return pointer to an array of size nb_tupes * nb_component * sizeof(T)
    */
   template <typename T>
   Array<T> & smalloc(const MemoryID & memory_id, const ID & name, UInt size,
                      UInt nb_component);
 
   template <typename T>
   Array<T> & smalloc(const MemoryID & memory_id, const ID & name, UInt size,
                      UInt nb_component, const T & init_value);
   /**
    * free the memory associated to the array name
    *
    * @param memory_id the id of the memory accessing to the static memory
    * @param name the name of an existing array
    */
   void sfree(const MemoryID & memory_id, const ID & name);
 
   /// function to print the containt of the class
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// is the static memory instantiated
   static bool is_instantiated;
 
   /// unique instance of the StaticMemory
   static StaticMemory * single_static_memory;
 
   /// map of all allocated arrays, indexed by their names
   MemoryMap memories;
 
   /// number of references on the static memory
   static UInt nb_reference;
 };
 
 #include "aka_static_memory_tmpl.hh"
 #include "aka_static_memory_inline_impl.cc"
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream,
                                  const StaticMemory & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // akantu
 
 #endif /* __AKANTU_STATIC_MEMORY_HH__ */
diff --git a/src/common/aka_static_memory_tmpl.hh b/src/common/aka_static_memory_tmpl.hh
index 747bfdef8..0f09c9c0f 100644
--- a/src/common/aka_static_memory_tmpl.hh
+++ b/src/common/aka_static_memory_tmpl.hh
@@ -1,87 +1,87 @@
 /**
  * @file   aka_static_memory_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Jul 15 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  template part of the StaticMemory
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 template<typename T>
 Array<T> & StaticMemory::smalloc(const MemoryID & memory_id,
                                   const ID & name,
                                   UInt size,
                                   UInt nb_component) {
   AKANTU_DEBUG_IN();
 
   MemoryMap::iterator memory_it;
   memory_it = memories.find(memory_id);
 
   if(memory_it == memories.end()){
     memories[memory_id] = ArrayMap();
     memory_it = memories.find(memory_id);
   }
 
   if((memory_it->second).find(name) != (memory_it->second).end()) {
     AKANTU_DEBUG_ERROR("The vector \"" << name << "\" is already registred in the memory " << memory_id);
   }
 
-  Array<T> * tmp_vect = new Array<T>(size, nb_component, name);
+  auto * tmp_vect = new Array<T>(size, nb_component, name);
   (memory_it->second)[name] = tmp_vect;
 
   AKANTU_DEBUG_OUT();
   return *tmp_vect;
 }
 
 /* -------------------------------------------------------------------------- */
 template<typename T>
 Array<T> & StaticMemory::smalloc(const MemoryID & memory_id,
                                   const ID & name,
                                   UInt size,
                                   UInt nb_component,
                                   const T & init_value) {
   AKANTU_DEBUG_IN();
 
   MemoryMap::iterator memory_it;
   memory_it = memories.find(memory_id);
 
   if(memory_it == memories.end()){
     memories[memory_id] = ArrayMap();
     memory_it = memories.find(memory_id);
   }
 
   if((memory_it->second).find(name) != (memory_it->second).end()) {
     AKANTU_DEBUG_ERROR("The vector \"" << name << "\" is already registred in the memory " << memory_id);
   }
 
-  Array<T> * tmp_vect = new Array<T>(size, nb_component, init_value, name);
+  auto * tmp_vect = new Array<T>(size, nb_component, init_value, name);
   (memory_it->second)[name] = tmp_vect;
 
   AKANTU_DEBUG_OUT();
   return *tmp_vect;
 }
 
 /* -------------------------------------------------------------------------- */
diff --git a/src/common/aka_types.hh b/src/common/aka_types.hh
index 87eed2533..336fc8cf7 100644
--- a/src/common/aka_types.hh
+++ b/src/common/aka_types.hh
@@ -1,1263 +1,1264 @@
 /**
  * @file   aka_types.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Feb 17 2011
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  description of the "simple" types
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_error.hh"
 #include "aka_fwd.hh"
 #include "aka_math.hh"
 /* -------------------------------------------------------------------------- */
 #include <initializer_list>
 #include <iomanip>
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_TYPES_HH__
 #define __AKANTU_AKA_TYPES_HH__
 
 namespace akantu {
 
 enum NormType { L_1 = 1, L_2 = 2, L_inf = UInt(-1) };
 
 /**
  * DimHelper is a class to generalize the setup of a dim array from 3
  * values. This gives a common interface in the TensorStorage class
  * independently of its derived inheritance (Vector, Matrix, Tensor3)
  * @tparam dim
  */
 template <UInt dim> struct DimHelper {
   static inline void setDims(UInt m, UInt n, UInt p, UInt dims[dim]);
 };
 
 /* -------------------------------------------------------------------------- */
 template <> struct DimHelper<1> {
   static inline void setDims(UInt m, __attribute__((unused)) UInt n,
                              __attribute__((unused)) UInt p, UInt dims[1]) {
     dims[0] = m;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <> struct DimHelper<2> {
   static inline void setDims(UInt m, UInt n, __attribute__((unused)) UInt p,
                              UInt dims[2]) {
     dims[0] = m;
     dims[1] = n;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <> struct DimHelper<3> {
   static inline void setDims(UInt m, UInt n, UInt p, UInt dims[3]) {
     dims[0] = m;
     dims[1] = n;
     dims[2] = p;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename T, UInt ndim, class RetType> class TensorStorage;
 
 /* -------------------------------------------------------------------------- */
 /* Proxy classes                                                              */
 /* -------------------------------------------------------------------------- */
 namespace tensors {
   template <class A, class B> struct is_copyable {
     enum : bool { value = false };
   };
 
   template <class A> struct is_copyable<A, A> {
     enum : bool { value = true };
   };
 
   template <class A> struct is_copyable<A, typename A::RetType> {
     enum : bool { value = true };
   };
 
   template <class A> struct is_copyable<A, typename A::RetType::proxy> {
     enum : bool { value = true };
   };
 
 } // namespace tensors
 
 
 /**
  * @class TensorProxy aka_types.hh
  * @desc The TensorProxy class is a proxy class to the TensorStorage it handles
  * the
  * wrapped case. That is to say if an accessor should give access to a Tensor
  * wrapped on some data, like the Array<T>::iterator they can return a
  * TensorProxy that will be automatically transformed as a TensorStorage wrapped
  * on the same data
  * @tparam T stored type
  * @tparam ndim order of the tensor
  * @tparam RetType real derived type
  */
 template <typename T, UInt ndim, class _RetType> class TensorProxy {
 protected:
   using RetTypeProxy = typename _RetType::proxy;
 
   TensorProxy(T * data, UInt m, UInt n, UInt p) {
     DimHelper<ndim>::setDims(m, n, p, this->n);
     this->values = data;
   }
 
+#ifndef SWIG
   template <class Other, typename = std::enable_if_t<
                              tensors::is_copyable<TensorProxy, Other>::value>>
   explicit TensorProxy(const Other & other) {
     this->values = other.storage();
     for (UInt i = 0; i < ndim; ++i)
       this->n[i] = other.size(i);
   }
-
+#endif
 public:
   using RetType = _RetType;
 
   //operator RetType() { return RetType(static_cast<RetTypeProxy &>(*this)); }
 
   UInt size(UInt i) const {
     AKANTU_DEBUG_ASSERT(i < ndim, "This tensor has only " << ndim
                                                           << " dimensions, not "
                                                           << (i + 1));
     return n[i];
   }
 
   inline UInt size() const {
     UInt _size = 1;
     for (UInt d = 0; d < ndim; ++d)
       _size *= this->n[d];
     return _size;
   }
 
   T * storage() const { return values; }
 
+#ifndef SWIG
   template <class Other, typename = std::enable_if_t<
                              tensors::is_copyable<TensorProxy, Other>::value>>
   inline TensorProxy & operator=(const Other & other) {
     AKANTU_DEBUG_ASSERT(
         other.size() == this->size(),
         "You are trying to copy two tensors with different sizes");
     memcpy(this->values, other.storage(), this->size() * sizeof(T));
     return *this;
   }
-
+#endif
   // template <class Other, typename = std::enable_if_t<
   //                          tensors::is_copyable<TensorProxy, Other>::value>>
   // inline TensorProxy & operator=(const Other && other) {
   //   AKANTU_DEBUG_ASSERT(
   //       other.size() == this->size(),
   //       "You are trying to copy two tensors with different sizes");
   //   memcpy(this->values, other.storage(), this->size() * sizeof(T));
   //   return *this;
   // }
 
   template <typename O> inline RetTypeProxy & operator*=(const O & o) {
     RetType(*this) *= o;
     return static_cast<RetTypeProxy &>(*this);
   }
 
   template <typename O> inline RetTypeProxy & operator/=(const O & o) {
     RetType(*this) /= o;
     return static_cast<RetTypeProxy &>(*this);
   }
 
 protected:
   T * values;
   UInt n[ndim];
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename T> class VectorProxy : public TensorProxy<T, 1, Vector<T>> {
   using parent = TensorProxy<T, 1, Vector<T>>;
   using type = Vector<T>;
 
 public:
   VectorProxy(T * data, UInt n) : parent(data, n, 0, 0) {}
   template <class Other> explicit VectorProxy(Other & src) : parent(src) {}
 
   /* ---------------------------------------------------------------------- */
   template <class Other>
   inline VectorProxy<T> & operator=(const Other & other) {
     parent::operator=(other);
     return *this;
   }
 
   // inline VectorProxy<T> & operator=(const VectorProxy && other) {
   //   parent::operator=(other);
   //   return *this;
   // }
 
   /* ------------------------------------------------------------------------ */
   T & operator()(UInt index) { return this->values[index]; };
   const T & operator()(UInt index) const { return this->values[index]; };
 };
 
 template <typename T> class MatrixProxy : public TensorProxy<T, 2, Matrix<T>> {
   using parent = TensorProxy<T, 2, Matrix<T>>;
   using type = Matrix<T>;
 
 public:
   MatrixProxy(T * data, UInt m, UInt n) : parent(data, m, n, 0) {}
   template <class Other> explicit MatrixProxy(Other & src) : parent(src) {}
 
   /* ---------------------------------------------------------------------- */
   template <class Other>
   inline MatrixProxy<T> & operator=(const Other & other) {
     parent::operator=(other);
     return *this;
   }
 };
 
 template <typename T>
 class Tensor3Proxy : public TensorProxy<T, 3, Tensor3<T>> {
   typedef TensorProxy<T, 3, Tensor3<T>> parent;
   using type = Tensor3<T>;
 
 public:
   Tensor3Proxy(T * data, UInt m, UInt n, UInt k) : parent(data, m, n, k) {}
   Tensor3Proxy(const Tensor3Proxy & src) : parent(src) {}
   Tensor3Proxy(const Tensor3<T> & src) : parent(src) {}
 
   /* ---------------------------------------------------------------------- */
   template <class Other>
   inline Tensor3Proxy<T> & operator=(const Other & other) {
     parent::operator=(other);
     return *this;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 /* Tensor base class                                                          */
 /* -------------------------------------------------------------------------- */
 template <typename T, UInt ndim, class RetType>
 class TensorStorage : public TensorTrait {
 public:
   using value_type = T;
 
   friend class Array<T>;
 protected:
   template <class TensorType> void copySize(const TensorType & src) {
     for (UInt d = 0; d < ndim; ++d)
       this->n[d] = src.size(d);
     this->_size = src.size();
   }
 
   TensorStorage() : values(nullptr) {
     for (UInt d = 0; d < ndim; ++d)
       this->n[d] = 0;
     _size = 0;
   }
 
   TensorStorage(const TensorProxy<T, ndim, RetType> & proxy) {
     this->copySize(proxy);
     this->values = proxy.storage();
     this->wrapped = true;
   }
 
 protected:
   TensorStorage(const TensorStorage & src) = delete;
 
 public:
-  TensorStorage(const TensorStorage & src, bool deep_copy)
-      : values(nullptr), wrapped(false) {
+  TensorStorage(const TensorStorage & src, bool deep_copy) : values(nullptr) {
     if (deep_copy)
       this->deepCopy(src);
     else
       this->shallowCopy(src);
   }
 
 protected:
   TensorStorage(UInt m, UInt n, UInt p, const T & def) {
     static_assert(std::is_trivially_constructible<T>{},
                   "Cannot create a tensor on non trivial types");
     DimHelper<ndim>::setDims(m, n, p, this->n);
 
     this->computeSize();
     this->values = new T[this->_size];
     this->set(def);
     this->wrapped = false;
   }
 
   TensorStorage(T * data, UInt m, UInt n, UInt p) {
     DimHelper<ndim>::setDims(m, n, p, this->n);
 
     this->computeSize();
     this->values = data;
     this->wrapped = true;
   }
 
 public:
   /* ------------------------------------------------------------------------ */
   template <class TensorType> inline void shallowCopy(const TensorType & src) {
     this->copySize(src);
     if (!this->wrapped)
       delete[] this->values;
     this->values = src.storage();
     this->wrapped = true;
   }
 
   /* ------------------------------------------------------------------------ */
   template <class TensorType> inline void deepCopy(const TensorType & src) {
     this->copySize(src);
 
     if (!this->wrapped)
       delete[] this->values;
 
     static_assert(std::is_trivially_constructible<T>{},
                   "Cannot create a tensor on non trivial types");
     this->values = new T[this->_size];
 
     static_assert(std::is_trivially_copyable<T>{},
                   "Cannot copy a tensor on non trivial types");
     memcpy((void *)this->values, (void *)src.storage(),
            this->_size * sizeof(T));
 
     this->wrapped = false;
   }
 
   virtual ~TensorStorage() {
     if (!this->wrapped)
       delete[] this->values;
   }
 
   /* ------------------------------------------------------------------------ */
   inline TensorStorage & operator=(const TensorStorage & src) {
     return this->operator=(dynamic_cast<RetType &>(src));
   }
 
   /* ------------------------------------------------------------------------ */
   inline TensorStorage & operator=(const RetType & src) {
     if (this != &src) {
       if (this->wrapped) {
         static_assert(std::is_trivially_copyable<T>{},
                   "Cannot copy a tensor on non trivial types");
         // this test is not sufficient for Tensor of order higher than 1
         AKANTU_DEBUG_ASSERT(this->_size == src.size(),
                             "Tensors of different size");
         memcpy((void *)this->values, (void *)src.storage(),
                this->_size * sizeof(T));
       } else {
         deepCopy(src);
       }
     }
     return *this;
   }
 
   /* ------------------------------------------------------------------------ */
   template <class R>
   inline RetType & operator+=(const TensorStorage<T, ndim, R> & other) {
     T * a = this->storage();
     T * b = other.storage();
     AKANTU_DEBUG_ASSERT(
         _size == other.size(),
         "The two tensors do not have the same size, they cannot be subtracted");
     for (UInt i = 0; i < _size; ++i)
       *(a++) += *(b++);
     return *(static_cast<RetType *>(this));
   }
 
   /* ------------------------------------------------------------------------ */
   template <class R>
   inline RetType & operator-=(const TensorStorage<T, ndim, R> & other) {
     T * a = this->storage();
     T * b = other.storage();
     AKANTU_DEBUG_ASSERT(
         _size == other.size(),
         "The two tensors do not have the same size, they cannot be subtracted");
     for (UInt i = 0; i < _size; ++i)
       *(a++) -= *(b++);
     return *(static_cast<RetType *>(this));
   }
 
   /* ------------------------------------------------------------------------ */
   inline RetType & operator+=(const T & x) {
     T * a = this->values;
     for (UInt i = 0; i < _size; ++i)
       *(a++) += x;
     return *(static_cast<RetType *>(this));
   }
 
   /* ------------------------------------------------------------------------ */
   inline RetType & operator-=(const T & x) {
     T * a = this->values;
     for (UInt i = 0; i < _size; ++i)
       *(a++) -= x;
     return *(static_cast<RetType *>(this));
   }
 
   /* ------------------------------------------------------------------------ */
   inline RetType & operator*=(const T & x) {
     T * a = this->storage();
     for (UInt i = 0; i < _size; ++i)
       *(a++) *= x;
     return *(static_cast<RetType *>(this));
   }
 
   /* ---------------------------------------------------------------------- */
   inline RetType & operator/=(const T & x) {
     T * a = this->values;
     for (UInt i = 0; i < _size; ++i)
       *(a++) /= x;
     return *(static_cast<RetType *>(this));
   }
 
   /// Y = \alpha X + Y
   inline RetType & aXplusY(const TensorStorage & other, const T & alpha = 1.) {
     AKANTU_DEBUG_ASSERT(
         _size == other.size(),
         "The two tensors do not have the same size, they cannot be subtracted");
 
     Math::aXplusY(this->_size, alpha, other.storage(), this->storage());
     return *(static_cast<RetType *>(this));
   }
 
   /* ------------------------------------------------------------------------ */
   T * storage() const { return values; }
   UInt size() const { return _size; }
   UInt size(UInt i) const {
     AKANTU_DEBUG_ASSERT(i < ndim, "This tensor has only " << ndim
                                                           << " dimensions, not "
                                                           << (i + 1));
     return n[i];
   };
   /* ------------------------------------------------------------------------ */
   inline void clear() { memset(values, 0, _size * sizeof(T)); };
   inline void set(const T & t) { std::fill_n(values, _size, t); };
 
   template <class TensorType> inline void copy(const TensorType & other) {
     AKANTU_DEBUG_ASSERT(
         _size == other.size(),
         "The two tensors do not have the same size, they cannot be copied");
     memcpy(values, other.storage(), _size * sizeof(T));
   }
 
   bool isWrapped() const { return this->wrapped; }
 
 protected:
   inline void computeSize() {
     _size = 1;
     for (UInt d = 0; d < ndim; ++d)
       _size *= this->n[d];
   }
 
 protected:
   template <typename R, NormType norm_type> struct NormHelper {
     template <class Ten> static R norm(const Ten & ten) {
       R _norm = 0.;
       R * it = ten.storage();
       R * end = ten.storage() + ten.size();
       for (; it < end; ++it)
         _norm += std::pow(std::abs(*it), norm_type);
       return std::pow(_norm, 1. / norm_type);
     }
   };
 
   template <typename R> struct NormHelper<R, L_1> {
     template <class Ten> static R norm(const Ten & ten) {
       R _norm = 0.;
       R * it = ten.storage();
       R * end = ten.storage() + ten.size();
       for (; it < end; ++it)
         _norm += std::abs(*it);
       return _norm;
     }
   };
 
   template <typename R> struct NormHelper<R, L_2> {
     template <class Ten> static R norm(const Ten & ten) {
       R _norm = 0.;
       R * it = ten.storage();
       R * end = ten.storage() + ten.size();
       for (; it < end; ++it)
         _norm += *it * *it;
       return sqrt(_norm);
     }
   };
 
   template <typename R> struct NormHelper<R, L_inf> {
     template <class Ten> static R norm(const Ten & ten) {
       R _norm = 0.;
       R * it = ten.storage();
       R * end = ten.storage() + ten.size();
       for (; it < end; ++it)
         _norm = std::max(std::abs(*it), _norm);
       return _norm;
     }
   };
 
 public:
   /*----------------------------------------------------------------------- */
   /// "Entrywise" norm norm<L_p> @f[ \|\boldsymbol{T}\|_p = \left(
   /// \sum_i^{n[0]}\sum_j^{n[1]}\sum_k^{n[2]} |T_{ijk}|^p \right)^{\frac{1}{p}}
   /// @f]
   template <NormType norm_type> inline T norm() const {
     return NormHelper<T, norm_type>::norm(*this);
   }
 
 protected:
   UInt n[ndim];
   UInt _size;
   T * values;
   bool wrapped{false};
 };
 
 /* -------------------------------------------------------------------------- */
 /* Vector                                                                     */
 /* -------------------------------------------------------------------------- */
 template <typename T> class Vector : public TensorStorage<T, 1, Vector<T>> {
   typedef TensorStorage<T, 1, Vector<T>> parent;
 
 public:
   using value_type = typename parent::value_type;
   using proxy = VectorProxy<T>;
 
 public:
   Vector() : parent() {}
   explicit Vector(UInt n, const T & def = T()) : parent(n, 0, 0, def) {}
   Vector(T * data, UInt n) : parent(data, n, 0, 0) {}
   Vector(const Vector & src, bool deep_copy = true) : parent(src, deep_copy) {}
   Vector(const TensorProxy<T, 1, Vector> & src) : parent(src) {}
 
   Vector(std::initializer_list<T> list) : parent(list.size(), 0, 0, T()) {
     UInt i = 0;
     for (auto val : list) {
       operator()(i++) = val;
     }
   }
 
 public:
   ~Vector() override = default;
 
   /* ------------------------------------------------------------------------ */
   inline Vector & operator=(const Vector & src) {
     parent::operator=(src);
     return *this;
   }
 
   /* ------------------------------------------------------------------------ */
   inline T & operator()(UInt i) {
     AKANTU_DEBUG_ASSERT((i < this->n[0]),
                         "Access out of the vector! "
                             << "Index (" << i
                             << ") is out of the vector of size (" << this->n[0]
                             << ")");
     return *(this->values + i);
   }
 
   inline const T & operator()(UInt i) const {
     AKANTU_DEBUG_ASSERT((i < this->n[0]),
                         "Access out of the vector! "
                             << "Index (" << i
                             << ") is out of the vector of size (" << this->n[0]
                             << ")");
     return *(this->values + i);
   }
 
   inline T & operator[](UInt i) { return this->operator()(i); }
   inline const T & operator[](UInt i) const { return this->operator()(i); }
 
   /* ------------------------------------------------------------------------ */
   inline Vector<T> & operator*=(Real x) { return parent::operator*=(x); }
   inline Vector<T> & operator/=(Real x) { return parent::operator/=(x); }
   /* ------------------------------------------------------------------------ */
   inline Vector<T> & operator*=(const Vector<T> & vect) {
     T * a = this->storage();
     T * b = vect.storage();
     for (UInt i = 0; i < this->_size; ++i)
       *(a++) *= *(b++);
     return *this;
   }
 
   /* ------------------------------------------------------------------------ */
   inline Real dot(const Vector<T> & vect) const {
     return Math::vectorDot(this->values, vect.storage(), this->_size);
   }
 
   /* ------------------------------------------------------------------------ */
   inline Real mean() const {
     Real mean = 0;
     T * a = this->storage();
     for (UInt i = 0; i < this->_size; ++i)
       mean += *(a++);
     return mean / this->_size;
   }
 
   /* ------------------------------------------------------------------------ */
   inline Vector & crossProduct(const Vector<T> & v1, const Vector<T> & v2) {
     AKANTU_DEBUG_ASSERT(this->size() == 3,
                         "crossProduct is only defined in 3D (n=" << this->size()
                                                                  << ")");
     AKANTU_DEBUG_ASSERT(
         this->size() == v1.size() && this->size() == v2.size(),
         "crossProduct is not a valid operation non matching size vectors");
     Math::vectorProduct3(v1.storage(), v2.storage(), this->values);
     return *this;
   }
 
   /* ------------------------------------------------------------------------ */
   inline void solve(const Matrix<T> & A, const Vector<T> & b) {
     AKANTU_DEBUG_ASSERT(
         this->size() == A.rows() && this->_size == A.cols(),
         "The size of the solution vector mismatches the size of the matrix");
     AKANTU_DEBUG_ASSERT(
         this->_size == b._size,
         "The rhs vector has a mismatch in size with the matrix");
     Math::solve(this->_size, A.storage(), this->values, b.storage());
   }
 
   /* ------------------------------------------------------------------------ */
   template <bool tr_A>
   inline void mul(const Matrix<T> & A, const Vector<T> & x, Real alpha = 1.0);
   /* ------------------------------------------------------------------------ */
   inline Real norm() const { return parent::template norm<L_2>(); }
 
   template <NormType nt> inline Real norm() const {
     return parent::template norm<nt>();
   }
 
   /* ------------------------------------------------------------------------ */
   inline void normalize() {
     Real n = norm();
     operator/=(n);
   }
 
   /* ------------------------------------------------------------------------ */
   /// norm of (*this - x)
   inline Real distance(const Vector<T> & y) const {
     Real * vx = this->values;
     Real * vy = y.storage();
     Real sum_2 = 0;
     for (UInt i = 0; i < this->_size; ++i, ++vx, ++vy)
       sum_2 += (*vx - *vy) * (*vx - *vy);
     return sqrt(sum_2);
   }
 
   /* ------------------------------------------------------------------------ */
   inline bool equal(const Vector<T> & v,
                     Real tolerance = Math::getTolerance()) const {
     T * a = this->storage();
     T * b = v.storage();
     UInt i = 0;
     while (i < this->_size && (std::abs(*(a++) - *(b++)) < tolerance))
       ++i;
     return i == this->_size;
   }
 
   /* ------------------------------------------------------------------------ */
   inline short compare(const Vector<T> & v,
                        Real tolerance = Math::getTolerance()) const {
     T * a = this->storage();
     T * b = v.storage();
     for (UInt i(0); i < this->_size; ++i, ++a, ++b) {
       if (std::abs(*a - *b) > tolerance)
         return (((*a - *b) > tolerance) ? 1 : -1);
     }
     return 0;
   }
 
   /* ------------------------------------------------------------------------ */
   inline bool operator==(const Vector<T> & v) const { return equal(v); }
   inline bool operator!=(const Vector<T> & v) const { return !operator==(v); }
   inline bool operator<(const Vector<T> & v) const { return compare(v) == -1; }
   inline bool operator>(const Vector<T> & v) const { return compare(v) == 1; }
 
   /* ------------------------------------------------------------------------ */
   /// function to print the containt of the class
   virtual void printself(std::ostream & stream, int indent = 0) const {
     std::string space;
     for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
       ;
 
     stream << "[";
     for (UInt i = 0; i < this->_size; ++i) {
       if (i != 0)
         stream << ", ";
       stream << this->values[i];
     }
     stream << "]";
   }
 
   //  friend class ::akantu::Array<T>;
 };
 
 using RVector = Vector<Real>;
 
 /* ------------------------------------------------------------------------ */
 template <>
 inline bool Vector<UInt>::equal(const Vector<UInt> & v,
                                 __attribute__((unused)) Real tolerance) const {
   UInt * a = this->storage();
   UInt * b = v.storage();
   UInt i = 0;
   while (i < this->_size && (*(a++) == *(b++)))
     ++i;
   return i == this->_size;
 }
 
 /* ------------------------------------------------------------------------ */
 /* Matrix                                                                   */
 /* ------------------------------------------------------------------------ */
 template <typename T> class Matrix : public TensorStorage<T, 2, Matrix<T>> {
   typedef TensorStorage<T, 2, Matrix<T>> parent;
 
 public:
   using value_type = typename parent::value_type;
   using proxy = MatrixProxy<T>;
 
 public:
   Matrix() : parent() {}
   Matrix(UInt m, UInt n, const T & def = T()) : parent(m, n, 0, def) {}
   Matrix(T * data, UInt m, UInt n) : parent(data, m, n, 0) {}
   Matrix(const Matrix & src, bool deep_copy = true) : parent(src, deep_copy) {}
   Matrix(const MatrixProxy<T> & src) : parent(src) {}
   Matrix(std::initializer_list<std::initializer_list<T>> list) {
     static_assert(std::is_trivially_copyable<T>{},
                   "Cannot create a tensor on non trivial types");
     std::size_t n = 0;
     std::size_t m = list.size();
     for (auto row : list) {
       n = std::max(n, row.size());
     }
 
     DimHelper<2>::setDims(m, n, 0, this->n);
     this->computeSize();
     this->values = new T[this->_size];
     this->set(0);
 
     UInt i = 0, j = 0;
     for (auto & row : list) {
       for (auto & val : row) {
         at(i, j++) = val;
       }
       ++i;
       j = 0;
     }
   }
 
   ~Matrix() override = default;
   /* ------------------------------------------------------------------------ */
   inline Matrix & operator=(const Matrix & src) {
     parent::operator=(src);
     return *this;
   }
 
 public:
   /* ---------------------------------------------------------------------- */
   UInt rows() const { return this->n[0]; }
   UInt cols() const { return this->n[1]; }
 
   /* ---------------------------------------------------------------------- */
   inline T & at(UInt i, UInt j) {
     AKANTU_DEBUG_ASSERT(((i < this->n[0]) && (j < this->n[1])),
                         "Access out of the matrix! "
                             << "Index (" << i << ", " << j
                             << ") is out of the matrix of size (" << this->n[0]
                             << ", " << this->n[1] << ")");
     return *(this->values + i + j * this->n[0]);
   }
 
   inline const T & at(UInt i, UInt j) const {
     AKANTU_DEBUG_ASSERT(((i < this->n[0]) && (j < this->n[1])),
                         "Access out of the matrix! "
                             << "Index (" << i << ", " << j
                             << ") is out of the matrix of size (" << this->n[0]
                             << ", " << this->n[1] << ")");
     return *(this->values + i + j * this->n[0]);
   }
 
   /* ------------------------------------------------------------------------ */
   inline T & operator()(UInt i, UInt j) { return this->at(i, j); }
   inline const T & operator()(UInt i, UInt j) const { return this->at(i, j); }
 
   /// give a line vector wrapped on the column i
   inline VectorProxy<T> operator()(UInt j) {
     AKANTU_DEBUG_ASSERT(j < this->n[1],
                         "Access out of the matrix! "
                             << "You are trying to access the column vector "
                             << j << " in a matrix of size (" << this->n[0]
                             << ", " << this->n[1] << ")");
     return VectorProxy<T>(this->values + j * this->n[0], this->n[0]);
   }
 
   inline const VectorProxy<T> operator()(UInt j) const {
     AKANTU_DEBUG_ASSERT(j < this->n[1],
                         "Access out of the matrix! "
                             << "You are trying to access the column vector "
                             << j << " in a matrix of size (" << this->n[0]
                             << ", " << this->n[1] << ")");
     return VectorProxy<T>(this->values + j * this->n[0], this->n[0]);
   }
 
   inline T & operator[](UInt idx) { return *(this->values + idx); };
   inline const T & operator[](UInt idx) const { return *(this->values + idx); };
 
   /* ---------------------------------------------------------------------- */
   inline Matrix operator*(const Matrix & B) {
     Matrix C(this->rows(), B.cols());
     C.mul<false, false>(*this, B);
     return C;
   }
 
   /* ----------------------------------------------------------------------- */
   inline Matrix & operator*=(const T & x) { return parent::operator*=(x); }
 
   inline Matrix & operator*=(const Matrix & B) {
     Matrix C(*this);
     this->mul<false, false>(C, B);
     return *this;
   }
 
   /* ---------------------------------------------------------------------- */
   template <bool tr_A, bool tr_B>
   inline void mul(const Matrix & A, const Matrix & B, T alpha = 1.0) {
     UInt k = A.cols();
     if (tr_A)
       k = A.rows();
 
 #ifndef AKANTU_NDEBUG
     if (tr_B) {
       AKANTU_DEBUG_ASSERT(k == B.cols(),
                           "matrices to multiply have no fit dimensions");
       AKANTU_DEBUG_ASSERT(this->cols() == B.rows(),
                           "matrices to multiply have no fit dimensions");
     } else {
       AKANTU_DEBUG_ASSERT(k == B.rows(),
                           "matrices to multiply have no fit dimensions");
       AKANTU_DEBUG_ASSERT(this->cols() == B.cols(),
                           "matrices to multiply have no fit dimensions");
     }
     if (tr_A) {
       AKANTU_DEBUG_ASSERT(this->rows() == A.cols(),
                           "matrices to multiply have no fit dimensions");
     } else {
       AKANTU_DEBUG_ASSERT(this->rows() == A.rows(),
                           "matrices to multiply have no fit dimensions");
     }
 #endif // AKANTU_NDEBUG
 
     Math::matMul<tr_A, tr_B>(this->rows(), this->cols(), k, alpha, A.storage(),
                              B.storage(), 0., this->storage());
   }
 
   /* ---------------------------------------------------------------------- */
   inline void outerProduct(const Vector<T> & A, const Vector<T> & B) {
     AKANTU_DEBUG_ASSERT(
         A.size() == this->rows() && B.size() == this->cols(),
         "A and B are not compatible with the size of the matrix");
     for (UInt i = 0; i < this->rows(); ++i) {
       for (UInt j = 0; j < this->cols(); ++j) {
         this->values[i + j * this->rows()] += A[i] * B[j];
       }
     }
   }
 
 private:
   class EigenSorter {
   public:
     EigenSorter(const Vector<T> & eigs) : eigs(eigs) {}
 
     bool operator()(const UInt & a, const UInt & b) const {
       return (eigs(a) > eigs(b));
     }
 
   private:
     const Vector<T> & eigs;
   };
 
 public:
   /* ---------------------------------------------------------------------- */
   inline void eig(Vector<T> & eigenvalues, Matrix<T> & eigenvectors) const {
     AKANTU_DEBUG_ASSERT(this->cols() == this->rows(),
                         "eig is not a valid operation on a rectangular matrix");
     AKANTU_DEBUG_ASSERT(eigenvalues.size() == this->cols(),
                         "eigenvalues should be of size " << this->cols()
                                                          << ".");
 #ifndef AKANTU_NDEBUG
     if (eigenvectors.storage() != nullptr)
       AKANTU_DEBUG_ASSERT((eigenvectors.rows() == eigenvectors.cols()) &&
                               (eigenvectors.rows() == this->cols()),
                           "Eigenvectors needs to be a square matrix of size "
                               << this->cols() << " x " << this->cols() << ".");
 #endif
 
     Matrix<T> tmp = *this;
     Vector<T> tmp_eigs(eigenvalues.size());
     Matrix<T> tmp_eig_vects(eigenvectors.rows(), eigenvectors.cols());
 
     if (tmp_eig_vects.rows() == 0 || tmp_eig_vects.cols() == 0)
       Math::matrixEig(tmp.cols(), tmp.storage(), tmp_eigs.storage());
     else
       Math::matrixEig(tmp.cols(), tmp.storage(), tmp_eigs.storage(),
                       tmp_eig_vects.storage());
 
     Vector<UInt> perm(eigenvalues.size());
     for (UInt i = 0; i < perm.size(); ++i)
       perm(i) = i;
 
     std::sort(perm.storage(), perm.storage() + perm.size(),
               EigenSorter(tmp_eigs));
 
     for (UInt i = 0; i < perm.size(); ++i)
       eigenvalues(i) = tmp_eigs(perm(i));
 
     if (tmp_eig_vects.rows() != 0 && tmp_eig_vects.cols() != 0)
       for (UInt i = 0; i < perm.size(); ++i) {
         for (UInt j = 0; j < eigenvectors.rows(); ++j) {
           eigenvectors(j, i) = tmp_eig_vects(j, perm(i));
         }
       }
   }
 
   /* ---------------------------------------------------------------------- */
   inline void eig(Vector<T> & eigenvalues) const {
     Matrix<T> empty;
     eig(eigenvalues, empty);
   }
 
   /* ---------------------------------------------------------------------- */
   inline void eye(T alpha = 1.) {
     AKANTU_DEBUG_ASSERT(this->cols() == this->rows(),
                         "eye is not a valid operation on a rectangular matrix");
     this->clear();
     for (UInt i = 0; i < this->cols(); ++i) {
       this->values[i + i * this->rows()] = alpha;
     }
   }
 
   /* ---------------------------------------------------------------------- */
   static inline Matrix<T> eye(UInt m, T alpha = 1.) {
     Matrix<T> tmp(m, m);
     tmp.eye(alpha);
     return tmp;
   }
 
   /* ---------------------------------------------------------------------- */
   inline T trace() const {
     AKANTU_DEBUG_ASSERT(
         this->cols() == this->rows(),
         "trace is not a valid operation on a rectangular matrix");
     T trace = 0.;
     for (UInt i = 0; i < this->rows(); ++i) {
       trace += this->values[i + i * this->rows()];
     }
     return trace;
   }
 
   /* ---------------------------------------------------------------------- */
   inline Matrix transpose() const {
     Matrix tmp(this->cols(), this->rows());
     for (UInt i = 0; i < this->rows(); ++i) {
       for (UInt j = 0; j < this->cols(); ++j) {
         tmp(j, i) = operator()(i, j);
       }
     }
     return tmp;
   }
 
   /* ---------------------------------------------------------------------- */
   inline void inverse(const Matrix & A) {
     AKANTU_DEBUG_ASSERT(A.cols() == A.rows(),
                         "inv is not a valid operation on a rectangular matrix");
     AKANTU_DEBUG_ASSERT(this->cols() == A.cols(),
                         "the matrix should have the same size as its inverse");
 
     if (this->cols() == 1)
       *this->values = 1. / *A.storage();
     else if (this->cols() == 2)
       Math::inv2(A.storage(), this->values);
     else if (this->cols() == 3)
       Math::inv3(A.storage(), this->values);
     else
       Math::inv(this->cols(), A.storage(), this->values);
   }
 
   /* --------------------------------------------------------------------- */
   inline T det() const {
     AKANTU_DEBUG_ASSERT(this->cols() == this->rows(),
                         "inv is not a valid operation on a rectangular matrix");
     if (this->cols() == 1)
       return *(this->values);
     else if (this->cols() == 2)
       return Math::det2(this->values);
     else if (this->cols() == 3)
       return Math::det3(this->values);
     else
       return Math::det(this->cols(), this->values);
   }
 
   /* --------------------------------------------------------------------- */
   inline T doubleDot(const Matrix<T> & other) const {
     AKANTU_DEBUG_ASSERT(
         this->cols() == this->rows(),
         "doubleDot is not a valid operation on a rectangular matrix");
     if (this->cols() == 1)
       return *(this->values) * *(other.storage());
     else if (this->cols() == 2)
       return Math::matrixDoubleDot22(this->values, other.storage());
     else if (this->cols() == 3)
       return Math::matrixDoubleDot33(this->values, other.storage());
     else
       AKANTU_DEBUG_ERROR("doubleDot is not defined for other spatial dimensions"
                          << " than 1, 2 or 3.");
     return T();
   }
 
   /* ---------------------------------------------------------------------- */
   /// function to print the containt of the class
   virtual void printself(std::ostream & stream, int indent = 0) const {
     std::string space;
     for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
       ;
 
     stream << "[";
     for (UInt i = 0; i < this->n[0]; ++i) {
       if (i != 0)
         stream << ", ";
       stream << "[";
       for (UInt j = 0; j < this->n[1]; ++j) {
         if (j != 0)
           stream << ", ";
         stream << operator()(i, j);
       }
       stream << "]";
     }
     stream << "]";
   };
 };
 
 /* ------------------------------------------------------------------------ */
 template <typename T>
 template <bool tr_A>
 inline void Vector<T>::mul(const Matrix<T> & A, const Vector<T> & x,
                            Real alpha) {
 #ifndef AKANTU_NDEBUG
   UInt n = x.size();
   if (tr_A) {
     AKANTU_DEBUG_ASSERT(n == A.rows(),
                         "matrix and vector to multiply have no fit dimensions");
     AKANTU_DEBUG_ASSERT(this->size() == A.cols(),
                         "matrix and vector to multiply have no fit dimensions");
   } else {
     AKANTU_DEBUG_ASSERT(n == A.cols(),
                         "matrix and vector to multiply have no fit dimensions");
     AKANTU_DEBUG_ASSERT(this->size() == A.rows(),
                         "matrix and vector to multiply have no fit dimensions");
   }
 #endif
   Math::matVectMul<tr_A>(A.rows(), A.cols(), alpha, A.storage(), x.storage(),
                          0., this->storage());
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline std::ostream & operator<<(std::ostream & stream,
                                  const Matrix<T> & _this) {
   _this.printself(stream);
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline std::ostream & operator<<(std::ostream & stream,
                                  const Vector<T> & _this) {
   _this.printself(stream);
   return stream;
 }
 
 /* ------------------------------------------------------------------------ */
 /* Tensor3                                                                  */
 /* ------------------------------------------------------------------------ */
 template <typename T> class Tensor3 : public TensorStorage<T, 3, Tensor3<T>> {
   typedef TensorStorage<T, 3, Tensor3<T>> parent;
 
 public:
   using value_type = typename parent::value_type;
   using proxy = Tensor3Proxy<T>;
 
 public:
   Tensor3() : parent(){};
 
   Tensor3(UInt m, UInt n, UInt p, const T & def = T()) : parent(m, n, p, def) {}
 
   Tensor3(T * data, UInt m, UInt n, UInt p) : parent(data, m, n, p) {}
 
   Tensor3(const Tensor3 & src, bool deep_copy = true)
       : parent(src, deep_copy) {}
 
 public:
   /* ------------------------------------------------------------------------ */
   inline Tensor3 & operator=(const Tensor3 & src) {
     parent::operator=(src);
     return *this;
   }
 
   /* ---------------------------------------------------------------------- */
   inline T & operator()(UInt i, UInt j, UInt k) {
     AKANTU_DEBUG_ASSERT(
         (i < this->n[0]) && (j < this->n[1]) && (k < this->n[2]),
         "Access out of the tensor3! "
             << "You are trying to access the element "
             << "(" << i << ", " << j << ", " << k << ") in a tensor of size ("
             << this->n[0] << ", " << this->n[1] << ", " << this->n[2] << ")");
     return *(this->values + (k * this->n[0] + i) * this->n[1] + j);
   }
 
   inline const T & operator()(UInt i, UInt j, UInt k) const {
     AKANTU_DEBUG_ASSERT(
         (i < this->n[0]) && (j < this->n[1]) && (k < this->n[2]),
         "Access out of the tensor3! "
             << "You are trying to access the element "
             << "(" << i << ", " << j << ", " << k << ") in a tensor of size ("
             << this->n[0] << ", " << this->n[1] << ", " << this->n[2] << ")");
     return *(this->values + (k * this->n[0] + i) * this->n[1] + j);
   }
 
   inline MatrixProxy<T> operator()(UInt k) {
     AKANTU_DEBUG_ASSERT((k < this->n[2]),
                         "Access out of the tensor3! "
                             << "You are trying to access the slice " << k
                             << " in a tensor3 of size (" << this->n[0] << ", "
                             << this->n[1] << ", " << this->n[2] << ")");
     return MatrixProxy<T>(this->values + k * this->n[0] * this->n[1],
                           this->n[0], this->n[1]);
   }
 
   inline const MatrixProxy<T> operator()(UInt k) const {
     AKANTU_DEBUG_ASSERT((k < this->n[2]),
                         "Access out of the tensor3! "
                             << "You are trying to access the slice " << k
                             << " in a tensor3 of size (" << this->n[0] << ", "
                             << this->n[1] << ", " << this->n[2] << ")");
     return MatrixProxy<T>(this->values + k * this->n[0] * this->n[1],
                           this->n[0], this->n[1]);
   }
 
   inline MatrixProxy<T> operator[](UInt k) {
     return MatrixProxy<T>(this->values + k * this->n[0] * this->n[1],
                           this->n[0], this->n[1]);
   }
 
   inline const MatrixProxy<T> operator[](UInt k) const {
     return MatrixProxy<T>(this->values + k * this->n[0] * this->n[1],
                           this->n[0], this->n[1]);
   }
 };
 
 /* -------------------------------------------------------------------------- */
 // support operations for the creation of other vectors
 /* -------------------------------------------------------------------------- */
 template <typename T>
 Vector<T> operator*(const T & scalar, const Vector<T> & a) {
   Vector<T> r(a);
   r *= scalar;
   return r;
 }
 
 template <typename T>
 Vector<T> operator*(const Vector<T> & a, const T & scalar) {
   Vector<T> r(a);
   r *= scalar;
   return r;
 }
 
 template <typename T>
 Vector<T> operator/(const Vector<T> & a, const T & scalar) {
   Vector<T> r(a);
   r /= scalar;
   return r;
 }
 
 template <typename T>
 Vector<T> operator*(const Vector<T> & a, const Vector<T> & b) {
   Vector<T> r(a);
   r *= b;
   return r;
 }
 
 template <typename T>
 Vector<T> operator+(const Vector<T> & a, const Vector<T> & b) {
   Vector<T> r(a);
   r += b;
   return r;
 }
 
 template <typename T>
 Vector<T> operator-(const Vector<T> & a, const Vector<T> & b) {
   Vector<T> r(a);
   r -= b;
   return r;
 }
 
 template <typename T>
 Vector<T> operator*(const Matrix<T> & A, const Vector<T> & b) {
   Vector<T> r(b.size());
   r.template mul<false>(A, b);
   return r;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 Matrix<T> operator*(const T & scalar, const Matrix<T> & a) {
   Matrix<T> r(a);
   r *= scalar;
   return r;
 }
 
 template <typename T>
 Matrix<T> operator*(const Matrix<T> & a, const T & scalar) {
   Matrix<T> r(a);
   r *= scalar;
   return r;
 }
 
 template <typename T>
 Matrix<T> operator/(const Matrix<T> & a, const T & scalar) {
   Matrix<T> r(a);
   r /= scalar;
   return r;
 }
 
 template <typename T>
 Matrix<T> operator+(const Matrix<T> & a, const Matrix<T> & b) {
   Matrix<T> r(a);
   r += b;
   return r;
 }
 
 template <typename T>
 Matrix<T> operator-(const Matrix<T> & a, const Matrix<T> & b) {
   Matrix<T> r(a);
   r -= b;
   return r;
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_AKA_TYPES_HH__ */
diff --git a/src/fe_engine/element_class.hh b/src/fe_engine/element_class.hh
index 6cb694cda..b1771836e 100644
--- a/src/fe_engine/element_class.hh
+++ b/src/fe_engine/element_class.hh
@@ -1,408 +1,406 @@
 /**
  * @file   element_class.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Jan 21 2016
  *
  * @brief  Declaration of the ElementClass main class and the
  * Integration and Interpolation elements
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_types.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_ELEMENT_CLASS_HH__
 #define __AKANTU_ELEMENT_CLASS_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /// default element class structure
 template <ElementType element_type> struct ElementClassProperty {
   static const GeometricalType geometrical_type{_gt_not_defined};
   static const InterpolationType interpolation_type{_itp_not_defined};
   static const ElementKind element_kind{_ek_regular};
   static const UInt spatial_dimension{0};
   static const GaussIntegrationType gauss_integration_type{_git_not_defined};
   static const UInt polynomial_degree{0};
 };
 
 /// Macro to generate the element class structures for different element types
 #define AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(elem_type, geom_type,             \
                                              interp_type, elem_kind, sp,       \
                                              gauss_int_type, min_int_order)    \
   template <> struct ElementClassProperty<elem_type> {                         \
     static const GeometricalType geometrical_type{geom_type};                  \
     static const InterpolationType interpolation_type{interp_type};            \
     static const ElementKind element_kind{elem_kind};                          \
     static const UInt spatial_dimension{sp};                                   \
     static const GaussIntegrationType gauss_integration_type{gauss_int_type};  \
     static const UInt polynomial_degree{min_int_order};                        \
   }
 
 /* -------------------------------------------------------------------------- */
 /* Geometry                                                                   */
 /* -------------------------------------------------------------------------- */
 /// Default GeometricalShape structure
 template <GeometricalType geometrical_type> struct GeometricalShape {
   static const GeometricalShapeType shape{_gst_point};
 };
 
 /// Templated GeometricalShape with function contains
 template <GeometricalShapeType shape> struct GeometricalShapeContains {
   /// Check if the point (vector in 2 and 3D) at natural coordinate coor
   template <class vector_type>
   static inline bool contains(const vector_type & coord);
 };
 
 /// Macro to generate the GeometricalShape structures for different geometrical
 /// types
 #define AKANTU_DEFINE_SHAPE(geom_type, geom_shape)                             \
   template <> struct GeometricalShape<geom_type> {                             \
     static const GeometricalShapeType shape{geom_shape};                       \
   }
 
 AKANTU_DEFINE_SHAPE(_gt_hexahedron_20, _gst_square);
 AKANTU_DEFINE_SHAPE(_gt_hexahedron_8, _gst_square);
 AKANTU_DEFINE_SHAPE(_gt_pentahedron_15, _gst_prism);
 AKANTU_DEFINE_SHAPE(_gt_pentahedron_6, _gst_prism);
 AKANTU_DEFINE_SHAPE(_gt_point, _gst_point);
 AKANTU_DEFINE_SHAPE(_gt_quadrangle_4, _gst_square);
 AKANTU_DEFINE_SHAPE(_gt_quadrangle_8, _gst_square);
 AKANTU_DEFINE_SHAPE(_gt_segment_2, _gst_square);
 AKANTU_DEFINE_SHAPE(_gt_segment_3, _gst_square);
 AKANTU_DEFINE_SHAPE(_gt_tetrahedron_10, _gst_triangle);
 AKANTU_DEFINE_SHAPE(_gt_tetrahedron_4, _gst_triangle);
 AKANTU_DEFINE_SHAPE(_gt_triangle_3, _gst_triangle);
 AKANTU_DEFINE_SHAPE(_gt_triangle_6, _gst_triangle);
 
 /* -------------------------------------------------------------------------- */
 /// Templated GeometricalElement with function getInradius
 template <GeometricalType geometrical_type,
           GeometricalShapeType shape =
               GeometricalShape<geometrical_type>::shape>
 class GeometricalElement {
 public:
   /// compute the in-radius
   static inline Real getInradius(__attribute__((unused))
                                  const Matrix<Real> & coord) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// true if the natural coordinates are in the element
   template <class vector_type>
   static inline bool contains(const vector_type & coord);
 
 public:
   static AKANTU_GET_MACRO_NOT_CONST(SpatialDimension, spatial_dimension, UInt);
   static AKANTU_GET_MACRO_NOT_CONST(NbNodesPerElement, nb_nodes_per_element,
                                     UInt);
   static AKANTU_GET_MACRO_NOT_CONST(NbFacetTypes, nb_facet_types, UInt);
   static inline UInt getNbFacetsPerElement(UInt t);
   static inline UInt getNbFacetsPerElement();
   static inline const MatrixProxy<UInt>
   getFacetLocalConnectivityPerElement(UInt t = 0);
 
 protected:
   /// Number of nodes per element
   static UInt nb_nodes_per_element;
   /// spatial dimension of the element
   static UInt spatial_dimension;
   /// number of different facet types
   static UInt nb_facet_types;
   /// number of facets for element
   static UInt nb_facets[];
   /// Nb nodes per facets types
   static UInt nb_nodes_per_facet[];
   /// storage of the facet local connectivity
   static UInt facet_connectivity_vect[];
   /// local connectivity of facets
   static UInt * facet_connectivity[];
 };
 
 /* -------------------------------------------------------------------------- */
 /* Interpolation                                                              */
 /* -------------------------------------------------------------------------- */
 /// default InterpolationProperty structure
 template <InterpolationType interpolation_type> struct InterpolationProperty {
   static const InterpolationKind kind{_itk_not_defined};
   static const UInt nb_nodes_per_element{0};
   static const UInt natural_space_dimension{0};
 };
 
 /// Macro to generate the InterpolationProperty structures for different
 /// interpolation types
 #define AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(itp_type, itp_kind,          \
                                                   nb_nodes, ndim)              \
   template <> struct InterpolationProperty<itp_type> {                         \
     static const InterpolationKind kind{itp_kind};                             \
     static const UInt nb_nodes_per_element{nb_nodes};                          \
     static const UInt natural_space_dimension{ndim};                           \
   }
 
 /* -------------------------------------------------------------------------- */
 /// Generic (templated by the enum InterpolationType which specifies the order
 /// and the dimension of the interpolation) class handling the elemental
 /// interpolation
 template <InterpolationType interpolation_type,
           InterpolationKind kind =
               InterpolationProperty<interpolation_type>::kind>
 class InterpolationElement {
 public:
-  typedef InterpolationProperty<interpolation_type> interpolation_property;
+  using interpolation_property = InterpolationProperty<interpolation_type>;
 
   /// compute the shape values for a given set of points in natural coordinates
   static inline void computeShapes(const Matrix<Real> & natural_coord,
                                    Matrix<Real> & N);
 
   /// compute the shape values for a given point in natural coordinates
   template <class vector_type>
   static inline void computeShapes(const vector_type &, vector_type &) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /**
    * compute @f$ B_{ij} = \frac{\partial N_j}{\partial S_i} @f$ the variation of
    * shape functions along with variation of natural coordinates on a given set
    * of points in natural coordinates
    */
   static inline void computeDNDS(const Matrix<Real> & natural_coord,
                                  Tensor3<Real> & dnds);
   /**
    * compute @f$ B_{ij} = \frac{\partial N_j}{\partial S_i} @f$ the variation of
    * shape functions along with
    * variation of natural coordinates on a given point in natural
    * coordinates
    */
   template <class vector_type, class matrix_type>
   static inline void computeDNDS(const vector_type &, matrix_type &) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// compute jacobian (or integration variable change factor) for a given point
   /// in the case of spatial_dimension != natural_space_dimension
   static inline void computeSpecialJacobian(const Matrix<Real> &, Real &) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// interpolate a field given (arbitrary) natural coordinates
   static inline void
   interpolateOnNaturalCoordinates(const Vector<Real> & natural_coords,
                                   const Matrix<Real> & nodal_values,
                                   Vector<Real> & interpolated);
 
   /// interpolate a field given the shape functions on the interpolation point
   static inline void interpolate(const Matrix<Real> & nodal_values,
                                  const Vector<Real> & shapes,
                                  Vector<Real> & interpolated);
 
   /// interpolate a field given the shape functions on the interpolations points
   static inline void interpolate(const Matrix<Real> & nodal_values,
                                  const Matrix<Real> & shapes,
                                  Matrix<Real> & interpolated);
 
   /// compute the gradient of a given field on the given natural coordinates
   static inline void
   gradientOnNaturalCoordinates(const Vector<Real> & natural_coords,
                                const Matrix<Real> & f, Matrix<Real> & gradient);
 
 public:
   static AKANTU_GET_MACRO_NOT_CONST(
       ShapeSize,
       InterpolationProperty<interpolation_type>::nb_nodes_per_element, UInt);
   static AKANTU_GET_MACRO_NOT_CONST(
       ShapeDerivativesSize,
       (InterpolationProperty<interpolation_type>::nb_nodes_per_element *
        InterpolationProperty<interpolation_type>::natural_space_dimension),
       UInt);
   static AKANTU_GET_MACRO_NOT_CONST(
       NaturalSpaceDimension,
       InterpolationProperty<interpolation_type>::natural_space_dimension, UInt);
   static AKANTU_GET_MACRO_NOT_CONST(
       NbNodesPerInterpolationElement,
       InterpolationProperty<interpolation_type>::nb_nodes_per_element, UInt);
 };
 
 /* -------------------------------------------------------------------------- */
 /* Integration                                                                */
 /* -------------------------------------------------------------------------- */
 template <GaussIntegrationType git_class, UInt nb_points>
 struct GaussIntegrationTypeData {
   /// quadrature points in natural coordinates
   static Real quad_positions[];
   /// weights for the Gauss integration
   static Real quad_weights[];
 };
 
 template <ElementType type,
           UInt n = ElementClassProperty<type>::polynomial_degree>
 class GaussIntegrationElement {
 public:
   static UInt getNbQuadraturePoints();
   static const Matrix<Real> getQuadraturePoints();
   static const Vector<Real> getWeights();
 };
 
 /* -------------------------------------------------------------------------- */
 /* ElementClass                                                               */
 /* -------------------------------------------------------------------------- */
 template <ElementType element_type,
           ElementKind element_kind =
               ElementClassProperty<element_type>::element_kind>
 class ElementClass
     : public GeometricalElement<
           ElementClassProperty<element_type>::geometrical_type>,
       public InterpolationElement<
           ElementClassProperty<element_type>::interpolation_type> {
 protected:
-  typedef GeometricalElement<
-      ElementClassProperty<element_type>::geometrical_type>
-      geometrical_element;
-  typedef InterpolationElement<
-      ElementClassProperty<element_type>::interpolation_type>
-      interpolation_element;
-
-  typedef ElementClassProperty<element_type> element_property;
-  typedef typename interpolation_element::interpolation_property
-      interpolation_property;
+  using geometrical_element = GeometricalElement<
+      ElementClassProperty<element_type>::geometrical_type>;
+  using interpolation_element = InterpolationElement<
+      ElementClassProperty<element_type>::interpolation_type>;
+
+  using element_property = ElementClassProperty<element_type>;
+  using interpolation_property =
+      typename interpolation_element::interpolation_property;
 
 public:
   /**
    * compute @f$ J = \frac{\partial x_j}{\partial s_i} @f$ the variation of real
    * coordinates along with variation of natural coordinates on a given point in
    * natural coordinates
    */
   static inline void computeJMat(const Matrix<Real> & dnds,
                                  const Matrix<Real> & node_coords,
                                  Matrix<Real> & J);
 
   /**
    * compute the Jacobian matrix by computing the variation of real coordinates
    * along with variation of natural coordinates on a given set of points in
    * natural coordinates
    */
   static inline void computeJMat(const Tensor3<Real> & dnds,
                                  const Matrix<Real> & node_coords,
                                  Tensor3<Real> & J);
 
   /// compute the jacobians of a serie of natural coordinates
   static inline void computeJacobian(const Matrix<Real> & natural_coords,
                                      const Matrix<Real> & node_coords,
                                      Vector<Real> & jacobians);
 
   /// compute jacobian (or integration variable change factor) for a set of
   /// points
   static inline void computeJacobian(const Tensor3<Real> & J,
                                      Vector<Real> & jacobians);
 
   /// compute jacobian (or integration variable change factor) for a given point
   static inline void computeJacobian(const Matrix<Real> & J, Real & jacobians);
 
   /// compute shape derivatives (input is dxds) for a set of points
   static inline void computeShapeDerivatives(const Tensor3<Real> & J,
                                              const Tensor3<Real> & dnds,
                                              Tensor3<Real> & shape_deriv);
 
   /// compute shape derivatives (input is dxds) for a given point
   static inline void computeShapeDerivatives(const Matrix<Real> & J,
                                              const Matrix<Real> & dnds,
                                              Matrix<Real> & shape_deriv);
 
   /// compute the normal of a surface defined by the function f
   static inline void
   computeNormalsOnNaturalCoordinates(const Matrix<Real> & coord,
                                      Matrix<Real> & f, Matrix<Real> & normals);
 
   /// get natural coordinates from real coordinates
   static inline void inverseMap(const Vector<Real> & real_coords,
                                 const Matrix<Real> & node_coords,
                                 Vector<Real> & natural_coords,
                                 Real tolerance = 1e-10);
 
   /// get natural coordinates from real coordinates
   static inline void inverseMap(const Matrix<Real> & real_coords,
                                 const Matrix<Real> & node_coords,
                                 Matrix<Real> & natural_coords,
                                 Real tolerance = 1e-10);
 
 public:
   static AKANTU_GET_MACRO_NOT_CONST(Kind, element_kind, ElementKind);
   static AKANTU_GET_MACRO_NOT_CONST(
       SpatialDimension, ElementClassProperty<element_type>::spatial_dimension,
       UInt);
   static AKANTU_GET_MACRO_NOT_CONST(P1ElementType, p1_type,
                                     const ElementType &);
   static const ElementType & getFacetType(UInt t = 0) { return facet_type[t]; }
   static ElementType * getFacetTypeInternal() { return facet_type; }
 
 protected:
   /// Type of the facet elements
   static ElementType facet_type[];
   /// type of element P1 associated
   static ElementType p1_type;
 };
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 #include "interpolation_element_tmpl.hh"
 /* -------------------------------------------------------------------------- */
 #include "element_class_tmpl.hh"
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 #include "element_class_pentahedron_6_inline_impl.cc"
 /* keep order */
 #include "element_class_hexahedron_20_inline_impl.cc"
 #include "element_class_hexahedron_8_inline_impl.cc"
 #include "element_class_pentahedron_15_inline_impl.cc"
 #include "element_class_point_1_inline_impl.cc"
 #include "element_class_quadrangle_4_inline_impl.cc"
 #include "element_class_quadrangle_8_inline_impl.cc"
 #include "element_class_segment_2_inline_impl.cc"
 #include "element_class_segment_3_inline_impl.cc"
 #include "element_class_tetrahedron_10_inline_impl.cc"
 #include "element_class_tetrahedron_4_inline_impl.cc"
 #include "element_class_triangle_3_inline_impl.cc"
 #include "element_class_triangle_6_inline_impl.cc"
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
 #include "element_class_structural.hh"
 #endif
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
 #include "cohesive_element.hh"
 #endif
 
 #if defined(AKANTU_IGFEM)
 #include "element_class_igfem.hh"
 #endif
 
 #endif /* __AKANTU_ELEMENT_CLASS_HH__ */
diff --git a/src/fe_engine/fe_engine.cc b/src/fe_engine/fe_engine.cc
index 561748958..95a2d29a2 100644
--- a/src/fe_engine/fe_engine.cc
+++ b/src/fe_engine/fe_engine.cc
@@ -1,95 +1,95 @@
 /**
  * @file   fe_engine.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Jul 20 2010
  * @date last modification: Fri Dec 11 2015
  *
  * @brief  Implementation of the FEEngine class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "fe_engine.hh"
 #include "aka_memory.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
-FEEngine::FEEngine(Mesh & mesh, UInt element_dimension, ID id,
+FEEngine::FEEngine(Mesh & mesh, UInt element_dimension, const ID & id,
                    MemoryID memory_id)
     : Memory(id, memory_id), mesh(mesh),
       normals_on_integration_points("normals_on_quad_points", id, memory_id) {
   AKANTU_DEBUG_IN();
   this->element_dimension = (element_dimension != _all_dimensions)
                                 ? element_dimension
                                 : mesh.getSpatialDimension();
 
   this->mesh.registerEventHandler(*this, _ehp_fe_engine);
 
   init();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void FEEngine::init() {}
 
 /* -------------------------------------------------------------------------- */
 FEEngine::~FEEngine() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 typename FEEngine::ElementTypesIteratorHelper
 FEEngine::elementTypes(UInt dim, GhostType ghost_type, ElementKind kind) const {
   return this->getIntegratorInterface().getJacobians().elementTypes(
       dim, ghost_type, kind);
 }
 
 /* -------------------------------------------------------------------------- */
 void FEEngine::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "FEEngine [" << std::endl;
   stream << space << " + id                : " << id << std::endl;
   stream << space << " + element dimension : " << element_dimension
          << std::endl;
 
   stream << space << " + mesh [" << std::endl;
   mesh.printself(stream, indent + 2);
   stream << space << AKANTU_INDENT << "]" << std::endl;
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/fe_engine/fe_engine.hh b/src/fe_engine/fe_engine.hh
index 9ca9a0343..dae6a197d 100644
--- a/src/fe_engine/fe_engine.hh
+++ b/src/fe_engine/fe_engine.hh
@@ -1,384 +1,384 @@
 /**
  * @file   fe_engine.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Oct 22 2015
  *
  * @brief  FEM class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_FE_ENGINE_HH__
 #define __AKANTU_FE_ENGINE_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "aka_memory.hh"
 #include "element_type_map.hh"
 #include "mesh_events.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 class Mesh;
 class Integrator;
 class ShapeFunctions;
 class DOFManager;
 class Element;
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 
 /**
  * The  generic  FEEngine class  derived  in  a  FEEngineTemplate class
  * containing  the
  * shape functions and the integration method
  */
 class FEEngine : protected Memory, public MeshEventHandler {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-  FEEngine(Mesh & mesh, UInt spatial_dimension = _all_dimensions, ID id = "fem",
-           MemoryID memory_id = 0);
+  FEEngine(Mesh & mesh, UInt spatial_dimension = _all_dimensions,
+           const ID & id = "fem", MemoryID memory_id = 0);
 
   ~FEEngine() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// pre-compute all the shape functions, their derivatives and the jacobians
   virtual void
   initShapeFunctions(const GhostType & ghost_type = _not_ghost) = 0;
 
   /// extract the nodal values and store them per element
   template <typename T>
   static void extractNodalToElementField(
       const Mesh & mesh, const Array<T> & nodal_f, Array<T> & elemental_f,
       const ElementType & type, const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter);
 
   /// filter a field
   template <typename T>
   static void
   filterElementalData(const Mesh & mesh, const Array<T> & quad_f,
                       Array<T> & filtered_f, const ElementType & type,
                       const GhostType & ghost_type = _not_ghost,
                       const Array<UInt> & filter_elements = empty_filter);
 
   /* ------------------------------------------------------------------------ */
   /* Integration method bridges                                               */
   /* ------------------------------------------------------------------------ */
   /// integrate f for all elements of type "type"
   virtual void
   integrate(const Array<Real> & f, Array<Real> & intf,
             UInt nb_degree_of_freedom, const ElementType & type,
             const GhostType & ghost_type = _not_ghost,
             const Array<UInt> & filter_elements = empty_filter) const = 0;
 
   /// integrate a scalar value f on all elements of type "type"
   virtual Real
   integrate(const Array<Real> & f, const ElementType & type,
             const GhostType & ghost_type = _not_ghost,
             const Array<UInt> & filter_elements = empty_filter) const = 0;
 
   /// integrate f for all integration points of type "type" but don't sum over
   /// all integration points
   virtual void integrateOnIntegrationPoints(
       const Array<Real> & f, Array<Real> & intf, UInt nb_degree_of_freedom,
       const ElementType & type, const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const = 0;
 
   /// integrate one element scalar value on all elements of type "type"
   virtual Real integrate(const Vector<Real> & f, const ElementType & type,
                          UInt index,
                          const GhostType & ghost_type = _not_ghost) const = 0;
 
 /* ------------------------------------------------------------------------ */
 /* compatibility with old FEEngine fashion */
 /* ------------------------------------------------------------------------ */
 #ifndef SWIG
   /// get the number of integration points
   virtual UInt
   getNbIntegrationPoints(const ElementType & type,
                          const GhostType & ghost_type = _not_ghost) const = 0;
   /// get the precomputed shapes
   const virtual Array<Real> &
   getShapes(const ElementType & type, const GhostType & ghost_type = _not_ghost,
             UInt id = 0) const = 0;
 
   /// get the derivatives of shapes
   const virtual Array<Real> &
   getShapesDerivatives(const ElementType & type,
                        const GhostType & ghost_type = _not_ghost,
                        UInt id = 0) const = 0;
 
   /// get integration points
   const virtual Matrix<Real> &
   getIntegrationPoints(const ElementType & type,
                        const GhostType & ghost_type = _not_ghost) const = 0;
 #endif
   /* ------------------------------------------------------------------------ */
   /* Shape method bridges                                                     */
   /* ------------------------------------------------------------------------ */
   /// Compute the gradient nablauq on the integration points of an element type
   /// from nodal values u
   virtual void gradientOnIntegrationPoints(
       const Array<Real> & u, Array<Real> & nablauq,
       const UInt nb_degree_of_freedom, const ElementType & type,
       const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const = 0;
 
   /// Interpolate a nodal field u at the integration points of an element type
   /// -> uq
   virtual void interpolateOnIntegrationPoints(
       const Array<Real> & u, Array<Real> & uq, UInt nb_degree_of_freedom,
       const ElementType & type, const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const = 0;
 
   /// Interpolate a nodal field u at the integration points of many element
   /// types -> uq
   virtual void interpolateOnIntegrationPoints(
       const Array<Real> & u, ElementTypeMapArray<Real> & uq,
       const ElementTypeMapArray<UInt> * filter_elements = nullptr) const = 0;
 
   /// Compute the interpolation point position in the global coordinates for
   /// many element types
   virtual void computeIntegrationPointsCoordinates(
       ElementTypeMapArray<Real> & integration_points_coordinates,
       const ElementTypeMapArray<UInt> * filter_elements = nullptr) const = 0;
 
   /// Compute the interpolation point position in the global coordinates for an
   /// element type
   virtual void computeIntegrationPointsCoordinates(
       Array<Real> & integration_points_coordinates, const ElementType & type,
       const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const = 0;
 
   /// Build pre-computed matrices for interpolation of field form integration
   /// points at other given positions (interpolation_points)
   virtual void initElementalFieldInterpolationFromIntegrationPoints(
       const ElementTypeMapArray<Real> & interpolation_points_coordinates,
       ElementTypeMapArray<Real> & interpolation_points_coordinates_matrices,
       ElementTypeMapArray<Real> & integration_points_coordinates_inv_matrices,
       const ElementTypeMapArray<UInt> * element_filter) const = 0;
 
   /// interpolate field at given position (interpolation_points) from given
   /// values of this field at integration points (field)
   virtual void interpolateElementalFieldFromIntegrationPoints(
       const ElementTypeMapArray<Real> & field,
       const ElementTypeMapArray<Real> & interpolation_points_coordinates,
       ElementTypeMapArray<Real> & result, const GhostType ghost_type,
       const ElementTypeMapArray<UInt> * element_filter) const = 0;
 
   /// Interpolate field at given position from given values of this field at
   /// integration points (field)
   /// using matrices precomputed with
   /// initElementalFieldInterplationFromIntegrationPoints
   virtual void interpolateElementalFieldFromIntegrationPoints(
       const ElementTypeMapArray<Real> & field,
       const ElementTypeMapArray<Real> &
           interpolation_points_coordinates_matrices,
       const ElementTypeMapArray<Real> &
           integration_points_coordinates_inv_matrices,
       ElementTypeMapArray<Real> & result, const GhostType ghost_type,
       const ElementTypeMapArray<UInt> * element_filter) const = 0;
 
   /// interpolate on a phyiscal point inside an element
   virtual void interpolate(const Vector<Real> & real_coords,
                            const Matrix<Real> & nodal_values,
                            Vector<Real> & interpolated,
                            const Element & element) const = 0;
 
   /// compute the shape on a provided point
   virtual void
   computeShapes(const Vector<Real> & real_coords, UInt elem,
                 const ElementType & type, Vector<Real> & shapes,
                 const GhostType & ghost_type = _not_ghost) const = 0;
 
   /// compute the shape derivatives on a provided point
   virtual void
   computeShapeDerivatives(const Vector<Real> & real__coords, UInt element,
                           const ElementType & type,
                           Matrix<Real> & shape_derivatives,
                           const GhostType & ghost_type = _not_ghost) const = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Other methods                                                            */
   /* ------------------------------------------------------------------------ */
 
   /// pre-compute normals on integration points
   virtual void computeNormalsOnIntegrationPoints(
       const GhostType & ghost_type = _not_ghost) = 0;
 
   /// pre-compute normals on integration points
   virtual void computeNormalsOnIntegrationPoints(
       __attribute__((unused)) const Array<Real> & field,
       __attribute__((unused)) const GhostType & ghost_type = _not_ghost) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// pre-compute normals on integration points
   virtual void computeNormalsOnIntegrationPoints(
       __attribute__((unused)) const Array<Real> & field,
       __attribute__((unused)) Array<Real> & normal,
       __attribute__((unused)) const ElementType & type,
       __attribute__((unused)) const GhostType & ghost_type = _not_ghost) const {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
 #ifdef AKANTU_STRUCTURAL_MECHANICS
 
   /// assemble a field as a matrix for structural elements (ex. rho to mass
   /// matrix)
   virtual void assembleFieldMatrix(
       __attribute__((unused)) const Array<Real> & field_1,
       __attribute__((unused)) UInt nb_degree_of_freedom,
       __attribute__((unused)) SparseMatrix & M,
       __attribute__((unused)) Array<Real> * n,
       __attribute__((unused)) ElementTypeMapArray<Real> & rotation_mat,
       __attribute__((unused)) ElementType type,
       __attribute__((unused)) const GhostType & ghost_type) const {
 
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
   /// compute shapes function in a matrix for structural elements
   virtual void computeShapesMatrix(
       __attribute__((unused)) const ElementType & type,
       __attribute__((unused)) UInt nb_degree_of_freedom,
       __attribute__((unused)) UInt nb_nodes_per_element,
       __attribute__((unused)) Array<Real> * n, __attribute__((unused)) UInt id,
       __attribute__((unused)) UInt degree_to_interpolate,
       __attribute__((unused)) UInt degree_interpolated,
       __attribute__((unused)) const bool sign,
       __attribute__((unused)) const GhostType & ghost_type) const {
 
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
 #endif
 
   /// function to print the containt of the class
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
 private:
   /// initialise the class
   void init();
 
   /* ------------------------------------------------------------------------ */
   /* Mesh Event Handler interface                                             */
   /* ------------------------------------------------------------------------ */
 public:
   void onNodesAdded(const Array<UInt> &, const NewNodesEvent &) final {}
   void onNodesRemoved(const Array<UInt> &, const Array<UInt> &,
                       const RemovedNodesEvent &) final {}
   void onElementsAdded(const Array<Element> &,
                        const NewElementsEvent &) override{};
   void onElementsRemoved(const Array<Element> &,
                          const ElementTypeMapArray<UInt> &,
                          const RemovedElementsEvent &) override {}
   void onElementsChanged(const Array<Element> &, const Array<Element> &,
                          const ElementTypeMapArray<UInt> &,
                          const ChangedElementsEvent &) override {}
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   using ElementTypesIteratorHelper =
       ElementTypeMapArray<Real, ElementType>::ElementTypesIteratorHelper;
 
   ElementTypesIteratorHelper elementTypes(UInt dim = _all_dimensions,
                                           GhostType ghost_type = _not_ghost,
                                           ElementKind kind = _ek_regular) const;
 
   /// get the dimension of the element handeled by this fe_engine object
   AKANTU_GET_MACRO(ElementDimension, element_dimension, UInt);
 
   /// get the mesh contained in the fem object
   AKANTU_GET_MACRO(Mesh, mesh, const Mesh &);
   /// get the mesh contained in the fem object
   AKANTU_GET_MACRO_NOT_CONST(Mesh, mesh, Mesh &);
 
   /// get the in-radius of an element
   static inline Real getElementInradius(const Matrix<Real> & coord,
                                         const ElementType & type);
 
   /// get the normals on integration points
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(NormalsOnIntegrationPoints,
                                          normals_on_integration_points, Real);
 
   /// get cohesive element type for a given facet type
   static inline ElementType
   getCohesiveElementType(const ElementType & type_facet);
 
   /// get igfem element type for a given regular type
   static inline Vector<ElementType>
   getIGFEMElementTypes(const ElementType & type);
 
   /// get the interpolation element associated to an element type
   static inline InterpolationType
   getInterpolationType(const ElementType & el_type);
 
   /// get the shape function class (probably useless: see getShapeFunction in
   /// fe_engine_template.hh)
   virtual const ShapeFunctions & getShapeFunctionsInterface() const = 0;
   /// get the integrator class (probably useless: see getIntegrator in
   /// fe_engine_template.hh)
   virtual const Integrator & getIntegratorInterface() const = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// spatial dimension of the problem
   UInt element_dimension;
 
   /// the mesh on which all computation are made
   Mesh & mesh;
 
   /// normals at integration points
   ElementTypeMapArray<Real> normals_on_integration_points;
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream,
                                  const FEEngine & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #include "fe_engine_inline_impl.cc"
 #include "fe_engine_template.hh"
 
 #endif /* __AKANTU_FE_ENGINE_HH__ */
diff --git a/src/fe_engine/fe_engine_template.hh b/src/fe_engine/fe_engine_template.hh
index 5b8c0e502..accd7e883 100644
--- a/src/fe_engine/fe_engine_template.hh
+++ b/src/fe_engine/fe_engine_template.hh
@@ -1,395 +1,395 @@
 /**
  * @file   fe_engine_template.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  templated class that calls integration and shape objects
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_FE_ENGINE_TEMPLATE_HH__
 #define __AKANTU_FE_ENGINE_TEMPLATE_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "fe_engine.hh"
 #include "integrator.hh"
 #include "shape_functions.hh"
 /* -------------------------------------------------------------------------- */
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 class DOFManager;
 namespace fe_engine {
   namespace details {
     template <ElementKind> struct AssembleLumpedTemplateHelper;
     template <ElementKind> struct AssembleFieldMatrixHelper;
   } // namespace details
 } // namespace fe_engine
 
 template <ElementKind, typename> struct AssembleFieldMatrixStructHelper;
 
 struct DefaultIntegrationOrderFunctor {
   template <ElementType type> static inline constexpr int getOrder() {
     return ElementClassProperty<type>::polynomial_degree;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind = _ek_regular,
           class IntegrationOrderFunctor = DefaultIntegrationOrderFunctor>
 class FEEngineTemplate : public FEEngine {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   typedef I<kind, IntegrationOrderFunctor> Integ;
-  typedef S<kind> Shape;
+  using Shape = S<kind>;
 
   FEEngineTemplate(Mesh & mesh, UInt spatial_dimension = _all_dimensions,
                    ID id = "fem", MemoryID memory_id = 0);
 
   ~FEEngineTemplate() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// pre-compute all the shape functions, their derivatives and the jacobians
   void initShapeFunctions(const GhostType & ghost_type = _not_ghost) override;
   void initShapeFunctions(const Array<Real> & nodes,
                           const GhostType & ghost_type = _not_ghost);
 
   /* ------------------------------------------------------------------------ */
   /* Integration method bridges                                               */
   /* ------------------------------------------------------------------------ */
   /// integrate f for all elements of type "type"
   void
   integrate(const Array<Real> & f, Array<Real> & intf,
             UInt nb_degree_of_freedom, const ElementType & type,
             const GhostType & ghost_type = _not_ghost,
             const Array<UInt> & filter_elements = empty_filter) const override;
 
   /// integrate a scalar value on all elements of type "type"
   Real
   integrate(const Array<Real> & f, const ElementType & type,
             const GhostType & ghost_type = _not_ghost,
             const Array<UInt> & filter_elements = empty_filter) const override;
 
   /// integrate one element scalar value on all elements of type "type"
   Real integrate(const Vector<Real> & f, const ElementType & type, UInt index,
                  const GhostType & ghost_type = _not_ghost) const override;
 
   /// integrate partially around an integration point (@f$ intf_q = f_q * J_q *
   /// w_q @f$)
   void integrateOnIntegrationPoints(
       const Array<Real> & f, Array<Real> & intf, UInt nb_degree_of_freedom,
       const ElementType & type, const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const override;
 
   /// interpolate on a phyiscal point inside an element
   void interpolate(const Vector<Real> & real_coords,
                    const Matrix<Real> & nodal_values,
                    Vector<Real> & interpolated,
                    const Element & element) const override;
 
   /// get the number of integration points
   UInt getNbIntegrationPoints(
       const ElementType & type,
       const GhostType & ghost_type = _not_ghost) const override;
 
   /// get shapes precomputed
   const Array<Real> & getShapes(const ElementType & type,
                                 const GhostType & ghost_type = _not_ghost,
                                 UInt id = 0) const override;
 
   /// get the derivatives of shapes
   const Array<Real> &
   getShapesDerivatives(const ElementType & type,
                        const GhostType & ghost_type = _not_ghost,
                        UInt id = 0) const override;
 
   /// get integration points
   const inline Matrix<Real> & getIntegrationPoints(
       const ElementType & type,
       const GhostType & ghost_type = _not_ghost) const override;
 
   /* ------------------------------------------------------------------------ */
   /* Shape method bridges                                                     */
   /* ------------------------------------------------------------------------ */
 
   /// compute the gradient of a nodal field on the integration points
   void gradientOnIntegrationPoints(
       const Array<Real> & u, Array<Real> & nablauq,
       const UInt nb_degree_of_freedom, const ElementType & type,
       const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const override;
 
   /// interpolate a nodal field on the integration points
   void interpolateOnIntegrationPoints(
       const Array<Real> & u, Array<Real> & uq, UInt nb_degree_of_freedom,
       const ElementType & type, const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const override;
 
   /// interpolate a nodal field on the integration points given a
   /// by_element_type
   void interpolateOnIntegrationPoints(
       const Array<Real> & u, ElementTypeMapArray<Real> & uq,
       const ElementTypeMapArray<UInt> * filter_elements =
           nullptr) const override;
 
   /// compute the position of integration points given by an element_type_map
   /// from nodes position
   inline void computeIntegrationPointsCoordinates(
       ElementTypeMapArray<Real> & quadrature_points_coordinates,
       const ElementTypeMapArray<UInt> * filter_elements =
           nullptr) const override;
 
   /// compute the position of integration points from nodes position
   inline void computeIntegrationPointsCoordinates(
       Array<Real> & quadrature_points_coordinates, const ElementType & type,
       const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const override;
 
   /// interpolate field at given position (interpolation_points) from given
   /// values of this field at integration points (field)
   inline void interpolateElementalFieldFromIntegrationPoints(
       const ElementTypeMapArray<Real> & field,
       const ElementTypeMapArray<Real> & interpolation_points_coordinates,
       ElementTypeMapArray<Real> & result, const GhostType ghost_type,
       const ElementTypeMapArray<UInt> * element_filter) const override;
 
   /// Interpolate field at given position from given values of this field at
   /// integration points (field)
   /// using matrices precomputed with
   /// initElementalFieldInterplationFromIntegrationPoints
   inline void interpolateElementalFieldFromIntegrationPoints(
       const ElementTypeMapArray<Real> & field,
       const ElementTypeMapArray<Real> &
           interpolation_points_coordinates_matrices,
       const ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
       ElementTypeMapArray<Real> & result, const GhostType ghost_type,
       const ElementTypeMapArray<UInt> * element_filter) const override;
 
   /// Build pre-computed matrices for interpolation of field form integration
   /// points at other given positions (interpolation_points)
   inline void initElementalFieldInterpolationFromIntegrationPoints(
       const ElementTypeMapArray<Real> & interpolation_points_coordinates,
       ElementTypeMapArray<Real> & interpolation_points_coordinates_matrices,
       ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
       const ElementTypeMapArray<UInt> * element_filter =
           nullptr) const override;
 
   /// find natural coords from real coords provided an element
   void inverseMap(const Vector<Real> & real_coords, UInt element,
                   const ElementType & type, Vector<Real> & natural_coords,
                   const GhostType & ghost_type = _not_ghost) const;
 
   /// return true if the coordinates provided are inside the element, false
   /// otherwise
   inline bool contains(const Vector<Real> & real_coords, UInt element,
                        const ElementType & type,
                        const GhostType & ghost_type = _not_ghost) const;
 
   /// compute the shape on a provided point
   inline void
   computeShapes(const Vector<Real> & real_coords, UInt element,
                 const ElementType & type, Vector<Real> & shapes,
                 const GhostType & ghost_type = _not_ghost) const override;
 
   /// compute the shape derivatives on a provided point
   inline void computeShapeDerivatives(
       const Vector<Real> & real__coords, UInt element, const ElementType & type,
       Matrix<Real> & shape_derivatives,
       const GhostType & ghost_type = _not_ghost) const override;
 
   /* ------------------------------------------------------------------------ */
   /* Other methods                                                            */
   /* ------------------------------------------------------------------------ */
 
   /// pre-compute normals on integration points
   void computeNormalsOnIntegrationPoints(
       const GhostType & ghost_type = _not_ghost) override;
   void computeNormalsOnIntegrationPoints(
       const Array<Real> & field,
       const GhostType & ghost_type = _not_ghost) override;
   void computeNormalsOnIntegrationPoints(
       const Array<Real> & field, Array<Real> & normal, const ElementType & type,
       const GhostType & ghost_type = _not_ghost) const override;
   template <ElementType type>
   void computeNormalsOnIntegrationPoints(const Array<Real> & field,
                                          Array<Real> & normal,
                                          const GhostType & ghost_type) const;
 
 private:
   // To avoid a weird full specialization of a method in a non specalized class
   void
   computeNormalsOnIntegrationPointsPoint1(const Array<Real> &,
                                           Array<Real> & normal,
                                           const GhostType & ghost_type) const;
 
 public:
   /// function to print the contain of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
   /// assemble a field as a lumped matrix (ex. rho in lumped mass)
   template <class Functor>
   void assembleFieldLumped(const Functor & field_funct, const ID & matrix_id,
                            const ID & dof_id, DOFManager & dof_manager,
                            ElementType type,
                            const GhostType & ghost_type) const;
 
   /// assemble a field as a matrix (ex. rho to mass matrix)
   template <class Functor>
   void assembleFieldMatrix(const Functor & field_funct, const ID & matrix_id,
                            const ID & dof_id, DOFManager & dof_manager,
                            ElementType type,
                            const GhostType & ghost_type) const;
 
 #ifdef AKANTU_STRUCTURAL_MECHANICS
   /// assemble a field as a matrix (ex. rho to mass matrix)
   void assembleFieldMatrix(const Array<Real> & field_1,
                            UInt nb_degree_of_freedom, SparseMatrix & M,
                            Array<Real> * n,
                            ElementTypeMapArray<Real> & rotation_mat,
                            const ElementType & type,
                            const GhostType & ghost_type = _not_ghost) const;
 
   /// compute shapes function in a matrix for structural elements
   void computeShapesMatrix(const ElementType & type, UInt nb_degree_of_freedom,
                            UInt nb_nodes_per_element, Array<Real> * n, UInt id,
                            UInt degree_to_interpolate, UInt degree_interpolated,
                            const bool sign,
                            const GhostType & ghost_type = _not_ghost) const;
 #endif
 
 private:
   friend struct fe_engine::details::AssembleLumpedTemplateHelper<kind>;
   friend struct fe_engine::details::AssembleFieldMatrixHelper<kind>;
   friend struct AssembleFieldMatrixStructHelper<kind, void>;
 
   /// templated function to compute the scaling to assemble a lumped matrix
   template <class Functor, ElementType type>
   void assembleFieldLumped(const Functor & field_funct, const ID & matrix_id,
                            const ID & dof_id, DOFManager & dof_manager,
                            const GhostType & ghost_type) const;
 
   /// @f$ \tilde{M}_{i} = \sum_j M_{ij} = \sum_j \int \rho \varphi_i \varphi_j
   /// dV = \int \rho \varphi_i dV @f$
   template <ElementType type>
   void assembleLumpedRowSum(const Array<Real> & field, const ID & matrix_id,
                             const ID & dof_id, DOFManager & dof_manager,
                             const GhostType & ghost_type) const;
 
   /// @f$ \tilde{M}_{i} = c * M_{ii} = \int_{V_e} \rho dV @f$
   template <ElementType type>
   void assembleLumpedDiagonalScaling(const Array<Real> & field,
                                      const ID & matrix_id, const ID & dof_id,
                                      DOFManager & dof_manager,
                                      const GhostType & ghost_type) const;
 
   /// assemble a field as a matrix (ex. rho to mass matrix)
   template <class Functor, ElementType type>
   void assembleFieldMatrix(const Functor & field_funct, const ID & matrix_id,
                            const ID & dof_id, DOFManager & dof_manager,
                            const GhostType & ghost_type) const;
 
 #ifdef AKANTU_STRUCTURAL_MECHANICS
 
   /// assemble a field as a matrix for structural elements (ex. rho to mass
   /// matrix)
   template <ElementType type>
   void assembleFieldMatrix(const Array<Real> & field_1,
                            UInt nb_degree_of_freedom, SparseMatrix & M,
                            Array<Real> * n,
                            ElementTypeMapArray<Real> & rotation_mat,
                            __attribute__((unused))
                            const GhostType & ghost_type) const;
 
 #endif
 
   /* ------------------------------------------------------------------------ */
   /* Mesh Event Handler interface                                             */
   /* ------------------------------------------------------------------------ */
 public:
   void onElementsAdded(const Array<Element> &,
                        const NewElementsEvent &) override;
   void onElementsRemoved(const Array<Element> &,
                          const ElementTypeMapArray<UInt> &,
                          const RemovedElementsEvent &) override;
   void onElementsChanged(const Array<Element> &, const Array<Element> &,
                          const ElementTypeMapArray<UInt> &,
                          const ChangedElementsEvent &) override;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the shape class (probably useless: see getShapeFunction)
   const ShapeFunctions & getShapeFunctionsInterface() const override {
     return shape_functions;
   };
   /// get the shape class
   const Shape & getShapeFunctions() const { return shape_functions; };
 
   /// get the integrator class (probably useless: see getIntegrator)
   const Integrator & getIntegratorInterface() const override {
     return integrator;
   };
   /// get the integrator class
   const Integ & getIntegrator() const { return integrator; };
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   Integ integrator;
   Shape shape_functions;
 };
 
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 #include "fe_engine_template_tmpl.hh"
 #include "fe_engine_template_tmpl_field.hh"
 /* -------------------------------------------------------------------------- */
 /* Shape Linked specialization                                                */
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
 #include "fe_engine_template_tmpl_struct.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 /* Shape IGFEM specialization                                                 */
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_IGFEM)
 #include "fe_engine_template_tmpl_igfem.hh"
 #endif
 
 #endif /* __AKANTU_FE_ENGINE_TEMPLATE_HH__ */
diff --git a/src/fe_engine/fe_engine_template_tmpl.hh b/src/fe_engine/fe_engine_template_tmpl.hh
index 83e0f168e..7362420f8 100644
--- a/src/fe_engine/fe_engine_template_tmpl.hh
+++ b/src/fe_engine/fe_engine_template_tmpl.hh
@@ -1,1301 +1,1302 @@
 /**
  * @file   fe_engine_template_tmpl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue Feb 15 2011
  * @date last modification: Thu Nov 19 2015
  *
  * @brief  Template implementation of FEEngineTemplate
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "dof_manager.hh"
 #include "fe_engine_template.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::FEEngineTemplate(
     Mesh & mesh, UInt spatial_dimension, ID id, MemoryID memory_id)
     : FEEngine(mesh, spatial_dimension, id, memory_id),
       integrator(mesh, id, memory_id), shape_functions(mesh, id, memory_id) {}
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
-FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::~FEEngineTemplate() {}
+FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::~FEEngineTemplate() =
+    default;
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct GradientOnIntegrationPointsHelper {
       template <class S>
       static void call(const S &, Mesh &, const Array<Real> &, Array<Real> &,
                        const UInt, const ElementType &, const GhostType &,
                        const Array<UInt> &) {
         AKANTU_DEBUG_TO_IMPLEMENT();
       }
     };
 
 #define COMPUTE_GRADIENT(type)                                                 \
   if (element_dimension == ElementClass<type>::getSpatialDimension())          \
     shape_functions.template gradientOnIntegrationPoints<type>(                \
         u, nablauq, nb_degree_of_freedom, ghost_type, filter_elements);
 
 #define AKANTU_SPECIALIZE_GRADIENT_ON_INTEGRATION_POINTS_HELPER(kind)          \
   template <> struct GradientOnIntegrationPointsHelper<kind> {                 \
     template <class S>                                                         \
     static void call(const S & shape_functions, Mesh & mesh,                   \
                      const Array<Real> & u, Array<Real> & nablauq,             \
                      const UInt nb_degree_of_freedom,                          \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<UInt> & filter_elements) {                    \
       UInt element_dimension = mesh.getSpatialDimension(type);                 \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(COMPUTE_GRADIENT, kind);                \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(
         AKANTU_SPECIALIZE_GRADIENT_ON_INTEGRATION_POINTS_HELPER,
         AKANTU_FE_ENGINE_LIST_GRADIENT_ON_INTEGRATION_POINTS)
 
 #undef AKANTU_SPECIALIZE_GRADIENT_ON_INTEGRATION_POINTS_HELPER
 #undef COMPUTE_GRADIENT
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     gradientOnIntegrationPoints(const Array<Real> & u, Array<Real> & nablauq,
                                 const UInt nb_degree_of_freedom,
                                 const ElementType & type,
                                 const GhostType & ghost_type,
                                 const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
     nb_element = filter_elements.size();
   UInt nb_points =
       shape_functions.getIntegrationPoints(type, ghost_type).cols();
 
 #ifndef AKANTU_NDEBUG
 
   UInt element_dimension = mesh.getSpatialDimension(type);
 
   AKANTU_DEBUG_ASSERT(u.size() == mesh.getNbNodes(),
                       "The vector u(" << u.getID()
                                       << ") has not the good size.");
   AKANTU_DEBUG_ASSERT(u.getNbComponent() == nb_degree_of_freedom,
                       "The vector u("
                           << u.getID()
                           << ") has not the good number of component.");
 
   AKANTU_DEBUG_ASSERT(
       nablauq.getNbComponent() == nb_degree_of_freedom * element_dimension,
       "The vector nablauq(" << nablauq.getID()
                             << ") has not the good number of component.");
 
 // AKANTU_DEBUG_ASSERT(nablauq.size() == nb_element * nb_points,
 //                  "The vector nablauq(" << nablauq.getID()
 //                  << ") has not the good size.");
 #endif
 
   nablauq.resize(nb_element * nb_points);
 
   fe_engine::details::GradientOnIntegrationPointsHelper<kind>::call(
       shape_functions, mesh, u, nablauq, nb_degree_of_freedom, type, ghost_type,
       filter_elements);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::initShapeFunctions(
     const GhostType & ghost_type) {
   initShapeFunctions(mesh.getNodes(), ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::initShapeFunctions(
     const Array<Real> & nodes, const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   for (auto & type : mesh.elementTypes(element_dimension, ghost_type, kind)) {
     integrator.initIntegrator(nodes, type, ghost_type);
     const auto & control_points = getIntegrationPoints(type, ghost_type);
     shape_functions.initShapeFunctions(nodes, control_points, type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct IntegrateHelper {};
 
 #define INTEGRATE(type)                                                        \
   integrator.template integrate<type>(f, intf, nb_degree_of_freedom,           \
                                       ghost_type, filter_elements);
 
 #define AKANTU_SPECIALIZE_INTEGRATE_HELPER(kind)                               \
   template <> struct IntegrateHelper<kind> {                                   \
     template <class I>                                                         \
     static void call(const I & integrator, const Array<Real> & f,              \
                      Array<Real> & intf, UInt nb_degree_of_freedom,            \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<UInt> & filter_elements) {                    \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTEGRATE, kind);                       \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_INTEGRATE_HELPER)
 
 #undef AKANTU_SPECIALIZE_INTEGRATE_HELPER
 #undef INTEGRATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::integrate(
     const Array<Real> & f, Array<Real> & intf, UInt nb_degree_of_freedom,
     const ElementType & type, const GhostType & ghost_type,
     const Array<UInt> & filter_elements) const {
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
     nb_element = filter_elements.size();
 #ifndef AKANTU_NDEBUG
 
   UInt nb_quadrature_points = getNbIntegrationPoints(type);
 
   AKANTU_DEBUG_ASSERT(f.size() == nb_element * nb_quadrature_points,
                       "The vector f(" << f.getID() << " size " << f.size()
                                       << ") has not the good size ("
                                       << nb_element << ").");
   AKANTU_DEBUG_ASSERT(f.getNbComponent() == nb_degree_of_freedom,
                       "The vector f("
                           << f.getID()
                           << ") has not the good number of component.");
   AKANTU_DEBUG_ASSERT(intf.getNbComponent() == nb_degree_of_freedom,
                       "The vector intf("
                           << intf.getID()
                           << ") has not the good number of component.");
 #endif
 
   intf.resize(nb_element);
 
   fe_engine::details::IntegrateHelper<kind>::call(integrator, f, intf,
                                                   nb_degree_of_freedom, type,
                                                   ghost_type, filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct IntegrateScalarHelper {};
 
 #define INTEGRATE(type)                                                        \
   integral =                                                                   \
       integrator.template integrate<type>(f, ghost_type, filter_elements);
 
 #define AKANTU_SPECIALIZE_INTEGRATE_SCALAR_HELPER(kind)                        \
   template <> struct IntegrateScalarHelper<kind> {                             \
     template <class I>                                                         \
     static Real call(const I & integrator, const Array<Real> & f,              \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<UInt> & filter_elements) {                    \
       Real integral = 0.;                                                      \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTEGRATE, kind);                       \
       return integral;                                                         \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_INTEGRATE_SCALAR_HELPER)
 
 #undef AKANTU_SPECIALIZE_INTEGRATE_SCALAR_HELPER
 #undef INTEGRATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 Real FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::integrate(
     const Array<Real> & f, const ElementType & type,
     const GhostType & ghost_type, const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
 #ifndef AKANTU_NDEBUG
   //   std::stringstream sstr; sstr << ghost_type;
   //   AKANTU_DEBUG_ASSERT(sstr.str() == nablauq.getTag(),
   //                  "The vector " << nablauq.getID() << " is not taged " <<
   //                  ghost_type);
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
     nb_element = filter_elements.size();
 
   UInt nb_quadrature_points = getNbIntegrationPoints(type, ghost_type);
 
   AKANTU_DEBUG_ASSERT(f.size() == nb_element * nb_quadrature_points,
                       "The vector f("
                           << f.getID() << ") has not the good size. ("
                           << f.size()
                           << "!=" << nb_quadrature_points * nb_element << ")");
   AKANTU_DEBUG_ASSERT(f.getNbComponent() == 1,
                       "The vector f("
                           << f.getID()
                           << ") has not the good number of component.");
 #endif
 
   Real integral = fe_engine::details::IntegrateScalarHelper<kind>::call(
       integrator, f, type, ghost_type, filter_elements);
   AKANTU_DEBUG_OUT();
   return integral;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct IntegrateScalarOnOneElementHelper {};
 
 #define INTEGRATE(type)                                                        \
   res = integrator.template integrate<type>(f, index, ghost_type);
 
 #define AKANTU_SPECIALIZE_INTEGRATE_SCALAR_ON_ONE_ELEMENT_HELPER(kind)         \
   template <> struct IntegrateScalarOnOneElementHelper<kind> {                 \
     template <class I>                                                         \
     static Real call(const I & integrator, const Vector<Real> & f,             \
                      const ElementType & type, UInt index,                     \
                      const GhostType & ghost_type) {                           \
       Real res = 0.;                                                           \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTEGRATE, kind);                       \
       return res;                                                              \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(
         AKANTU_SPECIALIZE_INTEGRATE_SCALAR_ON_ONE_ELEMENT_HELPER)
 
 #undef AKANTU_SPECIALIZE_INTEGRATE_SCALAR_ON_ONE_ELEMENT_HELPER
 #undef INTEGRATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 Real FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::integrate(
     const Vector<Real> & f, const ElementType & type, UInt index,
     const GhostType & ghost_type) const {
 
   Real res = fe_engine::details::IntegrateScalarOnOneElementHelper<kind>::call(
       integrator, f, type, index, ghost_type);
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct IntegrateOnIntegrationPointsHelper {};
 
 #define INTEGRATE(type)                                                        \
   integrator.template integrateOnIntegrationPoints<type>(                      \
       f, intf, nb_degree_of_freedom, ghost_type, filter_elements);
 
 #define AKANTU_SPECIALIZE_INTEGRATE_ON_INTEGRATION_POINTS_HELPER(kind)         \
   template <> struct IntegrateOnIntegrationPointsHelper<kind> {                \
     template <class I>                                                         \
     static void call(const I & integrator, const Array<Real> & f,              \
                      Array<Real> & intf, UInt nb_degree_of_freedom,            \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<UInt> & filter_elements) {                    \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTEGRATE, kind);                       \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(
         AKANTU_SPECIALIZE_INTEGRATE_ON_INTEGRATION_POINTS_HELPER)
 
 #undef AKANTU_SPECIALIZE_INTEGRATE_ON_INTEGRATION_POINTS_HELPER
 #undef INTEGRATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     integrateOnIntegrationPoints(const Array<Real> & f, Array<Real> & intf,
                                  UInt nb_degree_of_freedom,
                                  const ElementType & type,
                                  const GhostType & ghost_type,
                                  const Array<UInt> & filter_elements) const {
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
     nb_element = filter_elements.size();
   UInt nb_quadrature_points = getNbIntegrationPoints(type);
 #ifndef AKANTU_NDEBUG
   //   std::stringstream sstr; sstr << ghost_type;
   //   AKANTU_DEBUG_ASSERT(sstr.str() == nablauq.getTag(),
   //                  "The vector " << nablauq.getID() << " is not taged " <<
   //                  ghost_type);
 
   AKANTU_DEBUG_ASSERT(f.size() == nb_element * nb_quadrature_points,
                       "The vector f(" << f.getID() << " size " << f.size()
                                       << ") has not the good size ("
                                       << nb_element << ").");
   AKANTU_DEBUG_ASSERT(f.getNbComponent() == nb_degree_of_freedom,
                       "The vector f("
                           << f.getID()
                           << ") has not the good number of component.");
   AKANTU_DEBUG_ASSERT(intf.getNbComponent() == nb_degree_of_freedom,
                       "The vector intf("
                           << intf.getID()
                           << ") has not the good number of component.");
 #endif
 
   intf.resize(nb_element * nb_quadrature_points);
   fe_engine::details::IntegrateOnIntegrationPointsHelper<kind>::call(
       integrator, f, intf, nb_degree_of_freedom, type, ghost_type,
       filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct InterpolateOnIntegrationPointsHelper {
       template <class S>
       static void call(const S &, const Array<Real> &, Array<Real> &,
                        const UInt, const ElementType &, const GhostType &,
                        const Array<UInt> &) {
         AKANTU_DEBUG_TO_IMPLEMENT();
       }
     };
 
 #define INTERPOLATE(type)                                                      \
   shape_functions.template interpolateOnIntegrationPoints<type>(               \
       u, uq, nb_degree_of_freedom, ghost_type, filter_elements);
 
 #define AKANTU_SPECIALIZE_INTERPOLATE_ON_INTEGRATION_POINTS_HELPER(kind)       \
   template <> struct InterpolateOnIntegrationPointsHelper<kind> {              \
     template <class S>                                                         \
     static void call(const S & shape_functions, const Array<Real> & u,         \
                      Array<Real> & uq, const UInt nb_degree_of_freedom,        \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<UInt> & filter_elements) {                    \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTERPOLATE, kind);                     \
     }                                                                          \
   };
     AKANTU_BOOST_ALL_KIND_LIST(
         AKANTU_SPECIALIZE_INTERPOLATE_ON_INTEGRATION_POINTS_HELPER,
         AKANTU_FE_ENGINE_LIST_INTERPOLATE_ON_INTEGRATION_POINTS)
 
 #undef AKANTU_SPECIALIZE_INTERPOLATE_ON_INTEGRATION_POINTS_HELPER
 #undef INTERPOLATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     interpolateOnIntegrationPoints(const Array<Real> & u, Array<Real> & uq,
                                    const UInt nb_degree_of_freedom,
                                    const ElementType & type,
                                    const GhostType & ghost_type,
                                    const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_points =
       shape_functions.getIntegrationPoints(type, ghost_type).cols();
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
     nb_element = filter_elements.size();
 #ifndef AKANTU_NDEBUG
 
   AKANTU_DEBUG_ASSERT(u.size() == mesh.getNbNodes(),
                       "The vector u(" << u.getID()
                                       << ") has not the good size.");
   AKANTU_DEBUG_ASSERT(u.getNbComponent() == nb_degree_of_freedom,
                       "The vector u("
                           << u.getID()
                           << ") has not the good number of component.");
   AKANTU_DEBUG_ASSERT(uq.getNbComponent() == nb_degree_of_freedom,
                       "The vector uq("
                           << uq.getID()
                           << ") has not the good number of component.");
 #endif
 
   uq.resize(nb_element * nb_points);
 
   fe_engine::details::InterpolateOnIntegrationPointsHelper<kind>::call(
       shape_functions, u, uq, nb_degree_of_freedom, type, ghost_type,
       filter_elements);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     interpolateOnIntegrationPoints(
         const Array<Real> & u, ElementTypeMapArray<Real> & uq,
         const ElementTypeMapArray<UInt> * filter_elements) const {
   AKANTU_DEBUG_IN();
 
   const Array<UInt> * filter = nullptr;
 
   for (auto ghost_type : ghost_types) {
     for (auto & type : uq.elementTypes(_all_dimensions, ghost_type, kind)) {
       UInt nb_quad_per_element = getNbIntegrationPoints(type, ghost_type);
 
       UInt nb_element = 0;
 
       if (filter_elements) {
         filter = &((*filter_elements)(type, ghost_type));
         nb_element = filter->size();
       } else {
         filter = &empty_filter;
         nb_element = mesh.getNbElement(type, ghost_type);
       }
 
       UInt nb_tot_quad = nb_quad_per_element * nb_element;
 
       Array<Real> & quad = uq(type, ghost_type);
       quad.resize(nb_tot_quad);
 
       interpolateOnIntegrationPoints(u, quad, quad.getNbComponent(), type,
                                      ghost_type, *filter);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeIntegrationPointsCoordinates(
         ElementTypeMapArray<Real> & quadrature_points_coordinates,
         const ElementTypeMapArray<UInt> * filter_elements) const {
 
   const Array<Real> & nodes_coordinates = mesh.getNodes();
 
   interpolateOnIntegrationPoints(
       nodes_coordinates, quadrature_points_coordinates, filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeIntegrationPointsCoordinates(
         Array<Real> & quadrature_points_coordinates, const ElementType & type,
         const GhostType & ghost_type,
         const Array<UInt> & filter_elements) const {
 
   const Array<Real> & nodes_coordinates = mesh.getNodes();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   interpolateOnIntegrationPoints(
       nodes_coordinates, quadrature_points_coordinates, spatial_dimension, type,
       ghost_type, filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     initElementalFieldInterpolationFromIntegrationPoints(
         const ElementTypeMapArray<Real> & interpolation_points_coordinates,
         ElementTypeMapArray<Real> & interpolation_points_coordinates_matrices,
         ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
         const ElementTypeMapArray<UInt> * element_filter) const {
 
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = this->mesh.getSpatialDimension();
 
   ElementTypeMapArray<Real> quadrature_points_coordinates(
       "quadrature_points_coordinates_for_interpolation", getID(),
       getMemoryID());
 
   quadrature_points_coordinates.initialize(*this,
                                            _nb_component = spatial_dimension);
 
   computeIntegrationPointsCoordinates(quadrature_points_coordinates,
                                       element_filter);
   shape_functions.initElementalFieldInterpolationFromIntegrationPoints(
       interpolation_points_coordinates,
       interpolation_points_coordinates_matrices,
       quad_points_coordinates_inv_matrices, quadrature_points_coordinates,
       element_filter);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     interpolateElementalFieldFromIntegrationPoints(
         const ElementTypeMapArray<Real> & field,
         const ElementTypeMapArray<Real> & interpolation_points_coordinates,
         ElementTypeMapArray<Real> & result, const GhostType ghost_type,
         const ElementTypeMapArray<UInt> * element_filter) const {
 
   ElementTypeMapArray<Real> interpolation_points_coordinates_matrices(
       "interpolation_points_coordinates_matrices", id, memory_id);
   ElementTypeMapArray<Real> quad_points_coordinates_inv_matrices(
       "quad_points_coordinates_inv_matrices", id, memory_id);
 
   initElementalFieldInterpolationFromIntegrationPoints(
       interpolation_points_coordinates,
       interpolation_points_coordinates_matrices,
       quad_points_coordinates_inv_matrices, element_filter);
 
   interpolateElementalFieldFromIntegrationPoints(
       field, interpolation_points_coordinates_matrices,
       quad_points_coordinates_inv_matrices, result, ghost_type, element_filter);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     interpolateElementalFieldFromIntegrationPoints(
         const ElementTypeMapArray<Real> & field,
         const ElementTypeMapArray<Real> &
             interpolation_points_coordinates_matrices,
         const ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
         ElementTypeMapArray<Real> & result, const GhostType ghost_type,
         const ElementTypeMapArray<UInt> * element_filter) const {
 
   shape_functions.interpolateElementalFieldFromIntegrationPoints(
       field, interpolation_points_coordinates_matrices,
       quad_points_coordinates_inv_matrices, result, ghost_type, element_filter);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct InterpolateHelper {
       template <class S>
       static void call(const S &, const Vector<Real> &, UInt,
                        const Matrix<Real> &, Vector<Real> &,
                        const ElementType &, const GhostType &) {
         AKANTU_DEBUG_TO_IMPLEMENT();
       }
     };
 
 #define INTERPOLATE(type)                                                      \
   shape_functions.template interpolate<type>(                                  \
       real_coords, element, nodal_values, interpolated, ghost_type);
 
 #define AKANTU_SPECIALIZE_INTERPOLATE_HELPER(kind)                             \
   template <> struct InterpolateHelper<kind> {                                 \
     template <class S>                                                         \
     static void call(const S & shape_functions,                                \
                      const Vector<Real> & real_coords, UInt element,           \
                      const Matrix<Real> & nodal_values,                        \
                      Vector<Real> & interpolated, const ElementType & type,    \
                      const GhostType & ghost_type) {                           \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTERPOLATE, kind);                     \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_INTERPOLATE_HELPER,
                                AKANTU_FE_ENGINE_LIST_INTERPOLATE)
 
 #undef AKANTU_SPECIALIZE_INTERPOLATE_HELPER
 #undef INTERPOLATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::interpolate(
     const Vector<Real> & real_coords, const Matrix<Real> & nodal_values,
     Vector<Real> & interpolated, const Element & element) const {
 
   AKANTU_DEBUG_IN();
 
   fe_engine::details::InterpolateHelper<kind>::call(
       shape_functions, real_coords, element.element, nodal_values, interpolated,
       element.type, element.ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeNormalsOnIntegrationPoints(const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   computeNormalsOnIntegrationPoints(mesh.getNodes(), ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeNormalsOnIntegrationPoints(const Array<Real> & field,
                                       const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   //  Real * coord = mesh.getNodes().storage();
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   // allocate the normal arrays
   for (auto & type : mesh.elementTypes(element_dimension, ghost_type, kind)) {
     UInt size = mesh.getNbElement(type, ghost_type);
     if (normals_on_integration_points.exists(type, ghost_type)) {
       normals_on_integration_points(type, ghost_type).resize(size);
     } else {
       normals_on_integration_points.alloc(size, spatial_dimension, type,
                                           ghost_type);
     }
   }
 
   // loop over the type to build the normals
   for (auto & type : mesh.elementTypes(element_dimension, ghost_type, kind)) {
     Array<Real> & normals_on_quad =
         normals_on_integration_points(type, ghost_type);
     computeNormalsOnIntegrationPoints(field, normals_on_quad, type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ComputeNormalsOnIntegrationPoints {
       template <template <ElementKind, class> class I,
                 template <ElementKind> class S, ElementKind k, class IOF>
       static void call(const FEEngineTemplate<I, S, k, IOF> &,
                        const Array<Real> &, Array<Real> &, const ElementType &,
                        const GhostType &) {
         AKANTU_DEBUG_TO_IMPLEMENT();
       }
     };
 
 #define COMPUTE_NORMALS_ON_INTEGRATION_POINTS(type)                            \
   fem.template computeNormalsOnIntegrationPoints<type>(field, normal,          \
                                                        ghost_type);
 
 #define AKANTU_SPECIALIZE_COMPUTE_NORMALS_ON_INTEGRATION_POINTS(kind)          \
   template <> struct ComputeNormalsOnIntegrationPoints<kind> {                 \
     template <template <ElementKind, class> class I,                           \
               template <ElementKind> class S, ElementKind k, class IOF>        \
     static void call(const FEEngineTemplate<I, S, k, IOF> & fem,               \
                      const Array<Real> & field, Array<Real> & normal,          \
                      const ElementType & type, const GhostType & ghost_type) { \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(COMPUTE_NORMALS_ON_INTEGRATION_POINTS,  \
                                        kind);                                  \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(
         AKANTU_SPECIALIZE_COMPUTE_NORMALS_ON_INTEGRATION_POINTS,
         AKANTU_FE_ENGINE_LIST_COMPUTE_NORMALS_ON_INTEGRATION_POINTS)
 
 #undef AKANTU_SPECIALIZE_COMPUTE_NORMALS_ON_INTEGRATION_POINTS
 #undef COMPUTE_NORMALS_ON_INTEGRATION_POINTS
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeNormalsOnIntegrationPoints(const Array<Real> & field,
                                       Array<Real> & normal,
                                       const ElementType & type,
                                       const GhostType & ghost_type) const {
   fe_engine::details::ComputeNormalsOnIntegrationPoints<kind>::call(
       *this, field, normal, type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeNormalsOnIntegrationPoints(const Array<Real> & field,
                                       Array<Real> & normal,
                                       const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   if(type == _point_1) {
     computeNormalsOnIntegrationPointsPoint1(field, normal, ghost_type);
     return;
   }
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_points = getNbIntegrationPoints(type, ghost_type);
 
   UInt nb_element = mesh.getConnectivity(type, ghost_type).size();
   normal.resize(nb_element * nb_points);
   Array<Real>::matrix_iterator normals_on_quad =
       normal.begin_reinterpret(spatial_dimension, nb_points, nb_element);
   Array<Real> f_el(0, spatial_dimension * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, field, f_el, type, ghost_type);
 
   const Matrix<Real> & quads =
       integrator.template getIntegrationPoints<type>(ghost_type);
 
   Array<Real>::matrix_iterator f_it =
       f_el.begin(spatial_dimension, nb_nodes_per_element);
 
   for (UInt elem = 0; elem < nb_element; ++elem) {
     ElementClass<type>::computeNormalsOnNaturalCoordinates(quads, *f_it,
                                                            *normals_on_quad);
     ++normals_on_quad;
     ++f_it;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 template <ElementKind kind> struct InverseMapHelper {
   template <class S>
   static void call(const S & /*shape_functions*/, const Vector<Real> & /*real_coords*/,
                    UInt /*element*/, const ElementType & /*type*/,
                    Vector<Real> & /*natural_coords*/,
                    const GhostType & /*ghost_type*/) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 };
 
 #define INVERSE_MAP(type)                                                      \
   shape_functions.template inverseMap<type>(real_coords, element,              \
                                             natural_coords, ghost_type);
 
 #define AKANTU_SPECIALIZE_INVERSE_MAP_HELPER(kind)                             \
   template <> struct InverseMapHelper<kind> {                                  \
     template <class S>                                                         \
     static void call(const S & shape_functions,                                \
                      const Vector<Real> & real_coords, UInt element,           \
                      const ElementType & type, Vector<Real> & natural_coords,  \
                      const GhostType & ghost_type) {                           \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INVERSE_MAP, kind);                     \
     }                                                                          \
   };
 
 AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_INVERSE_MAP_HELPER,
                            AKANTU_FE_ENGINE_LIST_INVERSE_MAP)
 
 #undef AKANTU_SPECIALIZE_INVERSE_MAP_HELPER
 #undef INVERSE_MAP
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::inverseMap(
     const Vector<Real> & real_coords, UInt element, const ElementType & type,
     Vector<Real> & natural_coords, const GhostType & ghost_type) const {
 
   AKANTU_DEBUG_IN();
 
   InverseMapHelper<kind>::call(shape_functions, real_coords, element, type,
                                natural_coords, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ContainsHelper {
       template <class S>
       static void call(const S &, const Vector<Real> &, UInt,
                        const ElementType &, const GhostType &) {
         AKANTU_DEBUG_TO_IMPLEMENT();
       }
     };
 
 #define CONTAINS(type)                                                         \
   contain = shape_functions.template contains<type>(real_coords, element,      \
                                                     ghost_type);
 
 #define AKANTU_SPECIALIZE_CONTAINS_HELPER(kind)                                \
   template <> struct ContainsHelper<kind> {                                    \
     template <template <ElementKind> class S, ElementKind k>                   \
     static bool call(const S<k> & shape_functions,                             \
                      const Vector<Real> & real_coords, UInt element,           \
                      const ElementType & type, const GhostType & ghost_type) { \
       bool contain = false;                                                    \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(CONTAINS, kind);                        \
       return contain;                                                          \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_CONTAINS_HELPER,
                                AKANTU_FE_ENGINE_LIST_CONTAINS)
 
 #undef AKANTU_SPECIALIZE_CONTAINS_HELPER
 #undef CONTAINS
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline bool FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::contains(
     const Vector<Real> & real_coords, UInt element, const ElementType & type,
     const GhostType & ghost_type) const {
   return fe_engine::details::ContainsHelper<kind>::call(
       shape_functions, real_coords, element, type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ComputeShapesHelper {
       template <class S>
       static void call(const S &, const Vector<Real> &, UInt, const ElementType,
                        Vector<Real> &, const GhostType &) {
         AKANTU_DEBUG_TO_IMPLEMENT();
       }
     };
 
 #define COMPUTE_SHAPES(type)                                                   \
   shape_functions.template computeShapes<type>(real_coords, element, shapes,   \
                                                ghost_type);
 
 #define AKANTU_SPECIALIZE_COMPUTE_SHAPES_HELPER(kind)                          \
   template <> struct ComputeShapesHelper<kind> {                               \
     template <class S>                                                         \
     static void call(const S & shape_functions,                                \
                      const Vector<Real> & real_coords, UInt element,           \
                      const ElementType type, Vector<Real> & shapes,            \
                      const GhostType & ghost_type) {                           \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(COMPUTE_SHAPES, kind);                  \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_COMPUTE_SHAPES_HELPER,
                                AKANTU_FE_ENGINE_LIST_COMPUTE_SHAPES)
 
 #undef AKANTU_SPECIALIZE_COMPUTE_SHAPES_HELPER
 #undef COMPUTE_SHAPES
   } // namespace details
 } // namespace fe_engine
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::computeShapes(
     const Vector<Real> & real_coords, UInt element, const ElementType & type,
     Vector<Real> & shapes, const GhostType & ghost_type) const {
 
   AKANTU_DEBUG_IN();
 
   fe_engine::details::ComputeShapesHelper<kind>::call(
       shape_functions, real_coords, element, type, shapes, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ComputeShapeDerivativesHelper {
       template <class S>
       static void call(__attribute__((unused)) const S & shape_functions,
                        __attribute__((unused)) const Vector<Real> & real_coords,
                        __attribute__((unused)) UInt element,
                        __attribute__((unused)) const ElementType type,
                        __attribute__((unused)) Matrix<Real> & shape_derivatives,
                        __attribute__((unused)) const GhostType & ghost_type) {
         AKANTU_DEBUG_TO_IMPLEMENT();
       }
     };
 
 #define COMPUTE_SHAPE_DERIVATIVES(type)                                        \
   Matrix<Real> coords_mat(real_coords.storage(), shape_derivatives.rows(), 1); \
   Tensor3<Real> shapesd_tensor(shape_derivatives.storage(),                    \
                                shape_derivatives.rows(),                       \
                                shape_derivatives.cols(), 1);                   \
   shape_functions.template computeShapeDerivatives<type>(                      \
       coords_mat, element, shapesd_tensor, ghost_type);
 
 #define AKANTU_SPECIALIZE_COMPUTE_SHAPE_DERIVATIVES_HELPER(kind)               \
   template <> struct ComputeShapeDerivativesHelper<kind> {                     \
     template <class S>                                                         \
     static void call(const S & shape_functions,                                \
                      const Vector<Real> & real_coords, UInt element,           \
                      const ElementType type, Matrix<Real> & shape_derivatives, \
                      const GhostType & ghost_type) {                           \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(COMPUTE_SHAPE_DERIVATIVES, kind);       \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(
         AKANTU_SPECIALIZE_COMPUTE_SHAPE_DERIVATIVES_HELPER,
         AKANTU_FE_ENGINE_LIST_COMPUTE_SHAPES_DERIVATIVES)
 
 #undef AKANTU_SPECIALIZE_COMPUTE_SHAPE_DERIVATIVES_HELPER
 #undef COMPUTE_SHAPE_DERIVATIVES
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::computeShapeDerivatives(
     const Vector<Real> & real_coords, UInt element, const ElementType & type,
     Matrix<Real> & shape_derivatives, const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   fe_engine::details::ComputeShapeDerivativesHelper<kind>::call(
       shape_functions, real_coords, element, type, shape_derivatives,
       ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct GetNbIntegrationPointsHelper {};
 
 #define GET_NB_INTEGRATION_POINTS(type)                                        \
   nb_quad_points = integrator.template getNbIntegrationPoints<type>(ghost_type);
 
 #define AKANTU_SPECIALIZE_GET_NB_INTEGRATION_POINTS_HELPER(kind)               \
   template <> struct GetNbIntegrationPointsHelper<kind> {                      \
     template <template <ElementKind, class> class I, ElementKind k, class IOF> \
     static UInt call(const I<k, IOF> & integrator, const ElementType type,     \
                      const GhostType & ghost_type) {                           \
       UInt nb_quad_points = 0;                                                 \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(GET_NB_INTEGRATION_POINTS, kind);       \
       return nb_quad_points;                                                   \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_GET_NB_INTEGRATION_POINTS_HELPER)
 
 #undef AKANTU_SPECIALIZE_GET_NB_INTEGRATION_POINTS_HELPER
 #undef GET_NB_INTEGRATION
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline UInt
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::getNbIntegrationPoints(
     const ElementType & type, const GhostType & ghost_type) const {
   return fe_engine::details::GetNbIntegrationPointsHelper<kind>::call(
       integrator, type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct GetShapesHelper {};
 
 #define GET_SHAPES(type) ret = &(shape_functions.getShapes(type, ghost_type));
 
 #define AKANTU_SPECIALIZE_GET_SHAPES_HELPER(kind)                              \
   template <> struct GetShapesHelper<kind> {                                   \
     template <class S>                                                         \
     static const Array<Real> & call(const S & shape_functions,                 \
                                     const ElementType type,                    \
                                     const GhostType & ghost_type) {            \
       const Array<Real> * ret = NULL;                                          \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(GET_SHAPES, kind);                      \
       return *ret;                                                             \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_GET_SHAPES_HELPER)
 
 #undef AKANTU_SPECIALIZE_GET_SHAPES_HELPER
 #undef GET_SHAPES
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline const Array<Real> &
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::getShapes(
     const ElementType & type, const GhostType & ghost_type,
     __attribute__((unused)) UInt id) const {
   return fe_engine::details::GetShapesHelper<kind>::call(shape_functions, type,
                                                          ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct GetShapesDerivativesHelper {
       template <template <ElementKind> class S, ElementKind k>
       static const Array<Real> & call(const S<k> &, const ElementType &,
                                       const GhostType &, UInt) {
         AKANTU_DEBUG_TO_IMPLEMENT();
       }
     };
 
 #define GET_SHAPES_DERIVATIVES(type)                                           \
   ret = &(shape_functions.getShapesDerivatives(type, ghost_type));
 
 #define AKANTU_SPECIALIZE_GET_SHAPES_DERIVATIVES_HELPER(kind)                  \
   template <> struct GetShapesDerivativesHelper<kind> {                        \
     template <template <ElementKind> class S, ElementKind k>                   \
     static const Array<Real> &                                                 \
     call(const S<k> & shape_functions, const ElementType type,                 \
          const GhostType & ghost_type, __attribute__((unused)) UInt id) {      \
       const Array<Real> * ret = NULL;                                          \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(GET_SHAPES_DERIVATIVES, kind);          \
       return *ret;                                                             \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_GET_SHAPES_DERIVATIVES_HELPER,
                                AKANTU_FE_ENGINE_LIST_GET_SHAPES_DERIVATIVES)
 
 #undef AKANTU_SPECIALIZE_GET_SHAPE_DERIVATIVES_HELPER
 #undef GET_SHAPES_DERIVATIVES
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline const Array<Real> &
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::getShapesDerivatives(
     const ElementType & type, const GhostType & ghost_type,
     __attribute__((unused)) UInt id) const {
   return fe_engine::details::GetShapesDerivativesHelper<kind>::call(
       shape_functions, type, ghost_type, id);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct GetIntegrationPointsHelper {};
 
 #define GET_INTEGRATION_POINTS(type)                                           \
   ret = &(integrator.template getIntegrationPoints<type>(ghost_type));
 
 #define AKANTU_SPECIALIZE_GET_INTEGRATION_POINTS_HELPER(kind)                  \
   template <> struct GetIntegrationPointsHelper<kind> {                        \
     template <template <ElementKind, class> class I, ElementKind k, class IOF> \
     static const Matrix<Real> & call(const I<k, IOF> & integrator,             \
                                      const ElementType type,                   \
                                      const GhostType & ghost_type) {           \
       const Matrix<Real> * ret = NULL;                                         \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(GET_INTEGRATION_POINTS, kind);          \
       return *ret;                                                             \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_GET_INTEGRATION_POINTS_HELPER)
 
 #undef AKANTU_SPECIALIZE_GET_INTEGRATION_POINTS_HELPER
 #undef GET_INTEGRATION_POINTS
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline const Matrix<Real> &
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::getIntegrationPoints(
     const ElementType & type, const GhostType & ghost_type) const {
   return fe_engine::details::GetIntegrationPointsHelper<kind>::call(
       integrator, type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::printself(
     std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "FEEngineTemplate [" << std::endl;
   stream << space << " + parent [" << std::endl;
   FEEngine::printself(stream, indent + 3);
   stream << space << "   ]" << std::endl;
   stream << space << " + shape functions [" << std::endl;
   shape_functions.printself(stream, indent + 3);
   stream << space << "   ]" << std::endl;
   stream << space << " + integrator [" << std::endl;
   integrator.printself(stream, indent + 3);
   stream << space << "   ]" << std::endl;
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::onElementsAdded(
     const Array<Element> & new_elements, const NewElementsEvent &) {
   integrator.onElementsAdded(new_elements);
   shape_functions.onElementsAdded(new_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::onElementsRemoved(
     const Array<Element> &, const ElementTypeMapArray<UInt> &,
     const RemovedElementsEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::onElementsChanged(
     const Array<Element> &, const Array<Element> &,
     const ElementTypeMapArray<UInt> &, const ChangedElementsEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeNormalsOnIntegrationPointsPoint1(
         const Array<Real> &, Array<Real> & normal,
         const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(mesh.getSpatialDimension() == 1,
                       "Mesh dimension must be 1 to compute normals on points!");
   const ElementType type = _point_1;
   UInt spatial_dimension = mesh.getSpatialDimension();
   // UInt nb_nodes_per_element  = Mesh::getNbNodesPerElement(type);
   UInt nb_points = getNbIntegrationPoints(type, ghost_type);
 
   UInt nb_element = mesh.getConnectivity(type, ghost_type).size();
   normal.resize(nb_element * nb_points);
   Array<Real>::matrix_iterator normals_on_quad =
       normal.begin_reinterpret(spatial_dimension, nb_points, nb_element);
   const Array<std::vector<Element>> & segments =
       mesh.getElementToSubelement(type, ghost_type);
   const Array<Real> & coords = mesh.getNodes();
 
   const Mesh * mesh_segment;
   if (mesh.isMeshFacets())
     mesh_segment = &(mesh.getMeshParent());
   else
     mesh_segment = &mesh;
 
   for (UInt elem = 0; elem < nb_element; ++elem) {
     UInt nb_segment = segments(elem).size();
 
     AKANTU_DEBUG_ASSERT(
         nb_segment > 0,
         "Impossible to compute a normal on a point connected to 0 segments");
 
     Real normal_value = 1;
     if (nb_segment == 1) {
       const Element & segment = segments(elem)[0];
       const Array<UInt> & segment_connectivity =
           mesh_segment->getConnectivity(segment.type, segment.ghost_type);
       // const Vector<UInt> & segment_points =
       // segment_connectivity.begin(Mesh::getNbNodesPerElement(segment.type))[segment.element];
       Real difference;
       if (segment_connectivity(0) == elem) {
         difference = coords(elem) - coords(segment_connectivity(1));
       } else {
         difference = coords(elem) - coords(segment_connectivity(0));
       }
       normal_value = difference / std::abs(difference);
     }
 
     for (UInt n(0); n < nb_points; ++n) {
       (*normals_on_quad)(0, n) = normal_value;
     }
     ++normals_on_quad;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/src/fe_engine/gauss_integration_tmpl.hh b/src/fe_engine/gauss_integration_tmpl.hh
index 1c353f38b..56f649e20 100644
--- a/src/fe_engine/gauss_integration_tmpl.hh
+++ b/src/fe_engine/gauss_integration_tmpl.hh
@@ -1,271 +1,271 @@
 /**
  * @file   gauss_integration_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Tue May 10 10:48:21 2016
  *
  * @brief  implementation of the gauss integration helpers
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_GAUSS_INTEGRATION_TMPL_HH__
 #define __AKANTU_GAUSS_INTEGRATION_TMPL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* GaussIntegrationElement                                                    */
 /* -------------------------------------------------------------------------- */
 namespace _aka_gauss_helpers {
 template <GaussIntegrationType type, UInt n> struct GaussIntegrationNbPoints {
 
 };
 
 template <UInt n> struct GaussIntegrationNbPoints<_git_not_defined, n> {
   static const UInt nb_points = 0;
 };
 
 template <UInt n> struct GaussIntegrationNbPoints<_git_point, n> {
   static const UInt nb_points = 1;
 };
 
 template <UInt n> struct GaussIntegrationNbPoints<_git_segment, n> {
   static const UInt nb_points = (n + 1) / 2 + ((n + 1) % 2 ? 1 : 0);
 };
 
 #define DECLARE_GAUSS_NB_POINTS(type, order, points)                           \
   template <> struct GaussIntegrationNbPoints<type, order> {                   \
     static const UInt nb_points = points;                                      \
   }
 
 #define DECLARE_GAUSS_NB_POINTS_PENT(type, order, xo, yo)                      \
   template <> struct GaussIntegrationNbPoints<type, order> {                   \
     static const UInt x_order = xo;                                            \
     static const UInt yz_order = yo;                                           \
     static const UInt nb_points = 1;                                           \
   }
 
 DECLARE_GAUSS_NB_POINTS(_git_triangle, 1, 1);
 DECLARE_GAUSS_NB_POINTS(_git_triangle, 2, 3);
 DECLARE_GAUSS_NB_POINTS(_git_triangle, 3, 4);
 DECLARE_GAUSS_NB_POINTS(_git_triangle, 4, 6);
 DECLARE_GAUSS_NB_POINTS(_git_triangle, 5, 7);
 DECLARE_GAUSS_NB_POINTS(_git_tetrahedron, 1, 1);
 DECLARE_GAUSS_NB_POINTS(_git_tetrahedron, 2, 4);
 DECLARE_GAUSS_NB_POINTS(_git_tetrahedron, 3, 5);
 DECLARE_GAUSS_NB_POINTS(_git_tetrahedron, 4, 15);
 DECLARE_GAUSS_NB_POINTS(_git_tetrahedron, 5, 15);
 DECLARE_GAUSS_NB_POINTS_PENT(_git_pentahedron, 1, 3,
                              2); // order 3 in x, order 2 in y and z
 DECLARE_GAUSS_NB_POINTS_PENT(_git_pentahedron, 2, 3,
                              2); // order 3 in x, order 2 in y and z
 DECLARE_GAUSS_NB_POINTS_PENT(_git_pentahedron, 3, 3,
                              3); // order 3 in x, order 3 in y and z
 DECLARE_GAUSS_NB_POINTS_PENT(_git_pentahedron, 4, 5,
                              5); // order 5 in x, order 5 in y and z
 DECLARE_GAUSS_NB_POINTS_PENT(_git_pentahedron, 5, 5,
                              5); // order 5 in x, order 5 in y and z
 
 template <GaussIntegrationType type, UInt n, UInt on = n,
           bool end_recurse = false>
 struct GaussIntegrationNbPointsHelper {
   static const UInt pnp = GaussIntegrationNbPoints<type, n>::nb_points;
   static const UInt order = n;
   static const UInt nb_points = pnp;
 };
 
 template <GaussIntegrationType type, UInt n, UInt on>
 struct GaussIntegrationNbPointsHelper<type, n, on, true> {
   static const UInt nb_points = 0;
 };
 
 /* ------------------------------------------------------------------------ */
 /* Generic helper                                                           */
 /* ------------------------------------------------------------------------ */
 template <GaussIntegrationType type, UInt dimension, UInt n>
 struct GaussIntegrationTypeDataHelper {
   typedef GaussIntegrationNbPoints<type, n> git_np;
   typedef GaussIntegrationTypeData<type, git_np::nb_points> git_data;
 
   static UInt getNbQuadraturePoints() { return git_np::nb_points; }
 
   static const Matrix<Real> getQuadraturePoints() {
     return Matrix<Real>(git_data::quad_positions, dimension, git_np::nb_points);
   }
 
   static const Vector<Real> getWeights() {
     return Vector<Real>(git_data::quad_weights, git_np::nb_points);
   }
 };
 
 /* ------------------------------------------------------------------------ */
 /* helper for _segment _quadrangle _hexahedron                              */
 /* ------------------------------------------------------------------------ */
 template <UInt dimension, UInt dp>
 struct GaussIntegrationTypeDataHelper<_git_segment, dimension, dp> {
   typedef GaussIntegrationNbPoints<_git_segment, dp> git_np;
   typedef GaussIntegrationTypeData<_git_segment, git_np::nb_points> git_data;
 
   static UInt getNbQuadraturePoints() {
     return Math::pow<dimension>(git_np::nb_points);
   }
 
   static const Matrix<Real> getQuadraturePoints() {
     UInt tot_nquad = getNbQuadraturePoints();
     UInt nquad = git_np::nb_points;
 
     Matrix<Real> quads(dimension, tot_nquad);
     Vector<Real> pos(git_data::quad_positions, nquad);
 
     UInt offset = 1;
     for (UInt d = 0; d < dimension; ++d) {
       for (UInt n = 0, q = 0; n < tot_nquad; ++n, q += offset) {
         UInt rq = q % tot_nquad + q / tot_nquad;
         quads(d, rq) = pos(n % nquad);
       }
       offset *= nquad;
     }
     return quads;
   }
 
   static const Vector<Real> getWeights() {
     UInt tot_nquad = getNbQuadraturePoints();
     UInt nquad = git_np::nb_points;
 
     Vector<Real> quads_weights(tot_nquad, 1.);
     Vector<Real> weights(git_data::quad_weights, nquad);
 
     UInt offset = 1;
     for (UInt d = 0; d < dimension; ++d) {
       for (UInt n = 0, q = 0; n < tot_nquad; ++n, q += offset) {
         UInt rq = q % tot_nquad + q / tot_nquad;
         quads_weights(rq) *= weights(n % nquad);
       }
       offset *= nquad;
     }
     return quads_weights;
   }
 };
 
 /* ------------------------------------------------------------------------ */
 /* helper for _pentahedron                                                  */
 /* ------------------------------------------------------------------------ */
 template <UInt dimension, UInt dp>
 struct GaussIntegrationTypeDataHelper<_git_pentahedron, dimension, dp> {
   typedef GaussIntegrationNbPoints<_git_pentahedron, dp> git_info;
   typedef GaussIntegrationNbPoints<_git_segment, git_info::x_order> git_np_seg;
   typedef GaussIntegrationNbPoints<_git_triangle, git_info::yz_order> git_np_tri;
 
   typedef GaussIntegrationTypeData<_git_segment, git_np_seg::nb_points>
       git_data_seg;
   typedef GaussIntegrationTypeData<_git_triangle, git_np_tri::nb_points>
       git_data_tri;
 
   static UInt getNbQuadraturePoints() {
     return git_np_seg::nb_points * git_np_tri::nb_points;
   }
 
   static const Matrix<Real> getQuadraturePoints() {
     UInt tot_nquad = getNbQuadraturePoints();
     UInt nquad_seg = git_np_seg::nb_points;
     UInt nquad_tri = git_np_tri::nb_points;
 
     Matrix<Real> quads(dimension, tot_nquad);
     Matrix<Real> pos_seg_w(git_data_seg::quad_positions, 1, nquad_seg);
     Matrix<Real> pos_tri_w(git_data_tri::quad_positions, 2, nquad_tri);
 
     for (UInt ns = 0, q = 0; ns < nquad_seg; ++ns) {
       Vector<Real> pos_seg = pos_seg_w(ns);
       for (UInt nt = 0; nt < nquad_tri; ++nt, ++q) {
         Vector<Real> pos_tri = pos_tri_w(nt);
         Vector<Real> quad = quads(q);
         quad(_x) = pos_seg(_x);
         quad(_y) = pos_tri(_x);
         quad(_z) = pos_tri(_y);
       }
     }
     return quads;
   }
 
   static const Vector<Real> getWeights() {
     UInt tot_nquad = getNbQuadraturePoints();
     UInt nquad_seg = git_np_seg::nb_points;
     UInt nquad_tri = git_np_tri::nb_points;
 
     Vector<Real> quads_weights(tot_nquad);
 
     Vector<Real> weight_seg(git_data_seg::quad_weights, nquad_seg);
     Vector<Real> weight_tri(git_data_tri::quad_weights, nquad_tri);
 
     for (UInt ns = 0, q = 0; ns < nquad_seg; ++ns) {
       for (UInt nt = 0; nt < nquad_tri; ++nt, ++q) {
         quads_weights(q) = weight_seg(ns) * weight_tri(nt);
       }
     }
     return quads_weights;
   }
 };
 }
 
 template <ElementType element_type, UInt n>
 const Matrix<Real>
 GaussIntegrationElement<element_type, n>::getQuadraturePoints() {
   const InterpolationType itp_type =
       ElementClassProperty<element_type>::interpolation_type;
-  typedef InterpolationProperty<itp_type> interpolation_property;
+  using interpolation_property = InterpolationProperty<itp_type>;
   typedef _aka_gauss_helpers::GaussIntegrationTypeDataHelper<
       ElementClassProperty<element_type>::gauss_integration_type,
       interpolation_property::natural_space_dimension, n> data_helper;
   Matrix<Real> tmp(data_helper::getQuadraturePoints());
   return tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType element_type, UInt n>
 const Vector<Real> GaussIntegrationElement<element_type, n>::getWeights() {
   const InterpolationType itp_type =
       ElementClassProperty<element_type>::interpolation_type;
-  typedef InterpolationProperty<itp_type> interpolation_property;
+  using interpolation_property = InterpolationProperty<itp_type>;
   typedef _aka_gauss_helpers::GaussIntegrationTypeDataHelper<
       ElementClassProperty<element_type>::gauss_integration_type,
       interpolation_property::natural_space_dimension, n> data_helper;
   Vector<Real> tmp(data_helper::getWeights());
   return tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType element_type, UInt n>
 UInt GaussIntegrationElement<element_type, n>::getNbQuadraturePoints() {
   const InterpolationType itp_type =
       ElementClassProperty<element_type>::interpolation_type;
-  typedef InterpolationProperty<itp_type> interpolation_property;
+  using interpolation_property = InterpolationProperty<itp_type>;
   typedef _aka_gauss_helpers::GaussIntegrationTypeDataHelper<
       ElementClassProperty<element_type>::gauss_integration_type,
       interpolation_property::natural_space_dimension, n> data_helper;
   return data_helper::getNbQuadraturePoints();
 }
 
 } // akantu
 
 #endif /* __AKANTU_GAUSS_INTEGRATION_TMPL_HH__ */
diff --git a/src/fe_engine/integration_point.hh b/src/fe_engine/integration_point.hh
index 2e6314ce7..596aca80f 100644
--- a/src/fe_engine/integration_point.hh
+++ b/src/fe_engine/integration_point.hh
@@ -1,168 +1,168 @@
 /**
  * @file   integration_point.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Jun 17 2015
  * @date last modification: Sun Nov 15 2015
  *
  * @brief  definition of the class IntegrationPoint
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "aka_types.hh"
 #include "element.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_QUADRATURE_POINT_H
 #define AKANTU_QUADRATURE_POINT_H
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 class IntegrationPoint;
 extern const IntegrationPoint IntegrationPointNull;
 /* -------------------------------------------------------------------------- */
 
 class IntegrationPoint : public Element {
 
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
-  typedef Vector<Real> position_type;
+  using position_type = Vector<Real>;
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
   IntegrationPoint(const Element & element, UInt num_point = 0,
                    UInt nb_quad_per_element = 0)
       : Element(element), num_point(num_point),
         global_num(element.element * nb_quad_per_element + num_point),
         position(nullptr, 0){};
 
   IntegrationPoint(ElementType type = _not_defined, UInt element = 0,
                    UInt num_point = 0, GhostType ghost_type = _not_ghost)
-      : Element{type, element, ghost_type}, num_point(num_point), global_num(0),
+      : Element{type, element, ghost_type}, num_point(num_point),
         position(nullptr, 0){};
 
   IntegrationPoint(UInt element, UInt num_point, UInt global_num,
                    const position_type & position, ElementType type,
                    GhostType ghost_type = _not_ghost)
       : Element{type, element, ghost_type}, num_point(num_point),
         global_num(global_num), position(nullptr, 0) {
     this->position.shallowCopy(position);
   };
 
   IntegrationPoint(const IntegrationPoint & quad)
       : Element(quad), num_point(quad.num_point), global_num(quad.global_num),
         position(nullptr, 0) {
     position.shallowCopy(quad.position);
   };
 
   virtual ~IntegrationPoint() = default;
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 
   inline bool operator==(const IntegrationPoint & quad) const {
     return Element::operator==(quad) && this->num_point == quad.num_point;
   }
 
   inline bool operator!=(const IntegrationPoint & quad) const {
     return Element::operator!=(quad) ||  (num_point != quad.num_point) || (global_num != quad.global_num);
   }
 
   bool operator<(const IntegrationPoint & rhs) const {
     bool res = Element::operator<(rhs) ||
                (Element::operator==(rhs) && this->num_point < rhs.num_point);
     return res;
   }
 
   inline IntegrationPoint & operator=(const IntegrationPoint & q) {
     if (this != &q) {
       element = q.element;
       type = q.type;
       ghost_type = q.ghost_type;
       num_point = q.num_point;
       global_num = q.global_num;
       position.shallowCopy(q.position);
     }
 
     return *this;
   }
 
   /// get the position of the integration point
   AKANTU_GET_MACRO(Position, position, const position_type &);
 
   /// set the position of the integration point
   void setPosition(const position_type & position) {
     this->position.shallowCopy(position);
   }
 
   /// deep copy of the position of the integration point
   void copyPosition(const position_type & position) {
     this->position.deepCopy(position);
   }
 
   /// function to print the containt of the class
   virtual void printself(std::ostream & stream, int indent = 0) const {
     std::string space;
     for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
       ;
     stream << space << "IntegrationPoint [";
     stream << *static_cast<const Element *>(this);
     stream << ", " << num_point << "(" << global_num << ")"
            << "]";
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 
 public:
   /// number of quadrature point in the element
   UInt num_point;
   /// global number of the quadrature point
-  UInt global_num;
+  UInt global_num{0};
   // TODO might be temporary: however this class should be tought maybe...
   std::string material_id;
 
 private:
   /// position of the quadrature point
   position_type position;
 };
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream,
                                  const IntegrationPoint & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // akantu
 
 #endif /* AKANTU_QUADRATURE_POINT_H */
diff --git a/src/fe_engine/integrator.hh b/src/fe_engine/integrator.hh
index 5df11d185..4c72949c5 100644
--- a/src/fe_engine/integrator.hh
+++ b/src/fe_engine/integrator.hh
@@ -1,137 +1,137 @@
 /**
  * @file   integrator.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Oct 22 2015
  *
  * @brief  interface for integrator classes
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_INTEGRATOR_HH__
 #define __AKANTU_INTEGRATOR_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "aka_memory.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
 class Integrator : protected Memory {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   Integrator(const Mesh & mesh, const ID & id = "integrator",
              const MemoryID & memory_id = 0)
       : Memory(id, memory_id), mesh(mesh),
         jacobians("jacobians", id, memory_id) {
     AKANTU_DEBUG_IN();
 
     AKANTU_DEBUG_OUT();
   };
 
-  ~Integrator() override{};
+  ~Integrator() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// empty method
   template <ElementType type>
   inline void precomputeJacobiansOnQuadraturePoints(__attribute__((unused))
                                                     GhostType ghost_type) {}
 
   /// empty method
   void integrateOnElement(__attribute__((unused)) const Array<Real> & f,
                           __attribute__((unused)) Real * intf,
                           __attribute__((unused)) UInt nb_degree_of_freedom,
                           __attribute__((unused)) const Element & elem,
                           __attribute__((unused))
                           GhostType ghost_type) const {};
 
   /// function to print the contain of the class
   virtual void printself(std::ostream & stream, int indent = 0) const {
     std::string space;
     for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
       ;
     stream << space << "Integrator [" << std::endl;
     jacobians.printself(stream, indent + 1);
     stream << space << "]" << std::endl;
   };
 
   /* ------------------------------------------------------------------------ */
 public:
   virtual void onElementsAdded(const Array<Element> &) {}
   virtual void onElementsRemoved(const Array<Element> &,
                                  const ElementTypeMapArray<UInt> & new_numbering) {
     jacobians.onElementsRemoved(new_numbering);
   }
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// access to the jacobians
   Array<Real> & getJacobians(const ElementType & type,
                              const GhostType & ghost_type = _not_ghost) {
     return jacobians(type, ghost_type);
   };
 
   /// access to the jacobians const
   const Array<Real> &
   getJacobians(const ElementType & type,
                const GhostType & ghost_type = _not_ghost) const {
     return jacobians(type, ghost_type);
   };
 
   AKANTU_GET_MACRO(Jacobians, jacobians, const ElementTypeMapArray<Real> &);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// mesh associated to the integrator
   const Mesh & mesh;
 
   /// jacobians for all elements
   ElementTypeMapArray<Real> jacobians;
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 //#include "integrator_inline_impl.cc"
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream,
                                  const Integrator & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_INTEGRATOR_HH__ */
diff --git a/src/fe_engine/integrator_gauss.hh b/src/fe_engine/integrator_gauss.hh
index b6f09fa1e..792758e0a 100644
--- a/src/fe_engine/integrator_gauss.hh
+++ b/src/fe_engine/integrator_gauss.hh
@@ -1,199 +1,199 @@
 /**
  * @file   integrator_gauss.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Oct 22 2015
  *
  * @brief  Gauss integration facilities
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "integrator.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_INTEGRATOR_GAUSS_HH__
 #define __AKANTU_INTEGRATOR_GAUSS_HH__
 
 namespace akantu {
 namespace integrator {
   namespace details {
     template <ElementKind> struct GaussIntegratorComputeJacobiansHelper;
   } // namespace details
 } // namespace fe_engine
 
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 class IntegratorGauss : public Integrator {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   IntegratorGauss(const Mesh & mesh, const ID & id = "integrator_gauss",
                   const MemoryID & memory_id = 0);
 
-  ~IntegratorGauss() override{};
+  ~IntegratorGauss() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   void initIntegrator(const Array<Real> & nodes, const ElementType & type,
                       const GhostType & ghost_type);
 
   template <ElementType type>
   inline void initIntegrator(const Array<Real> & nodes,
                              const GhostType & ghost_type);
 
   /// integrate f on the element "elem" of type "type"
   template <ElementType type>
   inline void integrateOnElement(const Array<Real> & f, Real * intf,
                                  UInt nb_degree_of_freedom, const UInt elem,
                                  const GhostType & ghost_type) const;
 
   /// integrate f for all elements of type "type"
   template <ElementType type>
   void integrate(const Array<Real> & in_f, Array<Real> & intf,
                  UInt nb_degree_of_freedom, const GhostType & ghost_type,
                  const Array<UInt> & filter_elements) const;
 
   /// integrate scalar field in_f
   template <ElementType type, UInt polynomial_degree>
   Real integrate(const Array<Real> & in_f,
                  const GhostType & ghost_type = _not_ghost) const;
 
   /// integrate partially around a quadrature point (@f$ intf_q = f_q * J_q *
   /// w_q @f$)
   template <ElementType type>
   Real integrate(const Vector<Real> & in_f, UInt index,
                  const GhostType & ghost_type) const;
 
   /// integrate scalar field in_f
   template <ElementType type>
   Real integrate(const Array<Real> & in_f, const GhostType & ghost_type,
                  const Array<UInt> & filter_elements) const;
 
   /// integrate a field without using the pre-computed values
   template <ElementType type, UInt polynomial_degree>
   void integrate(const Array<Real> & in_f, Array<Real> & intf,
                  UInt nb_degree_of_freedom, const GhostType & ghost_type) const;
 
   /// integrate partially around a quadrature point (@f$ intf_q = f_q * J_q *
   /// w_q @f$)
   template <ElementType type>
   void integrateOnIntegrationPoints(const Array<Real> & in_f,
                                     Array<Real> & intf,
                                     UInt nb_degree_of_freedom,
                                     const GhostType & ghost_type,
                                     const Array<UInt> & filter_elements) const;
 
   /// return a matrix with quadrature points natural coordinates
   template <ElementType type>
   const Matrix<Real> & getIntegrationPoints(const GhostType & ghost_type) const;
 
   /// return number of quadrature points
   template <ElementType type>
   UInt getNbIntegrationPoints(const GhostType & ghost_type) const;
 
   template <ElementType type, UInt n> Matrix<Real> getIntegrationPoints() const;
   template <ElementType type, UInt n>
   Vector<Real> getIntegrationWeights() const;
 
 protected:
   friend struct integrator::details::GaussIntegratorComputeJacobiansHelper<kind>;
 
   template <ElementType type>
   void computeJacobiansOnIntegrationPoints(
       const Array<Real> & nodes, const Matrix<Real> & quad_points,
       Array<Real> & jacobians, const GhostType & ghost_type,
       const Array<UInt> & filter_elements = empty_filter) const;
 
   void computeJacobiansOnIntegrationPoints(
       const Array<Real> & nodes, const Matrix<Real> & quad_points,
       Array<Real> & jacobians, const ElementType & type,
       const GhostType & ghost_type,
       const Array<UInt> & filter_elements = empty_filter) const;
 
   /// precompute jacobians on elements of type "type"
   template <ElementType type>
   void precomputeJacobiansOnQuadraturePoints(const Array<Real> & nodes,
                                              const GhostType & ghost_type);
 
   // multiply the jacobians by the integration weights and stores the results in
   // jacobians
   template <ElementType type, UInt polynomial_degree>
   void multiplyJacobiansByWeights(Array<Real> & jacobians) const;
 
   /// compute the vector of quadrature points natural coordinates
   template <ElementType type>
   void computeQuadraturePoints(const GhostType & ghost_type);
 
   /// check that the jacobians are not negative
   template <ElementType type>
   void checkJacobians(const GhostType & ghost_type) const;
 
   /// internal integrate partially around a quadrature point (@f$ intf_q = f_q *
   /// J_q *
   /// w_q @f$)
   void integrateOnIntegrationPoints(const Array<Real> & in_f,
                                     Array<Real> & intf,
                                     UInt nb_degree_of_freedom,
                                     const Array<Real> & jacobians,
                                     UInt nb_element) const;
 
   void integrate(const Array<Real> & in_f, Array<Real> & intf,
                  UInt nb_degree_of_freedom, const Array<Real> & jacobians,
                  UInt nb_element) const;
 
 public:
   /// compute the jacobians on quad points for a given element
   template <ElementType type>
   void
   computeJacobianOnQuadPointsByElement(const Matrix<Real> & node_coords,
                                        const Matrix<Real> & integration_points,
                                        Vector<Real> & jacobians) const;
 
 public:
   void onElementsAdded(const Array<Element> & elements) override;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// integrate the field f with the jacobian jac -> inte
   inline void integrate(Real * f, Real * jac, Real * inte,
                         UInt nb_degree_of_freedom,
                         UInt nb_quadrature_points) const;
 
 private:
   /// ElementTypeMap of the quadrature points
   ElementTypeMap<Matrix<Real>> quadrature_points;
 };
 
 } // namespace akantu
 
 #include "integrator_gauss_inline_impl.cc"
 
 #endif /* __AKANTU_INTEGRATOR_GAUSS_HH__ */
diff --git a/src/io/dumper/dumpable.cc b/src/io/dumper/dumpable.cc
index c7a27ef22..12a692aa6 100644
--- a/src/io/dumper/dumpable.cc
+++ b/src/io/dumper/dumpable.cc
@@ -1,285 +1,285 @@
 /**
  * @file   dumpable.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Thu Jan 21 2016
  *
  * @brief  Implementation of the dumpable interface
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dumpable.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifdef AKANTU_USE_IOHELPER
 
 #include <io_helper.hh>
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Dumpable::Dumpable() : default_dumper("") {}
 
 /* -------------------------------------------------------------------------- */
 Dumpable::~Dumpable() {
 
-  DumperMap::iterator it = dumpers.begin();
-  DumperMap::iterator end = dumpers.end();
+  auto it = dumpers.begin();
+  auto end = dumpers.end();
 
   for (; it != end; ++it) {
     delete it->second;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::registerExternalDumper(DumperIOHelper & dumper,
                                       const std::string & dumper_name,
                                       const bool is_default) {
   this->dumpers[dumper_name] = &dumper;
   if (is_default)
     this->default_dumper = dumper_name;
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpMesh(const Mesh & mesh, UInt spatial_dimension,
                            const GhostType & ghost_type,
                            const ElementKind & element_kind) {
 
   this->addDumpMeshToDumper(this->default_dumper, mesh, spatial_dimension,
                             ghost_type, element_kind);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpMeshToDumper(const std::string & dumper_name,
                                    const Mesh & mesh, UInt spatial_dimension,
                                    const GhostType & ghost_type,
                                    const ElementKind & element_kind) {
 
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerMesh(mesh, spatial_dimension, ghost_type, element_kind);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFilteredMesh(
     const Mesh & mesh, const ElementTypeMapArray<UInt> & elements_filter,
     const Array<UInt> & nodes_filter, UInt spatial_dimension,
     const GhostType & ghost_type, const ElementKind & element_kind) {
   this->addDumpFilteredMeshToDumper(this->default_dumper, mesh, elements_filter,
                                     nodes_filter, spatial_dimension, ghost_type,
                                     element_kind);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFilteredMeshToDumper(
     const std::string & dumper_name, const Mesh & mesh,
     const ElementTypeMapArray<UInt> & elements_filter,
     const Array<UInt> & nodes_filter, UInt spatial_dimension,
     const GhostType & ghost_type, const ElementKind & element_kind) {
 
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerFilteredMesh(mesh, elements_filter, nodes_filter,
                               spatial_dimension, ghost_type, element_kind);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpField(const std::string & field_id) {
   this->addDumpFieldToDumper(this->default_dumper, field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldToDumper(__attribute__((unused))
                                     const std::string & dumper_name,
                                     __attribute__((unused))
                                     const std::string & field_id) {
   AKANTU_DEBUG_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldExternal(const std::string & field_id,
                                     dumper::Field * field) {
   this->addDumpFieldExternalToDumper(this->default_dumper, field_id, field);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldExternalToDumper(const std::string & dumper_name,
                                             const std::string & field_id,
                                             dumper::Field * field) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerField(field_id, field);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Dumpable::removeDumpField(const std::string & field_id) {
   this->removeDumpFieldFromDumper(this->default_dumper, field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::removeDumpFieldFromDumper(const std::string & dumper_name,
                                          const std::string & field_id) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.unRegisterField(field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldVector(const std::string & field_id) {
   this->addDumpFieldVectorToDumper(this->default_dumper, field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldVectorToDumper(__attribute__((unused))
                                           const std::string & dumper_name,
                                           __attribute__((unused))
                                           const std::string & field_id) {
   AKANTU_DEBUG_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldTensor(const std::string & field_id) {
   this->addDumpFieldTensorToDumper(this->default_dumper, field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldTensorToDumper(__attribute__((unused))
                                           const std::string & dumper_name,
                                           __attribute__((unused))
                                           const std::string & field_id) {
   AKANTU_DEBUG_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setDirectory(const std::string & directory) {
   this->setDirectoryToDumper(this->default_dumper, directory);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setDirectoryToDumper(const std::string & dumper_name,
                                     const std::string & directory) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.setDirectory(directory);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setBaseName(const std::string & basename) {
   this->setBaseNameToDumper(this->default_dumper, basename);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setBaseNameToDumper(const std::string & dumper_name,
                                    const std::string & basename) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.setBaseName(basename);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setTimeStepToDumper(Real time_step) {
   this->setTimeStepToDumper(this->default_dumper, time_step);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setTimeStepToDumper(const std::string & dumper_name,
                                    Real time_step) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.setTimeStep(time_step);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Dumpable::setTextModeToDumper(const std::string & dumper_name) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.getDumper().setMode(iohelper::TEXT);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setTextModeToDumper() {
   DumperIOHelper & dumper = this->getDumper(this->default_dumper);
   dumper.getDumper().setMode(iohelper::TEXT);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Dumpable::dump(const std::string & dumper_name) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.dump();
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::dump() { this->dump(this->default_dumper); }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::dump(const std::string & dumper_name, UInt step) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.dump(step);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::dump(UInt step) { this->dump(this->default_dumper, step); }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::dump(const std::string & dumper_name, Real time, UInt step) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.dump(time, step);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::dump(Real time, UInt step) {
   this->dump(this->default_dumper, time, step);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::internalAddDumpFieldToDumper(const std::string & dumper_name,
                                             const std::string & field_id,
                                             dumper::Field * field) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerField(field_id, field);
 }
 
 /* -------------------------------------------------------------------------- */
 DumperIOHelper & Dumpable::getDumper() {
   return this->getDumper(this->default_dumper);
 }
 
 /* -------------------------------------------------------------------------- */
 DumperIOHelper & Dumpable::getDumper(const std::string & dumper_name) {
 
-  DumperMap::iterator it = this->dumpers.find(dumper_name);
-  DumperMap::iterator end = this->dumpers.end();
+  auto it = this->dumpers.find(dumper_name);
+  auto end = this->dumpers.end();
 
   if (it == end)
     AKANTU_EXCEPTION("Dumper " << dumper_name
                                << "has not been registered, yet.");
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 
 std::string Dumpable::getDefaultDumperName() const {
   return this->default_dumper;
 }
 
 } // akantu
 
 #endif
diff --git a/src/io/dumper/dumpable_inline_impl.hh b/src/io/dumper/dumpable_inline_impl.hh
index 2461429b2..638462db5 100644
--- a/src/io/dumper/dumpable_inline_impl.hh
+++ b/src/io/dumper/dumpable_inline_impl.hh
@@ -1,134 +1,134 @@
 /**
  * @file   dumpable_inline_impl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Thu Jan 21 2016
  *
  * @brief  Implementation of the Dumpable class
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_DUMPABLE_INLINE_IMPL_HH__
 #define __AKANTU_DUMPABLE_INLINE_IMPL_HH__
 
 /* -------------------------------------------------------------------------- */
 #ifdef AKANTU_USE_IOHELPER
 #include "dumper_elemental_field.hh"
 #include "dumper_nodal_field.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class T>
 inline void Dumpable::registerDumper(const std::string & dumper_name,
                                      const std::string & file_name,
                                      const bool is_default) {
 
   if (this->dumpers.find(dumper_name) != this->dumpers.end()) {
     AKANTU_DEBUG_INFO("Dumper " + dumper_name + "is already registered.");
   }
 
   std::string name = file_name;
   if (name == "")
     name = dumper_name;
 
   this->dumpers[dumper_name] = new T(name);
 
   if (is_default)
     this->default_dumper = dumper_name;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Dumpable::addDumpFieldExternal(const std::string & field_id,
                                            const Array<T> & field) {
   this->addDumpFieldExternalToDumper<T>(this->default_dumper, field_id, field);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void
 Dumpable::addDumpFieldExternalToDumper(const std::string & dumper_name,
                                        const std::string & field_id,
                                        const Array<T> & field) {
   dumper::Field * field_cont = new dumper::NodalField<T>(field);
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerField(field_id, field_cont);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Dumpable::addDumpFieldExternal(const std::string & field_id,
                                            const ElementTypeMapArray<T> & field,
                                            UInt spatial_dimension,
                                            const GhostType & ghost_type,
                                            const ElementKind & element_kind) {
   this->addDumpFieldExternalToDumper(this->default_dumper, field_id, field,
                                      spatial_dimension, ghost_type,
                                      element_kind);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Dumpable::addDumpFieldExternalToDumper(
     const std::string & dumper_name, const std::string & field_id,
     const ElementTypeMapArray<T> & field, UInt spatial_dimension,
     const GhostType & ghost_type, const ElementKind & element_kind) {
 
   dumper::Field * field_cont;
 #if defined(AKANTU_IGFEM)
   if (element_kind == _ek_igfem) {
     field_cont = new dumper::IGFEMElementalField<T>(field, spatial_dimension,
                                                     ghost_type, element_kind);
   } else
 #endif
     field_cont = new dumper::ElementalField<T>(field, spatial_dimension,
                                                ghost_type, element_kind);
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerField(field_id, field_cont);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T>
 inline T & Dumpable::getDumper(const std::string & dumper_name) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
 
   try {
-    T & templated_dumper = dynamic_cast<T &>(dumper);
+    auto & templated_dumper = dynamic_cast<T &>(dumper);
     return templated_dumper;
   } catch (std::bad_cast &) {
     AKANTU_EXCEPTION("Dumper " << dumper_name << " is not of type: "
                                << debug::demangle(typeid(T).name()));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
 
 #endif
 
 #endif /* __AKANTU_DUMPABLE_INLINE_IMPL_HH__ */
diff --git a/src/io/dumper/dumpable_iohelper.hh b/src/io/dumper/dumpable_iohelper.hh
index 1ffe18fd8..0a5a366ce 100644
--- a/src/io/dumper/dumpable_iohelper.hh
+++ b/src/io/dumper/dumpable_iohelper.hh
@@ -1,196 +1,196 @@
 /**
  * @file   dumpable_iohelper.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Jan 06 2015
  * @date last modification: Thu Nov 19 2015
  *
  * @brief  Interface for object who wants to dump themselves
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dumper_iohelper.hh"
 /* -------------------------------------------------------------------------- */
 #include <set>
 /* -------------------------------------------------------------------------- */
 #ifndef __AKANTU_DUMPABLE_IOHELPER_HH__
 #define __AKANTU_DUMPABLE_IOHELPER_HH__
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 class Dumpable {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
 
   Dumpable();
   virtual ~Dumpable();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
 
   /// create a new dumper (of templated type T) and register it under
   /// dumper_name. file_name is used for construction of T. is default states if
   /// this dumper is the default dumper.
   template<class T>
   inline void registerDumper(const std::string & dumper_name,
                              const std::string & file_name = "",
                              const bool is_default = false);
 
   /// register an externally created dumper
   void registerExternalDumper(DumperIOHelper & dumper,
                               const std::string & dumper_name,
                               const bool is_default = false);
 
   /// register a mesh to the default dumper
   void addDumpMesh(const Mesh & mesh, UInt spatial_dimension = _all_dimensions,
                    const GhostType & ghost_type = _not_ghost,
                    const ElementKind & element_kind = _ek_not_defined);
 
   /// register a mesh to the default identified by its name
   void addDumpMeshToDumper(const std::string & dumper_name,
                            const Mesh & mesh, UInt spatial_dimension = _all_dimensions,
                            const GhostType & ghost_type = _not_ghost,
                            const ElementKind & element_kind = _ek_not_defined);
 
   /// register a filtered mesh as the default dumper
   void addDumpFilteredMesh(const Mesh & mesh,
                            const ElementTypeMapArray<UInt> & elements_filter,
                            const Array<UInt> & nodes_filter,
                            UInt spatial_dimension = _all_dimensions,
                            const GhostType & ghost_type = _not_ghost,
                            const ElementKind & element_kind = _ek_not_defined);
 
   /// register a filtered mesh and provides a name
   void addDumpFilteredMeshToDumper(const std::string & dumper_name,
                                    const Mesh & mesh,
                                    const ElementTypeMapArray<UInt> & elements_filter,
                                    const Array<UInt> & nodes_filter,
                                    UInt spatial_dimension = _all_dimensions,
                                    const GhostType & ghost_type = _not_ghost,
                                    const ElementKind & element_kind = _ek_not_defined);
 
   /// to implement
   virtual void addDumpField(const std::string & field_id);
   /// to implement
   virtual void addDumpFieldToDumper(const std::string & dumper_name,
                                     const std::string & field_id);
   /// add a field
   virtual void addDumpFieldExternal(const std::string & field_id,
                                     dumper::Field * field);
   virtual void addDumpFieldExternalToDumper(const std::string & dumper_name,
                                             const std::string & field_id,
                                             dumper::Field * field);
 
   template<typename T>
   inline void addDumpFieldExternal(const std::string & field_id,
                                    const Array<T> & field);
   template<typename T>
   inline void addDumpFieldExternalToDumper(const std::string & dumper_name,
                                     const std::string & field_id,
                                     const Array<T> & field);
   template<typename T>
   inline void addDumpFieldExternal(const std::string & field_id,
                                    const ElementTypeMapArray<T> & field,
                                    UInt spatial_dimension = _all_dimensions,
                                    const GhostType & ghost_type = _not_ghost,
                                    const ElementKind & element_kind = _ek_not_defined);
   template<typename T>
   inline void addDumpFieldExternalToDumper(const std::string & dumper_name,
                                     const std::string & field_id,
                                     const ElementTypeMapArray<T> & field,
                                     UInt spatial_dimension = _all_dimensions,
                                     const GhostType & ghost_type = _not_ghost,
                                     const ElementKind & element_kind = _ek_not_defined);
 
   void removeDumpField(const std::string & field_id);
   void removeDumpFieldFromDumper(const std::string & dumper_name,
                                  const std::string & field_id);
 
   virtual void addDumpFieldVector(const std::string & field_id);
   virtual void addDumpFieldVectorToDumper(const std::string & dumper_name,
                                           const std::string & field_id);
 
   virtual void addDumpFieldTensor(const std::string & field_id);
   virtual void addDumpFieldTensorToDumper(const std::string & dumper_name,
                                           const std::string & field_id);
 
   void setDirectory(const std::string & directory);
   void setDirectoryToDumper(const std::string & dumper_name,
                             const std::string & directory);
 
   void setBaseName(const std::string & basename);
 
   void setBaseNameToDumper(const std::string & dumper_name,
                            const std::string & basename);
   void setTimeStepToDumper(Real time_step);
   void setTimeStepToDumper(const std::string & dumper_name,
                            Real time_step);
 
 
   void setTextModeToDumper(const std::string & dumper_name);
   void setTextModeToDumper();
 
   virtual void dump();
   virtual void dump(UInt step);
   virtual void dump(Real time, UInt step);
   virtual void dump(const std::string & dumper_name);
   virtual void dump(const std::string & dumper_name, UInt step);
   virtual void dump(const std::string & dumper_name, Real time, UInt step);
 
 
 public:
   void internalAddDumpFieldToDumper(const std::string & dumper_name,
                                     const std::string & field_id,
                                     dumper::Field * field);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   DumperIOHelper & getDumper();
   DumperIOHelper & getDumper(const std::string & dumper_name);
 
   template<class T> T & getDumper(const std::string & dumper_name);
   std::string getDefaultDumperName() const;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   typedef std::map<std::string, DumperIOHelper *> DumperMap;
-  typedef std::set<std::string> DumperSet;
+  using DumperSet = std::set<std::string>;
 
   DumperMap dumpers;
   std::string default_dumper;
 };
 
 } // akantu
 
 #endif /* __AKANTU_DUMPABLE_IOHELPER_HH__ */
diff --git a/src/io/dumper/dumper_compute.hh b/src/io/dumper/dumper_compute.hh
index 2f7931dd7..30a362d3d 100644
--- a/src/io/dumper/dumper_compute.hh
+++ b/src/io/dumper/dumper_compute.hh
@@ -1,272 +1,271 @@
 /**
  * @file   dumper_compute.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  Field that map a function to another field
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_DUMPER_COMPUTE_HH__
 #define __AKANTU_DUMPER_COMPUTE_HH__
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "dumper_iohelper.hh"
 #include "dumper_type_traits.hh"
 #include "dumper_field.hh"
 #include <io_helper.hh>
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 __BEGIN_AKANTU_DUMPER__
 
 class ComputeFunctorInterface {
 public:
-  virtual ~ComputeFunctorInterface(){};
+  virtual ~ComputeFunctorInterface() = default;
 
   virtual UInt getDim() = 0;
   virtual UInt getNbComponent(UInt old_nb_comp) = 0;
 };
 
 /* -------------------------------------------------------------------------- */
 
 template <typename return_type>
 class ComputeFunctorOutput : public ComputeFunctorInterface {
 public:
-  ComputeFunctorOutput(){};
-  ~ComputeFunctorOutput() override{};
+  ComputeFunctorOutput() = default;
+  ~ComputeFunctorOutput() override = default;
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename input_type, typename return_type>
 class ComputeFunctor : public ComputeFunctorOutput<return_type> {
 public:
-  ComputeFunctor(){};
-  ~ComputeFunctor() override{};
+  ComputeFunctor() = default;
+  ~ComputeFunctor() override = default;
 
   virtual return_type func(const input_type & d, Element global_index) = 0;
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename SubFieldCompute, typename _return_type>
 class FieldCompute : public Field {
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-  typedef typename SubFieldCompute::iterator sub_iterator;
-  typedef typename SubFieldCompute::types sub_types;
-  typedef typename sub_types::return_type sub_return_type;
-  typedef _return_type return_type;
-  typedef typename sub_types::data_type data_type;
+  using sub_iterator = typename SubFieldCompute::iterator;
+  using sub_types = typename SubFieldCompute::types;
+  using sub_return_type = typename sub_types::return_type;
+  using return_type = _return_type;
+  using data_type = typename sub_types::data_type;
 
   typedef TypeTraits<data_type, return_type, ElementTypeMapArray<data_type> >
       types;
 
   class iterator {
   public:
     iterator(const sub_iterator & it,
              ComputeFunctor<sub_return_type, return_type> & func)
         : it(it), func(func) {}
 
     bool operator!=(const iterator & it) const { return it.it != this->it; }
     iterator operator++() {
       ++this->it;
       return *this;
     }
 
     UInt currentGlobalIndex() { return this->it.currentGlobalIndex(); }
 
     return_type operator*() { return func.func(*it, it.getCurrentElement()); }
 
     Element getCurrentElement() { return this->it.getCurrentElement(); }
 
     UInt element_type() { return this->it.element_type(); }
 
   protected:
     sub_iterator it;
     ComputeFunctor<sub_return_type, return_type> & func;
   };
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   FieldCompute(SubFieldCompute & cont, ComputeFunctorInterface & func)
       : sub_field(cont),
         func(dynamic_cast<ComputeFunctor<sub_return_type, return_type> &>(
             func)) {
     this->checkHomogeneity();
   };
 
   ~FieldCompute() override {
     delete &(this->sub_field);
     delete &(this->func);
   }
 
   void registerToDumper(const std::string & id,
                         iohelper::Dumper & dumper) override {
     dumper.addElemDataField(id, *this);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 public:
   iterator begin() { return iterator(sub_field.begin(), func); }
   iterator end() { return iterator(sub_field.end(), func); }
 
   UInt getDim() { return func.getDim(); }
 
   UInt size() {
     throw;
     // return Functor::size();
     return 0;
   }
 
   void checkHomogeneity() override { this->homogeneous = true; };
 
   iohelper::DataType getDataType() {
     return iohelper::getDataType<data_type>();
   }
 
   /// get the number of components of the hosted field
   ElementTypeMap<UInt>
   getNbComponents(UInt dim = _all_dimensions, GhostType ghost_type = _not_ghost,
                   ElementKind kind = _ek_not_defined) override {
     ElementTypeMap<UInt> nb_components;
     const ElementTypeMap<UInt> & old_nb_components =
         this->sub_field.getNbComponents(dim, ghost_type, kind);
 
     ElementTypeMap<UInt>::type_iterator tit =
         old_nb_components.firstType(dim, ghost_type, kind);
     ElementTypeMap<UInt>::type_iterator end =
         old_nb_components.lastType(dim, ghost_type, kind);
 
     while (tit != end) {
       UInt nb_comp = old_nb_components(*tit, ghost_type);
       nb_components(*tit, ghost_type) = func.getNbComponent(nb_comp);
       ++tit;
     }
     return nb_components;
   };
 
   /// for connection to a FieldCompute
   inline Field * connect(FieldComputeProxy & proxy) override;
 
   /// for connection to a FieldCompute
   ComputeFunctorInterface * connect(HomogenizerProxy & proxy) override;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 public:
   SubFieldCompute & sub_field;
   ComputeFunctor<sub_return_type, return_type> & func;
 };
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 
 class FieldComputeProxy {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   FieldComputeProxy(ComputeFunctorInterface & func) : func(func){};
 
   inline static Field * createFieldCompute(Field * field,
                                            ComputeFunctorInterface & func) {
     /// that looks fishy an object passed as a ref and destroyed at their end of
     /// the function
     FieldComputeProxy compute_proxy(func);
     return field->connect(compute_proxy);
   }
 
   template <typename T> Field * connectToField(T * ptr) {
     if (dynamic_cast<ComputeFunctorOutput<Vector<Real> > *>(&func)) {
       return this->connectToFunctor<Vector<Real> >(ptr);
     } else if (dynamic_cast<ComputeFunctorOutput<Vector<UInt> > *>(&func)) {
       return this->connectToFunctor<Vector<UInt> >(ptr);
     }
 
     else if (dynamic_cast<ComputeFunctorOutput<Matrix<UInt> > *>(&func)) {
       return this->connectToFunctor<Matrix<UInt> >(ptr);
     }
 
     else if (dynamic_cast<ComputeFunctorOutput<Matrix<Real> > *>(&func)) {
       return this->connectToFunctor<Matrix<Real> >(ptr);
     }
 
     else
       throw;
   }
 
   template <typename output, typename T> Field * connectToFunctor(T * ptr) {
-    FieldCompute<T, output> * functor_ptr =
-        new FieldCompute<T, output>(*ptr, func);
+    auto * functor_ptr = new FieldCompute<T, output>(*ptr, func);
     return functor_ptr;
   }
 
   template <typename output, typename SubFieldCompute, typename return_type1,
             typename return_type2>
   Field * connectToFunctor(__attribute__((unused)) FieldCompute<
       FieldCompute<SubFieldCompute, return_type1>, return_type2> * ptr) {
     throw; //    return new FieldCompute<T,output>(*ptr,func);
     return nullptr;
   }
 
   template <typename output, typename SubFieldCompute, typename return_type1,
             typename return_type2, typename return_type3, typename return_type4>
   Field * connectToFunctor(__attribute__((unused)) FieldCompute<
       FieldCompute<FieldCompute<FieldCompute<SubFieldCompute, return_type1>,
                                 return_type2>,
                    return_type3>,
       return_type4> * ptr) {
     throw; //    return new FieldCompute<T,output>(*ptr,func);
     return nullptr;
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 public:
   ComputeFunctorInterface & func;
 };
 
 /* -------------------------------------------------------------------------- */
 /// for connection to a FieldCompute
 template <typename SubFieldCompute, typename return_type>
 inline Field *
 FieldCompute<SubFieldCompute, return_type>::connect(FieldComputeProxy & proxy) {
   return proxy.connectToField(this);
 }
 
 /* -------------------------------------------------------------------------- */
 __END_AKANTU_DUMPER__
 } // akantu
 
 #endif /* __AKANTU_DUMPER_COMPUTE_HH__ */
diff --git a/src/io/dumper/dumper_element_iterator.hh b/src/io/dumper/dumper_element_iterator.hh
index 6bfe39e33..026640e45 100644
--- a/src/io/dumper/dumper_element_iterator.hh
+++ b/src/io/dumper/dumper_element_iterator.hh
@@ -1,193 +1,192 @@
 /**
  * @file   dumper_element_iterator.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Fri May 15 2015
  *
  * @brief  Iterators for elemental fields
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_DUMPER_ELEMENT_ITERATOR_HH__
 #define __AKANTU_DUMPER_ELEMENT_ITERATOR_HH__
 /* -------------------------------------------------------------------------- */
 #include "element.hh"
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 __BEGIN_AKANTU_DUMPER__
 /* -------------------------------------------------------------------------- */
 
 template<class types, template <class> class final_iterator>
 class element_iterator {
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-
-  typedef typename types::it_type      it_type;
-  typedef typename types::field_type field_type;
-  typedef typename types::array_type array_type;
-  typedef typename types::array_iterator array_iterator;
-  typedef final_iterator<types> iterator;
+  using it_type = typename types::it_type;
+  using field_type = typename types::field_type;
+  using array_type = typename types::array_type;
+  using array_iterator = typename types::array_iterator;
+  using iterator = final_iterator<types>;
 
 public:
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
   element_iterator(const field_type & field,
                    const typename field_type::type_iterator & t_it,
                    const typename field_type::type_iterator & t_it_end,
                    const array_iterator & array_it,
                    const array_iterator & array_it_end,
                    const GhostType ghost_type = _not_ghost)
     : field(field),
       tit(t_it),
       tit_end(t_it_end),
       array_it(array_it),
       array_it_end(array_it_end),
       ghost_type(ghost_type) {
   }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 
 public:
 
   bool operator!=(const iterator & it) const {
     return (ghost_type != it.ghost_type)
       || (tit != it.tit || (array_it != it.array_it));
   }
 
   iterator & operator++() {
     ++array_it;
     while(array_it == array_it_end && tit != tit_end) {
       ++tit;
       if(tit != tit_end) {
 
         const array_type & vect = field(*tit, ghost_type);
         UInt _nb_data_per_elem = getNbDataPerElem(*tit);
         UInt nb_component = vect.getNbComponent();
         UInt size = (vect.size() * nb_component) / _nb_data_per_elem;
 
         array_it       = vect.begin_reinterpret(_nb_data_per_elem,size);
         array_it_end   = vect.end_reinterpret  (_nb_data_per_elem,size);
       }
     }
     return *(static_cast<iterator *>(this));
   };
 
   ElementType getType() { return *tit; }
 
   UInt element_type() { return getIOHelperType(*tit); }
 
   Element getCurrentElement(){
     return Element{*tit, array_it.getCurrentIndex(), _not_ghost};
   }
 
   UInt getNbDataPerElem(const ElementType & type) const {
     if (!nb_data_per_elem.exists(type, ghost_type))
       return field(type,ghost_type).getNbComponent();
     
     return nb_data_per_elem(type,ghost_type);
   }
 
   void setNbDataPerElem(const ElementTypeMap<UInt> & nb_data){
     this->nb_data_per_elem = nb_data;
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 
 protected:
 
   /// the field to iterate on
   const field_type & field;
   /// field iterator
   typename field_type::type_iterator tit;
   /// field iterator end
   typename field_type::type_iterator tit_end;
   /// array iterator
   array_iterator array_it;
   /// internal iterator end
   array_iterator array_it_end;
   /// ghost type identification
   const GhostType ghost_type;
   /// number of data per element
   ElementTypeMap<UInt> nb_data_per_elem;
 
 };
 
 /* -------------------------------------------------------------------------- */
 template<typename types>
 class elemental_field_iterator
   : public element_iterator<types, elemental_field_iterator> {
 public:
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 
   typedef element_iterator<types, ::akantu::dumper::elemental_field_iterator> parent;
-  typedef typename types::it_type     it_type;
-  typedef typename types::return_type return_type;
-  typedef typename types::field_type  field_type;
-  typedef typename types::array_iterator array_iterator;
+  using it_type = typename types::it_type;
+  using return_type = typename types::return_type;
+  using field_type = typename types::field_type;
+  using array_iterator = typename types::array_iterator;
 
 public:
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
   elemental_field_iterator(const field_type & field,
                            const typename field_type::type_iterator & t_it,
                            const typename field_type::type_iterator & t_it_end,
                            const array_iterator & array_it,
                            const array_iterator & array_it_end,
                            const GhostType ghost_type = _not_ghost) :
     parent(field, t_it, t_it_end, array_it, array_it_end, ghost_type) { }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 
   return_type operator*(){
     return *this->array_it;
   }
 
 private:
 
 };
 
 /* -------------------------------------------------------------------------- */
 __END_AKANTU_DUMPER__
 } // akantu
 /* -------------------------------------------------------------------------- */
 
 
 
 #endif /* __AKANTU_DUMPER_ELEMENT_ITERATOR_HH__ */
diff --git a/src/io/dumper/dumper_elemental_field.hh b/src/io/dumper/dumper_elemental_field.hh
index 231e5cdeb..117936411 100644
--- a/src/io/dumper/dumper_elemental_field.hh
+++ b/src/io/dumper/dumper_elemental_field.hh
@@ -1,80 +1,80 @@
 /**
  * @file   dumper_elemental_field.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Mon Aug 17 2015
  *
  * @brief  description of elemental fields
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_DUMPER_ELEMENTAL_FIELD_HH__
 #define __AKANTU_DUMPER_ELEMENTAL_FIELD_HH__
 /* -------------------------------------------------------------------------- */
 #include "communicator.hh"
 #include "dumper_field.hh"
 #include "dumper_generic_elemental_field.hh"
 #ifdef AKANTU_IGFEM
 #  include "dumper_igfem_elemental_field.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 __BEGIN_AKANTU_DUMPER__
 /* -------------------------------------------------------------------------- */
 
 
 template<typename T, template <class> class ret = Vector,bool filtered = false>
 class ElementalField
   : public GenericElementalField<SingleType<T,ret,filtered>,
                                  elemental_field_iterator> {
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   typedef SingleType<T,ret,filtered> types;
-  typedef typename types::field_type field_type;
-  typedef elemental_field_iterator<types> iterator;
+  using field_type = typename types::field_type;
+  using iterator = elemental_field_iterator<types>;
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   ElementalField(const field_type & field,
                  UInt spatial_dimension = _all_dimensions,
                  GhostType ghost_type = _not_ghost,
                  ElementKind element_kind = _ek_not_defined) :
     GenericElementalField<types,elemental_field_iterator>(field,
                                                           spatial_dimension,
                                                           ghost_type,
                                                           element_kind) { }
 };
 
 /* -------------------------------------------------------------------------- */
 
 
 __END_AKANTU_DUMPER__
 } // akantu
 
 #endif /* __AKANTU_DUMPER_ELEMENTAL_FIELD_HH__ */
diff --git a/src/io/dumper/dumper_field.hh b/src/io/dumper/dumper_field.hh
index 7c7170e3f..0164045e9 100644
--- a/src/io/dumper/dumper_field.hh
+++ b/src/io/dumper/dumper_field.hh
@@ -1,137 +1,137 @@
 /**
  * @file   dumper_field.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  Common interface for fields
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_DUMPER_FIELD_HH__
 #define __AKANTU_DUMPER_FIELD_HH__
 /* -------------------------------------------------------------------------- */
 #include "dumper_iohelper.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 __BEGIN_AKANTU_DUMPER__
 /* -------------------------------------------------------------------------- */
 class FieldComputeProxy;
 class FieldComputeBaseInterface;
 class ComputeFunctorInterface;
 class HomogenizerProxy;
 /* -------------------------------------------------------------------------- */
 
 /// Field interface
 class Field {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-  Field() : homogeneous(false) {}
-  virtual ~Field(){};
+  Field() = default;
+  virtual ~Field() = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
 #ifdef AKANTU_USE_IOHELPER
   /// register this to the provided dumper
   virtual void registerToDumper(const std::string & id,
                                 iohelper::Dumper & dumper) = 0;
 #endif
 
   /// set the number of data per item (used for elements fields at the moment)
   virtual void setNbData(__attribute__((unused)) UInt nb_data) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   };
 
   /// set the number of data per elem (used for elements fields at the moment)
   virtual void setNbDataPerElem(__attribute__((unused))
                                 const ElementTypeMap<UInt> & nb_data) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   };
 
   /// set the number of data per elem (used for elements fields at the moment)
   virtual void setNbDataPerElem(__attribute__((unused)) UInt nb_data) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   };
 
   /// get the number of components of the hosted field
   virtual ElementTypeMap<UInt>
   getNbComponents(__attribute__((unused)) UInt dim = _all_dimensions,
                   __attribute__((unused)) GhostType ghost_type = _not_ghost,
                   __attribute__((unused)) ElementKind kind = _ek_not_defined) {
     throw;
   };
 
   /// for connection to a FieldCompute
   inline virtual Field * connect(__attribute__((unused))
                                  FieldComputeProxy & proxy) {
     throw;
   };
 
   /// for connection to a FieldCompute
   inline virtual ComputeFunctorInterface * connect(__attribute__((unused))
                                                    HomogenizerProxy & proxy) {
     throw;
   };
 
   /// check if the same quantity of data for all element types
   virtual void checkHomogeneity() = 0;
 
   /// return the dumper name
   std::string getGroupName() { return group_name; };
 
   /// return the id of the field
   std::string getID() { return field_id; };
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// return the flag to know if the field is homogeneous/contiguous
   virtual bool isHomogeneous() { return homogeneous; }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// the flag to know if it is homogeneous
-  bool homogeneous;
+  bool homogeneous{false};
 
   /// the name of the group it was associated to
   std::string group_name;
 
   /// the name of the dumper it was associated to
   std::string field_id;
 };
 
 /* -------------------------------------------------------------------------- */
 
 __END_AKANTU_DUMPER__
 } // akantu
 
 #endif /* __AKANTU_DUMPER_FIELD_HH__ */
diff --git a/src/io/dumper/dumper_filtered_connectivity.hh b/src/io/dumper/dumper_filtered_connectivity.hh
index ebc21227e..b26f49c00 100644
--- a/src/io/dumper/dumper_filtered_connectivity.hh
+++ b/src/io/dumper/dumper_filtered_connectivity.hh
@@ -1,151 +1,151 @@
 /**
  * @file   dumper_filtered_connectivity.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Mon Aug 17 2015
  *
  * @brief  FilteredConnectivities field
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #include "dumper_generic_elemental_field.hh"
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 __BEGIN_AKANTU_DUMPER__
 /* -------------------------------------------------------------------------- */
 
 template <class types>
 class filtered_connectivity_field_iterator
   : public element_iterator<types, filtered_connectivity_field_iterator> {
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   typedef element_iterator<types, dumper::filtered_connectivity_field_iterator> parent;
-  typedef typename types::return_type return_type;
-  typedef typename types::field_type field_type;
-  typedef typename types::array_iterator array_iterator;
+  using return_type = typename types::return_type;
+  using field_type = typename types::field_type;
+  using array_iterator = typename types::array_iterator;
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   filtered_connectivity_field_iterator(const field_type & field,
                                        const typename field_type::type_iterator & t_it,
                                        const typename field_type::type_iterator & t_it_end,
                                        const array_iterator & array_it,
                                        const array_iterator & array_it_end,
                                        const GhostType ghost_type = _not_ghost) :
     parent(field, t_it, t_it_end, array_it, array_it_end, ghost_type) { }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   return_type operator*(){
     const Vector<UInt> & old_connect = *this->array_it;
     Vector<UInt> new_connect(old_connect.size());
     Array<UInt>::const_iterator<UInt> nodes_begin = nodal_filter->begin();
     Array<UInt>::const_iterator<UInt> nodes_end = nodal_filter->end();
     for(UInt i(0); i<old_connect.size(); ++i) {
       Array<UInt>::const_iterator<UInt> new_id =
         std::find(nodes_begin, nodes_end, old_connect(i));
       if(new_id == nodes_end) AKANTU_EXCEPTION("Node not found in the filter!");
       new_connect(i) = new_id - nodes_begin;
     }
     return new_connect;
   }
 
   void setNodalFilter(const Array<UInt> & new_nodal_filter) {
     nodal_filter = &new_nodal_filter;
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   const Array<UInt> * nodal_filter;
 };
 
 /* -------------------------------------------------------------------------- */
 
 class FilteredConnectivityField :
   public GenericElementalField<SingleType<UInt,Vector,true>,
                                filtered_connectivity_field_iterator> {
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   typedef SingleType<UInt,Vector,true> types;
-  typedef filtered_connectivity_field_iterator<types> iterator;
-  typedef types::field_type field_type;
+  using iterator = filtered_connectivity_field_iterator<types>;
+  using field_type = types::field_type;
   typedef GenericElementalField<types,filtered_connectivity_field_iterator> parent;
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   FilteredConnectivityField(const field_type & field,
                             const Array<UInt> & nodal_filter,
                             UInt spatial_dimension = _all_dimensions,
                             GhostType ghost_type = _not_ghost,
                             ElementKind element_kind = _ek_not_defined) :
     parent(field, spatial_dimension, ghost_type, element_kind),
     nodal_filter(nodal_filter) { }
 
-  ~FilteredConnectivityField() {
+  ~FilteredConnectivityField() override {
     // since the field is created in registerFilteredMesh it is destroyed here
     delete const_cast<field_type *>(&this->field);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
-  iterator begin() {
+  iterator begin() override {
     iterator it = parent::begin();
     it.setNodalFilter(nodal_filter);
     return it;
   }
 
-  iterator end() {
+  iterator end() override {
     iterator it = parent::end();
     it.setNodalFilter(nodal_filter);
     return it;
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   const Array<UInt> & nodal_filter;
 };
 
 
 /* -------------------------------------------------------------------------- */
 
 __END_AKANTU_DUMPER__
 } // akantu
 
 /* -------------------------------------------------------------------------- */
diff --git a/src/io/dumper/dumper_generic_elemental_field.hh b/src/io/dumper/dumper_generic_elemental_field.hh
index ab5ee3886..d96b4209f 100644
--- a/src/io/dumper/dumper_generic_elemental_field.hh
+++ b/src/io/dumper/dumper_generic_elemental_field.hh
@@ -1,224 +1,224 @@
 /**
  * @file   dumper_generic_elemental_field.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  Generic interface for elemental fields
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_DUMPER_GENERIC_ELEMENTAL_FIELD_HH__
 #define __AKANTU_DUMPER_GENERIC_ELEMENTAL_FIELD_HH__
 /* -------------------------------------------------------------------------- */
 #include "dumper_field.hh"
 #include "element_type_map_filter.hh"
 #include "dumper_element_iterator.hh"
 #include "dumper_homogenizing_field.hh"
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 __BEGIN_AKANTU_DUMPER__
 /* -------------------------------------------------------------------------- */
 
 template <class _types, template <class> class iterator_type>
 class GenericElementalField : public Field {
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   // check dumper_type_traits.hh for additional information over these types
-  typedef _types types;
-  typedef typename types::data_type data_type;
-  typedef typename types::it_type it_type;
-  typedef typename types::field_type field_type;
-  typedef typename types::array_type array_type;
-  typedef typename types::array_iterator array_iterator;
-  typedef typename field_type::type_iterator field_type_iterator;
-  typedef iterator_type<types> iterator;
+  using types = _types;
+  using data_type = typename types::data_type;
+  using it_type = typename types::it_type;
+  using field_type = typename types::field_type;
+  using array_type = typename types::array_type;
+  using array_iterator = typename types::array_iterator;
+  using field_type_iterator = typename field_type::type_iterator;
+  using iterator = iterator_type<types>;
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   GenericElementalField(const field_type & field,
                         UInt spatial_dimension = _all_dimensions,
                         GhostType ghost_type = _not_ghost,
                         ElementKind element_kind = _ek_not_defined)
       : field(field), spatial_dimension(spatial_dimension),
         ghost_type(ghost_type), element_kind(element_kind) {
     this->checkHomogeneity();
   }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the number of components of the hosted field
   ElementTypeMap<UInt>
   getNbComponents(UInt dim = _all_dimensions, GhostType ghost_type = _not_ghost,
                   ElementKind kind = _ek_not_defined) override {
     return this->field.getNbComponents(dim, ghost_type, kind);
   };
 
   /// return the size of the contained data: i.e. the number of elements ?
   virtual UInt size() {
     checkHomogeneity();
     return this->nb_total_element;
   }
 
   /// return the iohelper datatype to be dumped
   iohelper::DataType getDataType() {
     return iohelper::getDataType<data_type>();
   }
 
 protected:
   /// return the number of entries per element
   UInt getNbDataPerElem(const ElementType & type,
                         const GhostType & ghost_type = _not_ghost) const {
     if (!nb_data_per_elem.exists(type, ghost_type))
       return field(type, ghost_type).getNbComponent();
 
     return nb_data_per_elem(type, this->ghost_type);
   }
 
   /// check if the same quantity of data for all element types
   void checkHomogeneity() override;
 
 public:
   void registerToDumper(const std::string & id,
                         iohelper::Dumper & dumper) override {
     dumper.addElemDataField(id, *this);
   };
 
   /// for connection to a FieldCompute
   inline Field * connect(FieldComputeProxy & proxy) override {
     return proxy.connectToField(this);
   }
 
   /// for connection to a Homogenizer
   inline ComputeFunctorInterface * connect(HomogenizerProxy & proxy) override {
     return proxy.connectToField(this);
   };
 
   virtual iterator begin() {
     field_type_iterator tit;
     field_type_iterator end;
 
     /// type iterators on the elemental field
     tit = this->field.firstType(this->spatial_dimension, this->ghost_type,
                                 this->element_kind);
     end = this->field.lastType(this->spatial_dimension, this->ghost_type,
                                this->element_kind);
 
     /// skip all types without data
     ElementType type = *tit;
     for (; tit != end && this->field(*tit, this->ghost_type).size() == 0;
          ++tit) {
     }
 
     type = *tit;
 
     if (tit == end)
       return this->end();
 
     /// getting information for the field of the given type
     const array_type & vect = this->field(type, this->ghost_type);
     UInt nb_data_per_elem = this->getNbDataPerElem(type);
     UInt nb_component = vect.getNbComponent();
     UInt size = (vect.size() * nb_component) / nb_data_per_elem;
 
     /// define element-wise iterator
     array_iterator it = vect.begin_reinterpret(nb_data_per_elem, size);
     array_iterator it_end = vect.end_reinterpret(nb_data_per_elem, size);
     /// define data iterator
     iterator rit =
         iterator(this->field, tit, end, it, it_end, this->ghost_type);
     rit.setNbDataPerElem(this->nb_data_per_elem);
     return rit;
   }
 
   virtual iterator end() {
     field_type_iterator tit;
     field_type_iterator end;
 
     tit = this->field.firstType(this->spatial_dimension, this->ghost_type,
                                 this->element_kind);
     end = this->field.lastType(this->spatial_dimension, this->ghost_type,
                                this->element_kind);
 
     ElementType type = *tit;
     for (; tit != end; ++tit)
       type = *tit;
 
     const array_type & vect = this->field(type, this->ghost_type);
     UInt nb_data = this->getNbDataPerElem(type);
     UInt nb_component = vect.getNbComponent();
     UInt size = (vect.size() * nb_component) / nb_data;
     array_iterator it = vect.end_reinterpret(nb_data, size);
 
     iterator rit = iterator(this->field, end, end, it, it, this->ghost_type);
     rit.setNbDataPerElem(this->nb_data_per_elem);
     return rit;
   }
 
   virtual UInt getDim() {
     if (this->homogeneous) {
       field_type_iterator tit = this->field.firstType(
           this->spatial_dimension, this->ghost_type, this->element_kind);
       return this->getNbDataPerElem(*tit);
     }
 
     throw;
     return 0;
   }
 
   void setNbDataPerElem(const ElementTypeMap<UInt> & nb_data) override {
     nb_data_per_elem = nb_data;
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// the ElementTypeMapArray embedded in the field
   const field_type & field;
   /// total number of elements
   UInt nb_total_element;
   /// the spatial dimension of the problem
   UInt spatial_dimension;
   /// whether this is a ghost field or not (for type selection)
   GhostType ghost_type;
   /// The element kind to operate on
   ElementKind element_kind;
   /// The number of data per element type
   ElementTypeMap<UInt> nb_data_per_elem;
 };
 
 /* -------------------------------------------------------------------------- */
 #include "dumper_generic_elemental_field_tmpl.hh"
 /* -------------------------------------------------------------------------- */
 
 __END_AKANTU_DUMPER__ } // akantu
 
 #endif /* __AKANTU_DUMPER_GENERIC_ELEMENTAL_FIELD_HH__ */
diff --git a/src/io/dumper/dumper_generic_elemental_field_tmpl.hh b/src/io/dumper/dumper_generic_elemental_field_tmpl.hh
index e21d67e9d..35b74d555 100644
--- a/src/io/dumper/dumper_generic_elemental_field_tmpl.hh
+++ b/src/io/dumper/dumper_generic_elemental_field_tmpl.hh
@@ -1,67 +1,67 @@
 /**
  * @file   dumper_generic_elemental_field_tmpl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Implementation of the template functions of the ElementalField
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 template<class types, template <class> class iterator>
 void GenericElementalField<types,iterator>::checkHomogeneity() {
-  typedef typename field_type::type_iterator field_type_iterator;
-  typedef typename field_type::array_type array_type;
+  using field_type_iterator = typename field_type::type_iterator;
+  using array_type = typename field_type::array_type;
 
   field_type_iterator tit;
   field_type_iterator end;
 
   tit = field.firstType(spatial_dimension, ghost_type, element_kind);
   end = field.lastType(spatial_dimension, ghost_type, element_kind);
 
   this->nb_total_element = 0;
   UInt nb_comp = 0;
 
   bool homogen = true;
   if(tit != end) {
     nb_comp = this->field(*tit, ghost_type).getNbComponent();
     for(;tit != end; ++tit) {
       const array_type & vect = this->field(*tit, ghost_type);
       UInt nb_element = vect.size();
       UInt nb_comp_cur = vect.getNbComponent();
       if(homogen && nb_comp != nb_comp_cur) homogen = false;
       this->nb_total_element += nb_element;
 
       //      this->nb_data_per_elem(*tit,this->ghost_type) = nb_comp_cur;
     }
 
     if(!homogen) nb_comp = 0;
   }
 
   this->homogeneous = homogen;
 }
 
 /* -------------------------------------------------------------------------- */
diff --git a/src/io/dumper/dumper_homogenizing_field.hh b/src/io/dumper/dumper_homogenizing_field.hh
index 443468e72..ba39b1986 100644
--- a/src/io/dumper/dumper_homogenizing_field.hh
+++ b/src/io/dumper/dumper_homogenizing_field.hh
@@ -1,216 +1,216 @@
 /**
  * @file   dumper_homogenizing_field.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Tue Jul 14 2015
  *
  * @brief  description of field homogenizing field
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_DUMPER_HOMOGENIZING_FIELD_HH__
 #define __AKANTU_DUMPER_HOMOGENIZING_FIELD_HH__
 /* -------------------------------------------------------------------------- */
 #include "dumper_compute.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 __BEGIN_AKANTU_DUMPER__
 
 /* -------------------------------------------------------------------------- */
 
 template <typename type>
 inline type typeConverter(const type & input,
                           __attribute__((unused))
                           Vector<typename type::value_type> & res,
                           __attribute__((unused)) UInt nb_data) {
 
   throw;
   return input;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename type>
 inline Matrix<type> typeConverter(const Matrix<type> & input,
                                   Vector<type> & res, UInt nb_data) {
 
   Matrix<type> tmp(res.storage(), input.rows(), nb_data / input.rows());
   Matrix<type> tmp2(tmp, true);
   return tmp2;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename type>
 inline Vector<type> typeConverter(__attribute__((unused))
                                   const Vector<type> & input,
                                   __attribute__((unused)) Vector<type> & res,
                                   __attribute__((unused)) UInt nb_data) {
 
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename type>
 class AvgHomogenizingFunctor : public ComputeFunctor<type, type> {
 
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 
-  typedef typename type::value_type value_type;
+  using value_type = typename type::value_type;
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
   AvgHomogenizingFunctor(ElementTypeMap<UInt> & nb_datas) {
 
     ElementTypeMap<UInt>::type_iterator tit = nb_datas.firstType();
     ElementTypeMap<UInt>::type_iterator end = nb_datas.lastType();
 
     nb_data = nb_datas(*tit);
 
     for (; tit != end; ++tit)
       if (nb_data != nb_datas(*tit))
         throw;
   }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 
-  type func(const type & d, Element /*global_index*/) {
+  type func(const type & d, Element /*global_index*/) override {
     Vector<value_type> res(this->nb_data);
 
     if (d.size() % this->nb_data)
       throw;
     UInt nb_to_average = d.size() / this->nb_data;
 
     value_type * ptr = d.storage();
     for (UInt i = 0; i < nb_to_average; ++i) {
       Vector<value_type> tmp(ptr, this->nb_data);
       res += tmp;
       ptr += this->nb_data;
     }
     res /= nb_to_average;
     return typeConverter(d, res, this->nb_data);
   };
 
   UInt getDim() override { return nb_data; };
-  UInt getNbComponent(UInt /*old_nb_comp*/) { throw; };
+  UInt getNbComponent(UInt /*old_nb_comp*/) override { throw; };
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 
   /// The size of data: i.e. the size of the vector to be returned
   UInt nb_data;
 };
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 
 class HomogenizerProxy {
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
-  HomogenizerProxy(){};
+  HomogenizerProxy() = default;
 
 public:
   inline static ComputeFunctorInterface * createHomogenizer(Field & field);
 
   template <typename T>
   inline ComputeFunctorInterface * connectToField(T * field) {
     ElementTypeMap<UInt> nb_components = field->getNbComponents();
 
-    typedef typename T::types::return_type ret_type;
+    using ret_type = typename T::types::return_type;
     return this->instantiateHomogenizer<ret_type>(nb_components);
   }
 
   template <typename ret_type>
   inline ComputeFunctorInterface *
   instantiateHomogenizer(ElementTypeMap<UInt> & nb_components);
 };
 
 /* -------------------------------------------------------------------------- */
 
 template <typename ret_type>
 inline ComputeFunctorInterface *
 HomogenizerProxy::instantiateHomogenizer(ElementTypeMap<UInt> & nb_components) {
 
-  typedef dumper::AvgHomogenizingFunctor<ret_type> Homogenizer;
-  Homogenizer * foo = new Homogenizer(nb_components);
+  using Homogenizer = dumper::AvgHomogenizingFunctor<ret_type>;
+  auto * foo = new Homogenizer(nb_components);
   return foo;
 }
 
 template <>
 inline ComputeFunctorInterface *
 HomogenizerProxy::instantiateHomogenizer<Vector<iohelper::ElemType>>(
     __attribute__((unused)) ElementTypeMap<UInt> & nb_components) {
   throw;
   return nullptr;
 }
 
 /* -------------------------------------------------------------------------- */
 
 /// for connection to a FieldCompute
 template <typename SubFieldCompute, typename return_type>
 inline ComputeFunctorInterface *
 FieldCompute<SubFieldCompute, return_type>::connect(HomogenizerProxy & proxy) {
 
   return proxy.connectToField(this);
 }
 /* -------------------------------------------------------------------------- */
 
 inline ComputeFunctorInterface *
 HomogenizerProxy::createHomogenizer(Field & field) {
 
   HomogenizerProxy homogenizer_proxy;
   return field.connect(homogenizer_proxy);
 }
 
 /* -------------------------------------------------------------------------- */
 
 // inline ComputeFunctorInterface & createHomogenizer(Field & field){
 
 //   HomogenizerProxy::createHomogenizer(field);
 //   throw;
 //   ComputeFunctorInterface * ptr = NULL;
 //   return *ptr;
 // }
 
 // /* --------------------------------------------------------------------------
 // */
 
 __END_AKANTU_DUMPER__
 } // namespace akantu
 
 #endif /* __AKANTU_DUMPER_HOMOGENIZING_FIELD_HH__ */
diff --git a/src/io/dumper/dumper_internal_material_field.hh b/src/io/dumper/dumper_internal_material_field.hh
index 72e25e5d2..94028416a 100644
--- a/src/io/dumper/dumper_internal_material_field.hh
+++ b/src/io/dumper/dumper_internal_material_field.hh
@@ -1,78 +1,77 @@
 /**
  * @file   dumper_internal_material_field.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Sep 17 2015
  *
  * @brief  description of material internal field
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_DUMPER_INTERNAL_MATERIAL_FIELD_HH__
 #define __AKANTU_DUMPER_INTERNAL_MATERIAL_FIELD_HH__
 /* -------------------------------------------------------------------------- */
 #include "dumper_quadrature_point_iterator.hh"
 #ifdef AKANTU_IGFEM
 #  include "dumper_igfem_material_internal_field.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 __BEGIN_AKANTU_DUMPER__
 /* -------------------------------------------------------------------------- */
 
 template<typename T, bool filtered = false>
 class InternalMaterialField
   : public GenericElementalField<SingleType<T,Vector,filtered>,
                                  quadrature_point_iterator> {
 
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
-
-  typedef SingleType<T,Vector,filtered> types;
-  typedef GenericElementalField<types,quadrature_point_iterator> parent;
-  typedef typename types::field_type field_type;
+  using types = SingleType<T,Vector,filtered>;
+  using parent = GenericElementalField<types,quadrature_point_iterator>;
+  using field_type = typename types::field_type;
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
 
   InternalMaterialField(const field_type & field,
                         UInt spatial_dimension = _all_dimensions,
                         GhostType ghost_type = _not_ghost,
                         ElementKind element_kind = _ek_not_defined) :
     parent(field, spatial_dimension, ghost_type, element_kind){}
 
 
 };
 
 
 __END_AKANTU_DUMPER__
 } // akantu
 
 #endif /* __AKANTU_DUMPER_INTERNAL_MATERIAL_FIELD_HH__ */
diff --git a/src/io/dumper/dumper_iohelper.cc b/src/io/dumper/dumper_iohelper.cc
index 863cb4f73..61215373b 100644
--- a/src/io/dumper/dumper_iohelper.cc
+++ b/src/io/dumper/dumper_iohelper.cc
@@ -1,302 +1,302 @@
 /**
  * @file   dumper_iohelper.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Oct 26 2012
  * @date last modification: Thu Sep 17 2015
  *
  * @brief  implementation of DumperIOHelper
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <io_helper.hh>
 
 #include "dumper_iohelper.hh"
 #include "dumper_elemental_field.hh"
 #include "dumper_nodal_field.hh"
 #include "dumper_filtered_connectivity.hh"
 #include "dumper_variable.hh"
 #include "mesh.hh"
 #if defined(AKANTU_IGFEM)
 #include "dumper_igfem_connectivity.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
-DumperIOHelper::DumperIOHelper() : count(0), time_activated(false) {}
+DumperIOHelper::DumperIOHelper() {}
 
 /* -------------------------------------------------------------------------- */
 DumperIOHelper::~DumperIOHelper() {
-  for (Fields::iterator it = fields.begin(); it != fields.end(); ++it) {
+  for (auto it = fields.begin(); it != fields.end(); ++it) {
     delete it->second;
   }
 
   delete dumper;
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::setParallelContext(bool is_parallel) {
   UInt whoami  = Communicator::getStaticCommunicator().whoAmI();
   UInt nb_proc = Communicator::getStaticCommunicator().getNbProc();
 
   if(is_parallel)
     dumper->setParallelContext(whoami, nb_proc);
   else
     dumper->setParallelContext(0, 1);
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::setDirectory(const std::string & directory) {
   this->directory = directory;
   dumper->setPrefix(directory);
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::setBaseName(const std::string & basename) {
   filename = basename;
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::setTimeStep(Real time_step) {
   if(!time_activated)
     this->dumper->activateTimeDescFiles(time_step);
   else
     this->dumper->setTimeStep(time_step);
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::dump() {
   try {
     dumper->dump(filename, count);
   } catch (iohelper::IOHelperException & e) {
     AKANTU_DEBUG_ERROR("I was not able to dump your data with a Dumper: " << e.what());
   }
 
   ++count;
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::dump(UInt step) {
   this->count = step;
   this->dump();
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::dump(Real current_time, UInt step) {
   this->dumper->setCurrentTime(current_time);
   this->dump(step);
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::registerMesh(const Mesh & mesh,
 				  UInt spatial_dimension,
 				  const GhostType & ghost_type,
 				  const ElementKind & element_kind) {
 
 #if defined(AKANTU_IGFEM)
   if (element_kind == _ek_igfem) {
     registerField("connectivities",
 		  new dumper::IGFEMConnectivityField(mesh.getConnectivities(),
 						     spatial_dimension,
 						     ghost_type));
   } else
 #endif
   
     registerField("connectivities",
 		  new dumper::ElementalField<UInt>(mesh.getConnectivities(),
 						   spatial_dimension,
 						   ghost_type,
 						   element_kind));
 
   registerField("positions",
 		new dumper::NodalField<Real>(mesh.getNodes()));
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::registerFilteredMesh(const Mesh & mesh,
 					  const ElementTypeMapArray<UInt> & elements_filter,
 					  const Array<UInt> & nodes_filter,
 					  UInt spatial_dimension,
 					  const GhostType & ghost_type,
 					  const ElementKind & element_kind) {
-  ElementTypeMapArrayFilter<UInt> * f_connectivities =
-    new ElementTypeMapArrayFilter<UInt>(mesh.getConnectivities(), elements_filter);
+  auto * f_connectivities = new ElementTypeMapArrayFilter<UInt>(
+      mesh.getConnectivities(), elements_filter);
 
   this->registerField("connectivities",
                       new dumper::FilteredConnectivityField(*f_connectivities,
                                                             nodes_filter,
                                                             spatial_dimension,
                                                             ghost_type,
                                                             element_kind));
 
   this->registerField("positions",new dumper::NodalField<Real,true>(
                                                                     mesh.getNodes(),
                                                                     0,
                                                                     0,
                                                                     &nodes_filter));
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::registerField(const std::string & field_id,
                                    dumper::Field * field) {
-  Fields::iterator it = fields.find(field_id);
+  auto it = fields.find(field_id);
   if(it != fields.end()) {
     AKANTU_DEBUG_WARNING("The field " << field_id
 			 << " is already registered in this Dumper. Field ignored.");
     return;
   }
 
   fields[field_id] = field;
   field->registerToDumper(field_id, *dumper);
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::unRegisterField(const std::string & field_id) {
-  Fields::iterator it = fields.find(field_id);
+  auto it = fields.find(field_id);
   if(it == fields.end()) {
     AKANTU_DEBUG_WARNING("The field " << field_id
 			 << " is not registered in this Dumper. Nothing to do.");
     return;
   }
 
   delete it->second;
   fields.erase(it);
 }
 
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::registerVariable(const std::string & variable_id,
                                       dumper::VariableBase * variable) {
-  Variables::iterator it = variables.find(variable_id);
+  auto it = variables.find(variable_id);
 
   if(it != variables.end()) {
     AKANTU_DEBUG_WARNING("The Variable " << variable_id
 			 << " is already registered in this Dumper. Variable ignored.");
     return;
   }
 
   variables[variable_id] = variable;
   variable->registerToDumper(variable_id, *dumper);
 }
 
 /* -------------------------------------------------------------------------- */
 void DumperIOHelper::unRegisterVariable(const std::string & variable_id) {
-  Variables::iterator it = variables.find(variable_id);
+  auto it = variables.find(variable_id);
 
   if(it == variables.end()) {
     AKANTU_DEBUG_WARNING("The variable " << variable_id
 			 << " is not registered in this Dumper. Nothing to do.");
     return;
   }
 
   delete it->second;
   variables.erase(it);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 iohelper::ElemType getIOHelperType() {
   AKANTU_DEBUG_TO_IMPLEMENT();
   return iohelper::MAX_ELEM_TYPE;
 }
 
 template <>
 iohelper::ElemType getIOHelperType<_point_1>() { return iohelper::POINT_SET; }
 template <>
 iohelper::ElemType getIOHelperType<_segment_2>() { return iohelper::LINE1; }
 template <>
 iohelper::ElemType getIOHelperType<_segment_3>() { return iohelper::LINE2; }
 
 template <>
 iohelper::ElemType getIOHelperType<_triangle_3>() { return iohelper::TRIANGLE1; }
 template <>
 iohelper::ElemType getIOHelperType<_triangle_6>() { return iohelper::TRIANGLE2; }
 
 template <>
 iohelper::ElemType getIOHelperType<_quadrangle_4>() { return iohelper::QUAD1; }
 template <>
 iohelper::ElemType getIOHelperType<_quadrangle_8>() { return iohelper::QUAD2; }
 
 template <>
 iohelper::ElemType getIOHelperType<_tetrahedron_4>()  { return iohelper::TETRA1; }
 template <>
 iohelper::ElemType getIOHelperType<_tetrahedron_10>() { return iohelper::TETRA2; }
 
 template <>
 iohelper::ElemType getIOHelperType<_hexahedron_8>()  { return iohelper::HEX1; }
 template <>
 iohelper::ElemType getIOHelperType<_hexahedron_20>() { return iohelper::HEX2; }
 
 template <>
 iohelper::ElemType getIOHelperType<_pentahedron_6>() { return iohelper::PRISM1; }
 template <>
 iohelper::ElemType getIOHelperType<_pentahedron_15>() { return iohelper::PRISM2; }
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
 template <>
 iohelper::ElemType getIOHelperType<_cohesive_2d_4>() { return iohelper::COH2D4; }
 template <>
 iohelper::ElemType getIOHelperType<_cohesive_2d_6>() { return iohelper::COH2D6; }
 
 template <>
 iohelper::ElemType getIOHelperType<_cohesive_3d_6>() { return iohelper::COH3D6; }
 template <>
 iohelper::ElemType getIOHelperType<_cohesive_3d_12>() { return iohelper::COH3D12; }
 
 template <>
 iohelper::ElemType getIOHelperType<_cohesive_3d_8>() { return iohelper::COH3D8; }
 //template <>
 //iohelper::ElemType getIOHelperType<_cohesive_3d_16>() { return iohelper::COH3D16; }
 #endif
 
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
 template <>
 iohelper::ElemType getIOHelperType<_bernoulli_beam_2>() { return iohelper::BEAM2; }
 template <>
 iohelper::ElemType getIOHelperType<_bernoulli_beam_3>() { return iohelper::BEAM3; }
 #endif
 
 /* -------------------------------------------------------------------------- */
 UInt getIOHelperType(ElementType type) {
   UInt ioh_type = iohelper::MAX_ELEM_TYPE;
 #define GET_IOHELPER_TYPE(type)			\
   ioh_type = getIOHelperType<type>();
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_IOHELPER_TYPE);
 #undef GET_IOHELPER_TYPE
   return ioh_type;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
 
 namespace iohelper {
   template<>
   DataType getDataType<akantu::NodeType>() { return _int; }
 }
diff --git a/src/io/dumper/dumper_iohelper.hh b/src/io/dumper/dumper_iohelper.hh
index c9f70ac01..6934986c5 100644
--- a/src/io/dumper/dumper_iohelper.hh
+++ b/src/io/dumper/dumper_iohelper.hh
@@ -1,158 +1,158 @@
 /**
  * @file   dumper_iohelper.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>
  *
  * @date creation: Fri Oct 26 2012
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  Define the akantu dumper interface for IOhelper dumpers
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_types.hh"
 #include "aka_array.hh"
 #include "element_type_map.hh"
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_DUMPER_IOHELPER_HH__
 #define __AKANTU_DUMPER_IOHELPER_HH__
 /* -------------------------------------------------------------------------- */
 
 namespace iohelper {
 class Dumper;
 }
 
 namespace akantu {
 
 UInt getIOHelperType(ElementType type);
 
 namespace dumper {
 class Field;
 class VariableBase;
 }
 
 class Mesh;
 
 class DumperIOHelper {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   DumperIOHelper();
   virtual ~DumperIOHelper();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// register a given Mesh for the current dumper
   virtual void registerMesh(const Mesh & mesh,
                             UInt spatial_dimension = _all_dimensions,
                             const GhostType & ghost_type = _not_ghost,
                             const ElementKind & element_kind = _ek_not_defined);
 
   /// register a filtered Mesh (provided filter lists) for the current dumper
   virtual void
   registerFilteredMesh(const Mesh & mesh,
                        const ElementTypeMapArray<UInt> & elements_filter,
                        const Array<UInt> & nodes_filter,
                        UInt spatial_dimension = _all_dimensions,
                        const GhostType & ghost_type = _not_ghost,
                        const ElementKind & element_kind = _ek_not_defined);
 
   /// register a Field object identified by name and provided by pointer
   void registerField(const std::string & field_id, dumper::Field * field);
   /// remove the Field identified by name from managed fields
   void unRegisterField(const std::string & field_id);
   /// register a VariableBase object identified by name and provided by pointer
   void registerVariable(const std::string & variable_id,
                         dumper::VariableBase * variable);
   /// remove a VariableBase identified by name from managed fields
   void unRegisterVariable(const std::string & variable_id);
 
   /// request dump: this calls IOHelper dump routine
   virtual void dump();
   /// request dump: this first set the current step and then calls IOHelper dump
   /// routine
   virtual void dump(UInt step);
   /// request dump: this first set the current step and current time and then
   /// calls IOHelper dump routine
   virtual void dump(Real current_time, UInt step);
   /// set the parallel context for IOHeper
   virtual void setParallelContext(bool is_parallel);
   /// set the directory where to generate the dumped files
   virtual void setDirectory(const std::string & directory);
   /// set the base name (needed by most IOHelper dumpers)
   virtual void setBaseName(const std::string & basename);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// direct access to the iohelper::Dumper object
   AKANTU_GET_MACRO(Dumper, *dumper, iohelper::Dumper &)
 
   /// set the timestep of the iohelper::Dumper
   void setTimeStep(Real time_step);
 
 public:
   /* ------------------------------------------------------------------------ */
   /* Variable wrapper */
   template <typename T, bool is_scal = std::is_arithmetic<T>::value> class Variable;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// internal iohelper::Dumper
   iohelper::Dumper * dumper;
 
   typedef std::map<std::string, dumper::Field *> Fields;
   typedef std::map<std::string, dumper::VariableBase *> Variables;
 
   /// list of registered fields to dump
   Fields fields;
   Variables variables;
 
   /// dump counter
-  UInt count;
+  UInt count{0};
 
   /// directory name
   std::string directory;
 
   /// filename prefix
   std::string filename;
 
   /// is time tracking activated in the dumper
-  bool time_activated;
+  bool time_activated{false};
 };
 
 } // akantu
 
 #endif /* __AKANTU_DUMPER_IOHELPER_HH__ */
diff --git a/src/io/dumper/dumper_nodal_field.hh b/src/io/dumper/dumper_nodal_field.hh
index e01599dcf..c894ce307 100644
--- a/src/io/dumper/dumper_nodal_field.hh
+++ b/src/io/dumper/dumper_nodal_field.hh
@@ -1,249 +1,250 @@
 /**
  * @file   dumper_nodal_field.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Oct 26 2012
  * @date last modification: Tue Jan 06 2015
  *
  * @brief  Description of nodal fields
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_DUMPER_NODAL_FIELD_HH__
 #define __AKANTU_DUMPER_NODAL_FIELD_HH__
 
 #include "dumper_field.hh"
 #include <io_helper.hh>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 __BEGIN_AKANTU_DUMPER__
 
 // This represents a iohelper compatible field
 template<typename T, bool filtered = false,
 	 class Container = Array<T>, class Filter = Array<UInt> >
 class NodalField;
 
 /* -------------------------------------------------------------------------- */
 template<typename T, class Container, class Filter>
 class NodalField<T, false, Container, Filter> : public dumper::Field {
 public:
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */  
  
   /// associated iterator with any nodal field (non filetered)
   class iterator : public iohelper::iterator< T, iterator, Vector<T> > {
   public:
     iterator(T * vect, UInt offset, UInt n, UInt stride,
              __attribute__((unused)) const UInt * filter = nullptr)
         :
 
           internal_it(vect), offset(offset), n(n), stride(stride) {}
 
     bool operator!=(const iterator & it) const override {
       return internal_it != it.internal_it;
     }
     iterator & operator++() override {
       internal_it += offset;
       return *this;
     };
     Vector<T> operator*() override {
       return Vector<T>(internal_it + stride, n);
     };
 
   private:
     T * internal_it;
     UInt offset, n, stride;
   };
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
   NodalField(const Container & field, UInt n = 0, UInt stride = 0,
-	     __attribute__ ((unused)) const Filter * filter = NULL) :
+             __attribute__((unused)) const Filter * filter = nullptr)
+      :
 
-    field(field), n(n), stride(stride), padding(0) {
+        field(field), n(n), stride(stride), padding(0) {
     AKANTU_DEBUG_ASSERT(filter == nullptr,
                         "Filter passed to unfiltered NodalField!");
     if(n == 0) { this->n = field.getNbComponent() - stride; }
   }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 
   void registerToDumper(const std::string & id,
                         iohelper::Dumper & dumper) override {
     dumper.addNodeDataField(id, *this);
   }
 
   inline iterator begin() {
     return iterator(field.storage(), field.getNbComponent(), n, stride);
   }
 
   inline iterator end  () {
     return iterator(field.storage() + field.getNbComponent()*field.size(),
 		    field.getNbComponent(), n, stride);
   }
 
   bool isHomogeneous() override { return true; }
   void checkHomogeneity() override { this->homogeneous = true; }
 
   virtual UInt getDim() {
     if(this->padding) return this->padding;
     else              return n;
   }
 
   void setPadding(UInt padding){this->padding = padding;}
 
   UInt size() { return field.size(); }
 
   iohelper::DataType getDataType() { return iohelper::getDataType<T>(); }
 
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
   
 
 private:
   const Container & field;
   UInt n, stride;
   UInt padding;
 };
 
 
 
 /* -------------------------------------------------------------------------- */
 template<typename T, class Container, class Filter>
 class NodalField<T, true, Container, Filter> : public dumper::Field {
 
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */  
   
 public:
   class iterator : public iohelper::iterator< T, iterator, Vector<T> > {
 
   public:
     iterator(T * const vect, UInt _offset, UInt _n, 
 	     UInt _stride, const UInt * filter) :
 
       internal_it(vect), offset(_offset), n(_n), stride(_stride),
       filter(filter) {}
 
     bool operator!=(const iterator & it) const override {
       return filter != it.filter;
     }
 
     iterator & operator++() override {
       ++filter;
       return *this;
     }
 
     Vector<T> operator*() override {
       return Vector<T>(internal_it + *(filter)*offset + stride, n);
     }
   private:
     T * const internal_it;
     UInt offset, n, stride;
     const UInt * filter;
   };
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
   NodalField(const Container & _field,
              UInt _n = 0, UInt _stride = 0,
              const Filter * filter = NULL)
     : field(_field), n(_n), stride(_stride), filter(filter), padding(0) {
     AKANTU_DEBUG_ASSERT(this->filter != nullptr,
                         "No filter passed to filtered NodalField!");
 
     AKANTU_DEBUG_ASSERT(this->filter->getNbComponent()==1, 
 			"Multi-component filter given to NodalField (" 
 			<< this->filter->getNbComponent() 
 			<< " components detected, sould be 1");
     if(n == 0) {
       this->n = field.getNbComponent() - stride;
     }
   }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 
   void registerToDumper(const std::string & id,
                         iohelper::Dumper & dumper) override {
     dumper.addNodeDataField(id, *this);
   }
 
   inline iterator begin() {
     return iterator(field.storage(), field.getNbComponent(), 
 		    n, stride, filter->storage());
   }
 
   inline iterator end() {
     return iterator(field.storage(), field.getNbComponent(), 
 		    n, stride, filter->storage()+filter->size());
   }
 
   bool isHomogeneous() override { return true; }
   void checkHomogeneity() override { this->homogeneous = true; }
 
   virtual UInt getDim() {
     if(this->padding) return this->padding;
     else              return n;
   }
 
   void setPadding(UInt padding){this->padding = padding;}
 
   UInt size() {
     return filter->size();
   }
 
   iohelper::DataType getDataType() {
     return iohelper::getDataType<T>();
   }
 
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
   
 private:
   const Container & field;
   UInt n, stride;
   const Filter * filter;
 
   UInt padding;
 };
 
  
 __END_AKANTU_DUMPER__
 } // akantu
 /* -------------------------------------------------------------------------- */
 #endif /* __AKANTU_DUMPER_NODAL_FIELD_HH__ */
diff --git a/src/io/dumper/dumper_paraview.cc b/src/io/dumper/dumper_paraview.cc
index dd39653fa..ce2f04e42 100644
--- a/src/io/dumper/dumper_paraview.cc
+++ b/src/io/dumper/dumper_paraview.cc
@@ -1,66 +1,66 @@
 /**
  * @file   dumper_paraview.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Sep 26 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  implementations of DumperParaview
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <io_helper.hh>
 
 #include "communicator.hh"
 #include "dumper_paraview.hh"
 #include <fstream>
 
 namespace akantu {
 
 DumperParaview::DumperParaview(const std::string & filename,
                                const std::string & directory, bool parallel)
     : DumperIOHelper() {
   iohelper::DumperParaview * dumper_para = new iohelper::DumperParaview();
   dumper = dumper_para;
   setBaseName(filename);
 
   this->setParallelContext(parallel);
 
   dumper_para->setMode(iohelper::BASE64);
   dumper_para->setPrefix(directory);
   dumper_para->init();
 }
 
 /* -------------------------------------------------------------------------- */
-DumperParaview::~DumperParaview() {}
+DumperParaview::~DumperParaview() = default;
 
 /* -------------------------------------------------------------------------- */
 void DumperParaview::setBaseName(const std::string & basename) {
   DumperIOHelper::setBaseName(basename);
   static_cast<iohelper::DumperParaview *>(dumper)->setVTUSubDirectory(filename +
                                                                       "-VTU");
 }
 
 } // namespace akantu
diff --git a/src/io/dumper/dumper_quadrature_point_iterator.hh b/src/io/dumper/dumper_quadrature_point_iterator.hh
index 2bd3f6699..52156376f 100644
--- a/src/io/dumper/dumper_quadrature_point_iterator.hh
+++ b/src/io/dumper/dumper_quadrature_point_iterator.hh
@@ -1,77 +1,74 @@
 /**
  * @file   dumper_quadrature_point_iterator.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Thu Sep 17 2015
  *
  * @brief  Description of quadrature point iterator
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_DUMPER_QUADRATURE_POINT_ITERATOR_HH__
 #define __AKANTU_DUMPER_QUADRATURE_POINT_ITERATOR_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "dumper_elemental_field.hh"
 
 namespace akantu {
 __BEGIN_AKANTU_DUMPER__
 
 /* -------------------------------------------------------------------------- */
-template<typename types>
+template <typename types>
 class quadrature_point_iterator
-   : public element_iterator<types, quadrature_point_iterator> {
+    : public element_iterator<types, quadrature_point_iterator> {
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-
-  typedef element_iterator<types, dumper::quadrature_point_iterator> parent;
-  typedef typename types::data_type   data_type;
-  typedef typename types::return_type return_type;
-  typedef typename types::field_type  field_type;
-  typedef typename types::array_iterator array_iterator;
+  using parent = element_iterator<types, dumper::quadrature_point_iterator>;
+  using data_type = typename types::data_type;
+  using return_type = typename types::return_type;
+  using field_type = typename types::field_type;
+  using array_iterator = typename types::array_iterator;
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   quadrature_point_iterator(const field_type & field,
-			    const typename field_type::type_iterator & t_it,
-			    const typename field_type::type_iterator & t_it_end,
-			    const array_iterator & array_it,
-			    const array_iterator & array_it_end,
-			    const GhostType ghost_type = _not_ghost) :
-    parent(field, t_it, t_it_end, array_it, array_it_end, ghost_type) { }
+                            const typename field_type::type_iterator & t_it,
+                            const typename field_type::type_iterator & t_it_end,
+                            const array_iterator & array_it,
+                            const array_iterator & array_it_end,
+                            const GhostType ghost_type = _not_ghost)
+      : parent(field, t_it, t_it_end, array_it, array_it_end, ghost_type) {}
 
-  return_type operator*() {
-    return *this->array_it;
-  }
+  return_type operator*() { return *this->array_it; }
 };
 
 /* -------------------------------------------------------------------------- */
 
 __END_AKANTU_DUMPER__
-} // akantu
+} // namespace akantu
 
 #endif /* __AKANTU_DUMPER_QUADRATURE_POINT_ITERATOR_HH__ */
diff --git a/src/io/dumper/dumper_text.hh b/src/io/dumper/dumper_text.hh
index 8a367d021..7758e2e54 100644
--- a/src/io/dumper/dumper_text.hh
+++ b/src/io/dumper/dumper_text.hh
@@ -1,88 +1,89 @@
 /**
  * @file   dumper_text.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  to dump into a text file
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dumper_iohelper.hh"
 /* -------------------------------------------------------------------------- */
 #ifndef __AKANTU_DUMPER_TEXT_HH__
 #define __AKANTU_DUMPER_TEXT_HH__
 /* -------------------------------------------------------------------------- */
 #include <io_helper.hh>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 class DumperText : public DumperIOHelper {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
 
   DumperText(const std::string & basename = "dumper_text",
 	     iohelper::TextDumpMode mode = iohelper::_tdm_space,
 	     bool parallel = true);
-  virtual ~DumperText() {};
+  ~DumperText() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
-  virtual void registerMesh(const Mesh & mesh, UInt spatial_dimension = _all_dimensions,
-			    const GhostType & ghost_type = _not_ghost,
-			    const ElementKind & element_kind = _ek_not_defined);
+  void
+  registerMesh(const Mesh & mesh, UInt spatial_dimension = _all_dimensions,
+               const GhostType & ghost_type = _not_ghost,
+               const ElementKind & element_kind = _ek_not_defined) override;
 
-  virtual void registerFilteredMesh(const Mesh & mesh,
-				    const ElementTypeMapArray<UInt> & elements_filter,
-				    const Array<UInt> & nodes_filter,
-				    UInt spatial_dimension = _all_dimensions,
-				    const GhostType & ghost_type = _not_ghost,
-				    const ElementKind & element_kind = _ek_not_defined);
+  void registerFilteredMesh(
+      const Mesh & mesh, const ElementTypeMapArray<UInt> & elements_filter,
+      const Array<UInt> & nodes_filter,
+      UInt spatial_dimension = _all_dimensions,
+      const GhostType & ghost_type = _not_ghost,
+      const ElementKind & element_kind = _ek_not_defined) override;
 
-  virtual void setBaseName(const std::string & basename);
+  void setBaseName(const std::string & basename) override;
 
 private:
   void registerNodeTypeField();
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   void setPrecision(UInt prec);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
 };
 
 } // akantu
 
 #endif /* __AKANTU_DUMPER_TEXT_HH__ */
diff --git a/src/io/dumper/dumper_type_traits.hh b/src/io/dumper/dumper_type_traits.hh
index d9b1b33ad..83e63954e 100644
--- a/src/io/dumper/dumper_type_traits.hh
+++ b/src/io/dumper/dumper_type_traits.hh
@@ -1,99 +1,99 @@
 /**
  * @file   dumper_type_traits.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Mon Sep 21 2015
  *
  * @brief  Type traits for field properties
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_DUMPER_TYPE_TRAITS_HH__
 #define __AKANTU_DUMPER_TYPE_TRAITS_HH__
 /* -------------------------------------------------------------------------- */
 #include "element_type_map.hh"
 #include "element_type_map_filter.hh"
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 __BEGIN_AKANTU_DUMPER__
 /* -------------------------------------------------------------------------- */
 
 template <class data, class ret, class field>
 struct TypeTraits {
 
   //! the stored data (real, int, uint, ...)
-  typedef data  data_type;
+  using data_type = data;
   //! the type returned by the operator *
-  typedef ret   return_type;
+  using return_type = ret;
   //! the field type (ElementTypeMap or ElementTypeMapFilter)
-  typedef field field_type;
+  using field_type = field;
   //! the type over which we iterate
-  typedef typename field_type::type it_type;
+  using it_type = typename field_type::type;
   //! the type of array (Array<T> or ArrayFilter<T>)
-  typedef typename field_type::array_type array_type;
+  using array_type = typename field_type::array_type;
   //! the iterator over the array
-  typedef typename array_type::const_vector_iterator array_iterator;
+  using array_iterator = typename array_type::const_vector_iterator;
 };
 
 /* -------------------------------------------------------------------------- */
 
 // specialization for the case in which input and output types are the same
 template <class T, template <class> class ret, bool filtered>
 struct SingleType
   : public TypeTraits<T,ret<T>,ElementTypeMapArray<T> >{
   
 };
 
 /* -------------------------------------------------------------------------- */
 
 // same as before but for filtered data
 template <class T, template <class> class ret>
 struct SingleType<T,ret,true> : 
   public TypeTraits<T,ret<T>, ElementTypeMapArrayFilter<T> >{
   
 };
 /* -------------------------------------------------------------------------- */
 
 // specialization for the case in which input and output types are different
 template <class it_type, class data_type, template <class> class ret, 
 	  bool filtered>
 struct DualType
   : public TypeTraits<data_type,ret<data_type>, ElementTypeMapArray<it_type> >{
 };
 
 /* -------------------------------------------------------------------------- */
 
 // same as before but for filtered data
 template <class it_type, class data_type,template <class> class ret>
 struct DualType<it_type,data_type,ret,true> : 
   public TypeTraits<data_type,ret<data_type>, ElementTypeMapArrayFilter<it_type> >{
   
 };
 /* -------------------------------------------------------------------------- */
 __END_AKANTU_DUMPER__
 } // akantu
 
 /* -------------------------------------------------------------------------- */
 
 
 #endif /* __AKANTU_DUMPER_TYPE_TRAITS_HH__ */
diff --git a/src/io/dumper/dumper_variable.hh b/src/io/dumper/dumper_variable.hh
index 498ea37c9..770afb217 100644
--- a/src/io/dumper/dumper_variable.hh
+++ b/src/io/dumper/dumper_variable.hh
@@ -1,118 +1,116 @@
 /**
  * @file   dumper_variable.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Tue Jun 04 2013
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  template of variable
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
+/* -------------------------------------------------------------------------- */
+#include "aka_common.hh"
+#include <type_traits>
+
 
 /* -------------------------------------------------------------------------- */
 #ifndef __AKANTU_DUMPER_IOHELPER_TMPL_VARIABLE_HH__
 #define __AKANTU_DUMPER_IOHELPER_TMPL_VARIABLE_HH__
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
-__BEGIN_AKANTU_DUMPER__
+namespace dumper {
 /* -------------------------------------------------------------------------- */
 
 /// Variable interface
-  class VariableBase {
+class VariableBase {
 public:
-  VariableBase() {};
-  virtual ~VariableBase() {};
-  virtual void registerToDumper(const std::string & id, iohelper::Dumper & dumper) = 0;
+  VariableBase() = default;
+  virtual ~VariableBase() = default;
+  virtual void registerToDumper(const std::string & id,
+                                iohelper::Dumper & dumper) = 0;
 };
 
 /* -------------------------------------------------------------------------- */
 
-
-template<typename T, bool is_scal = is_scalar<T>::value >
+template <typename T, bool is_scal = std::is_arithmetic<T>::value>
 class Variable : public VariableBase {
 public:
   Variable(const T & t) : vari(t) {}
 
-  virtual void registerToDumper(const std::string & id,
-				iohelper::Dumper & dumper) {
+  void registerToDumper(const std::string & id,
+                        iohelper::Dumper & dumper) override {
     dumper.addVariable(id, *this);
   }
 
-  const T & operator[](UInt i) const {
-    return vari[i];
-  }
+  const T & operator[](UInt i) const { return vari[i]; }
 
   UInt getDim() { return vari.size(); }
   iohelper::DataType getDataType() { return iohelper::getDataType<T>(); }
+
 protected:
   const T & vari;
 };
 
 /* -------------------------------------------------------------------------- */
-template<typename T>
-class Variable<Vector<T>, false> : public VariableBase {
+template <typename T> class Variable<Vector<T>, false> : public VariableBase {
 public:
   Variable(const Vector<T> & t) : vari(t) {}
 
-  virtual void registerToDumper(const std::string & id,
-				iohelper::Dumper & dumper) {
+  void registerToDumper(const std::string & id,
+                        iohelper::Dumper & dumper) override {
     dumper.addVariable(id, *this);
   }
 
-  const T & operator[](UInt i) const {
-    return vari[i];
-  }
+  const T & operator[](UInt i) const { return vari[i]; }
 
   UInt getDim() { return vari.size(); }
   iohelper::DataType getDataType() { return iohelper::getDataType<T>(); }
-    
+
 protected:
   const Vector<T> & vari;
 };
 
 /* -------------------------------------------------------------------------- */
 
-template<typename T>
-class Variable<T, true> : public VariableBase {
+template <typename T> class Variable<T, true> : public VariableBase {
 public:
   Variable(const T & t) : vari(t) {}
 
-  virtual void registerToDumper(const std::string & id,
-				iohelper::Dumper & dumper) {
+  void registerToDumper(const std::string & id,
+                        iohelper::Dumper & dumper) override {
     dumper.addVariable(id, *this);
   }
 
-  const T & operator[](__attribute__((unused)) UInt i) const {
-    return vari;
-  }
+  const T & operator[](__attribute__((unused)) UInt i) const { return vari; }
 
   UInt getDim() { return 1; }
   iohelper::DataType getDataType() { return iohelper::getDataType<T>(); }
+
 protected:
   const T & vari;
 };
 
-__END_AKANTU_DUMPER__
-} // akantu
+} // namespace dumper
+} // namespace akantu
 
 #endif /* __AKANTU_DUMPER_IOHELPER_TMPL_VARIABLE_HH__ */
diff --git a/src/io/mesh_io.cc b/src/io/mesh_io.cc
index 904c4f42e..cdc56a716 100644
--- a/src/io/mesh_io.cc
+++ b/src/io/mesh_io.cc
@@ -1,148 +1,148 @@
 /**
  * @file   mesh_io.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Mon Jun 01 2015
  *
  * @brief  common part for all mesh io classes
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "mesh_io.hh"
 #include "aka_common.hh"
 #include "aka_iterators.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 MeshIO::MeshIO() {
   canReadSurface = false;
   canReadExtendedData = false;
 }
 
 /* -------------------------------------------------------------------------- */
-MeshIO::~MeshIO() {}
+MeshIO::~MeshIO() = default;
 
 /* -------------------------------------------------------------------------- */
 std::unique_ptr<MeshIO> MeshIO::getMeshIO(const std::string & filename,
                                           const MeshIOType & type) {
   MeshIOType t = type;
   if (type == _miot_auto) {
     std::string::size_type idx = filename.rfind('.');
     std::string ext;
     if (idx != std::string::npos) {
       ext = filename.substr(idx + 1);
     }
 
     if (ext == "msh") {
       t = _miot_gmsh;
     } else if (ext == "diana") {
       t = _miot_diana;
     } else if (ext == "inp") {
       t = _miot_abaqus;
     } else
       AKANTU_EXCEPTION("Cannot guess the type of file of "
                        << filename << " (ext " << ext << "). "
                        << "Please provide the MeshIOType to the read function");
   }
 
   switch (t) {
   case _miot_gmsh:
     return std::make_unique<MeshIOMSH>();
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
   case _miot_gmsh_struct:
     return std::make_unique<MeshIOMSHStruct>();
 #endif
   case _miot_diana:
     return std::make_unique<MeshIODiana>();
   case _miot_abaqus:
     return std::make_unique<MeshIOAbaqus>();
   default:
     return nullptr;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIO::read(const std::string & filename, Mesh & mesh,
                   const MeshIOType & type) {
   std::unique_ptr<MeshIO> mesh_io = getMeshIO(filename, type);
   mesh_io->read(filename, mesh);
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIO::write(const std::string & filename, Mesh & mesh,
                    const MeshIOType & type) {
   std::unique_ptr<MeshIO> mesh_io = getMeshIO(filename, type);
   mesh_io->write(filename, mesh);
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIO::constructPhysicalNames(const std::string & tag_name, Mesh & mesh) {
   if (!phys_name_map.empty()) {
     for (Mesh::type_iterator type_it = mesh.firstType();
          type_it != mesh.lastType(); ++type_it) {
 
       auto & name_vec =
           mesh.getDataPointer<std::string>("physical_names", *type_it);
 
       const auto & tags_vec = mesh.getData<UInt>(tag_name, *type_it);
 
       for (auto pair : zip(tags_vec, name_vec)) {
         auto tag = std::get<0>(pair);
         auto & name = std::get<1>(pair);
         auto map_it = phys_name_map.find(tag);
 
         if (map_it == phys_name_map.end()) {
           std::stringstream sstm;
           sstm << tag;
 
           name = sstm.str();
         } else {
           name = map_it->second;
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIO::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   if (phys_name_map.size()) {
     stream << space << "Physical map:" << std::endl;
     for (auto & pair : phys_name_map) {
       stream << space << pair.first << ": " << pair.second << std::endl;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/io/mesh_io/mesh_io_abaqus.cc b/src/io/mesh_io/mesh_io_abaqus.cc
index 8f9a5c4d0..658ba77f7 100644
--- a/src/io/mesh_io/mesh_io_abaqus.cc
+++ b/src/io/mesh_io/mesh_io_abaqus.cc
@@ -1,476 +1,475 @@
 /**
  * @file   mesh_io_abaqus.cc
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jan 04 2013
  * @date last modification: Fri Dec 11 2015
  *
  * @brief  read a mesh from an abaqus input file
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 // std library header files
 #include <fstream>
 
 // akantu header files
 #include "mesh.hh"
 #include "mesh_io_abaqus.hh"
 #include "mesh_utils.hh"
 
 #include "element_group.hh"
 #include "node_group.hh"
 
 #if defined(__INTEL_COMPILER)
 //#pragma warning ( disable : 383 )
 #elif defined(__clang__) // test clang to be sure that when we test for gnu it
                          // is only gnu
 #elif (defined(__GNUC__) || defined(__GNUG__))
 #define GCC_VERSION                                                            \
   (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
 #if GCC_VERSION > 40600
 #pragma GCC diagnostic push
 #endif
 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
 #endif
 
 /* -------------------------------------------------------------------------- */
 #include <boost/config/warning_disable.hpp>
 #include <boost/spirit/include/phoenix.hpp>
 #include <boost/spirit/include/qi.hpp>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
-MeshIOAbaqus::MeshIOAbaqus() {}
+MeshIOAbaqus::MeshIOAbaqus() = default;
 
 /* -------------------------------------------------------------------------- */
-MeshIOAbaqus::~MeshIOAbaqus() {}
+MeshIOAbaqus::~MeshIOAbaqus() = default;
 
 /* -------------------------------------------------------------------------- */
 namespace spirit = boost::spirit;
 namespace qi = boost::spirit::qi;
 namespace ascii = boost::spirit::ascii;
 namespace lbs = boost::spirit::qi::labels;
 namespace phx = boost::phoenix;
 
 /* -------------------------------------------------------------------------- */
 void element_read(Mesh & mesh, const ElementType & type, UInt id,
                   const std::vector<Int> & conn,
                   const std::map<UInt, UInt> & nodes_mapping,
                   std::map<UInt, Element> & elements_mapping) {
   Vector<UInt> tmp_conn(Mesh::getNbNodesPerElement(type));
 
   AKANTU_DEBUG_ASSERT(conn.size() == tmp_conn.size(),
                       "The nodes in the Abaqus file have too many coordinates"
                           << " for the mesh you try to fill.");
 
   mesh.addConnectivityType(type);
   Array<UInt> & connectivity = mesh.getConnectivity(type);
 
   UInt i = 0;
-  for (std::vector<Int>::const_iterator it = conn.begin(); it != conn.end();
-       ++it) {
-    std::map<UInt, UInt>::const_iterator nit = nodes_mapping.find(*it);
+  for (auto it = conn.begin(); it != conn.end(); ++it) {
+    auto nit = nodes_mapping.find(*it);
     AKANTU_DEBUG_ASSERT(nit != nodes_mapping.end(),
                         "There is an unknown node in the connectivity.");
     tmp_conn[i++] = nit->second;
   }
   Element el{type, connectivity.size(), _not_ghost};
   elements_mapping[id] = el;
   connectivity.push_back(tmp_conn);
 }
 
 void node_read(Mesh & mesh, UInt id, const std::vector<Real> & pos,
                std::map<UInt, UInt> & nodes_mapping) {
   Vector<Real> tmp_pos(mesh.getSpatialDimension());
   UInt i = 0;
-  for (std::vector<Real>::const_iterator it = pos.begin();
-       it != pos.end() || i < mesh.getSpatialDimension(); ++it)
+  for (auto it = pos.begin(); it != pos.end() || i < mesh.getSpatialDimension();
+       ++it)
     tmp_pos[i++] = *it;
 
   nodes_mapping[id] = mesh.getNbNodes();
   mesh.getNodes().push_back(tmp_pos);
 }
 
 /* ------------------------------------------------------------------------ */
 void add_element_to_group(ElementGroup * el_grp, UInt element,
                           const std::map<UInt, Element> & elements_mapping) {
-  std::map<UInt, Element>::const_iterator eit = elements_mapping.find(element);
+  auto eit = elements_mapping.find(element);
   AKANTU_DEBUG_ASSERT(eit != elements_mapping.end(),
                       "There is an unknown element ("
                           << element << ") in the in the ELSET "
                           << el_grp->getName() << ".");
 
   el_grp->add(eit->second, true, false);
 }
 
 ElementGroup * element_group_create(Mesh & mesh, const ID & name) {
-  Mesh::element_group_iterator eg_it = mesh.element_group_find(name);
+  auto eg_it = mesh.element_group_find(name);
   if (eg_it != mesh.element_group_end()) {
     return eg_it->second;
   } else {
     return &mesh.createElementGroup(name, _all_dimensions);
   }
 }
 
 NodeGroup * node_group_create(Mesh & mesh, const ID & name) {
-  Mesh::node_group_iterator ng_it = mesh.node_group_find(name);
+  auto ng_it = mesh.node_group_find(name);
   if (ng_it != mesh.node_group_end()) {
     return ng_it->second;
   } else {
     return &mesh.createNodeGroup(name, mesh.getSpatialDimension());
   }
 }
 
 void add_node_to_group(NodeGroup * node_grp, UInt node,
                        const std::map<UInt, UInt> & nodes_mapping) {
-  std::map<UInt, UInt>::const_iterator nit = nodes_mapping.find(node);
+  auto nit = nodes_mapping.find(node);
 
   AKANTU_DEBUG_ASSERT(nit != nodes_mapping.end(),
                       "There is an unknown node in the in the NSET "
                           << node_grp->getName() << ".");
 
   node_grp->add(nit->second, false);
 }
 
 void optimize_group(NodeGroup * grp) { grp->optimize(); }
 void optimize_element_group(ElementGroup * grp) { grp->optimize(); }
 
 /* -------------------------------------------------------------------------- */
 template <class Iterator> struct AbaqusSkipper : qi::grammar<Iterator> {
   AbaqusSkipper() : AbaqusSkipper::base_type(skip, "abaqus_skipper") {
     /* clang-format off */
     skip
       =   (ascii::space - spirit::eol)
       |   "**" >> *(qi::char_ - spirit::eol) >> spirit::eol
       ;
     /* clang-format on */
   }
   qi::rule<Iterator> skip;
 };
 
 /* -------------------------------------------------------------------------- */
 template <class Iterator, typename Skipper = AbaqusSkipper<Iterator>>
 struct AbaqusMeshGrammar : qi::grammar<Iterator, void(), Skipper> {
 public:
   AbaqusMeshGrammar(Mesh & mesh)
       : AbaqusMeshGrammar::base_type(start, "abaqus_mesh_reader"), mesh(mesh) {
 
     /* clang-format off */
     start
       =  *(
              (qi::char_('*')
                 >  (   (qi::no_case[ qi::lit("node output")    ] > any_section)
                    |   (qi::no_case[ qi::lit("element output") ] > any_section)
                    |   (qi::no_case[ qi::lit("node")           ] > nodes)
                    |   (qi::no_case[ qi::lit("element")        ] > elements)
                    |   (qi::no_case[ qi::lit("heading")        ] > header)
                    |   (qi::no_case[ qi::lit("elset")          ] > elements_set)
                    |   (qi::no_case[ qi::lit("nset")           ] > nodes_set)
                    |   (qi::no_case[ qi::lit("material")       ] > material)
                    |   (keyword > any_section)
                    )
              )
           |  spirit::eol
           )
       ;
 
     header
       =   spirit::eol
       >   *any_line
       ;
 
     nodes
       =   *(qi::char_(',') >> option)
            >> spirit::eol
            >> *( (qi::int_
                   > node_position) [ phx::bind(&node_read,
                                                  phx::ref(mesh),
                                                  lbs::_1,
                                                  lbs::_2,
                                                  phx::ref(abaqus_nodes_to_akantu)) ]
                   >> spirit::eol
                )
       ;
 
     elements
       =   (
              (  qi::char_(',') >> qi::no_case[qi::lit("type")] >> '='
                 >> abaqus_element_type  [ lbs::_a = lbs::_1 ]
              )
           ^  *(qi::char_(',') >> option)
           )
           >> spirit::eol
           >> *(  (qi::int_
                   > connectivity) [ phx::bind(&element_read,
                                                 phx::ref(mesh),
                                                 lbs::_a,
                                                 lbs::_1,
                                                 lbs::_2,
                                                 phx::cref(abaqus_nodes_to_akantu),
                                                 phx::ref(abaqus_elements_to_akantu)) ]
                  >> spirit::eol
                )
       ;
 
     elements_set
       =   (
              (
                 (  qi::char_(',') >> qi::no_case[ qi::lit("elset") ] >> '='
                    >> value [ lbs::_a = phx::bind<ElementGroup *>(&element_group_create,
                                                                     phx::ref(mesh),
                                                                     lbs::_1) ]
                 )
              ^  *(qi::char_(',') >> option)
              )
              >> spirit::eol
              >> qi::skip
                   (qi::char_(',') | qi::space)
              [ +(qi::int_ [ phx::bind(&add_element_to_group,
                                         lbs::_a,
                                         lbs::_1,
                                         phx::cref(abaqus_elements_to_akantu)
                                         )
                                ]
                      )
                  ]
            ) [ phx::bind(&optimize_element_group, lbs::_a) ]
       ;
 
     nodes_set
       =   (
              (
                 (  qi::char_(',')
                    >> qi::no_case[ qi::lit("nset") ] >> '='
                    >> value [ lbs::_a = phx::bind<NodeGroup *>(&node_group_create, phx::ref(mesh), lbs::_1) ]
                 )
              ^  *(qi::char_(',') >> option)
              )
              >> spirit::eol
              >> qi::skip
                  (qi::char_(',') | qi::space)
                  [ +(qi::int_ [ phx::bind(&add_node_to_group,
                                             lbs::_a,
                                             lbs::_1,
                                             phx::cref(abaqus_nodes_to_akantu)
                                            )
                               ]
                     )
                  ]
            ) [ phx::bind(&optimize_group, lbs::_a) ]
       ;
 
     material
       =   (
              (  qi::char_(',') >> qi::no_case[ qi::lit("name") ] >> '='
                 >> value  [ phx::push_back(phx::ref(material_names), lbs::_1) ]
              )
           ^  *(qi::char_(',') >> option)
           ) >> spirit::eol;
       ;
 
     node_position
       =   +(qi::char_(',') > real [ phx::push_back(lbs::_val, lbs::_1) ])
       ;
 
     connectivity
       = +(qi::char_(',') > qi::int_ [ phx::push_back(lbs::_val, lbs::_1) ])
       ;
 
 
     any_section
       =   *(qi::char_(',') >> option) > spirit::eol
       >   *any_line
       ;
 
     any_line
       =   *(qi::char_ - spirit::eol - qi::char_('*')) >> spirit::eol
       ;
 
     keyword
       =   qi::lexeme[ +(qi::char_ - (qi::char_('*') | spirit::eol)) ]
       ;
 
     option
       = key > -( '=' >> value );
 
     key
       =   qi::char_("a-zA-Z_") >> *(qi::char_("a-zA-Z_0-9") | qi::char_('-'))
       ;
 
     value
       =   key.alias()
       ;
 
     BOOST_SPIRIT_DEBUG_NODE(start);
 
     abaqus_element_type.add
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
       ("BE21"  , _bernoulli_beam_2)
       ("BE31"  , _bernoulli_beam_3)
 #endif
       ("T3D2"  , _segment_2) // Gmsh generates this elements
       ("T3D3"  , _segment_3) // Gmsh generates this elements
       ("CPE3"  , _triangle_3)
       ("CPS3"  , _triangle_3)
       ("DC2D3" , _triangle_3)
       ("CPE6"  , _triangle_6)
       ("CPS6"  , _triangle_6)
       ("DC2D6" , _triangle_6)
       ("CPE4"  , _quadrangle_4)
       ("CPS4"  , _quadrangle_4)
       ("DC2D4" , _quadrangle_4)
       ("CPE8"  , _quadrangle_8)
       ("CPS8"  , _quadrangle_8)
       ("DC2D8" , _quadrangle_8)
       ("C3D4"  , _tetrahedron_4)
       ("DC3D4" , _tetrahedron_4)
       ("C3D8"  , _hexahedron_8)
       ("C3D8R" , _hexahedron_8)
       ("DC3D8" , _hexahedron_8)
       ("C3D10" , _tetrahedron_10)
       ("DC3D10", _tetrahedron_10);
 
 #if !defined(AKANTU_NDEBUG) && defined(AKANTU_CORE_CXX_11)
     qi::on_error<qi::fail>(start, error_handler(lbs::_4, lbs::_3, lbs::_2));
 #endif
     
     start              .name("abaqus-start-rule");
     connectivity       .name("abaqus-connectivity");
     node_position      .name("abaqus-nodes-position");
     nodes              .name("abaqus-nodes");
     any_section        .name("abaqus-any_section");
     header             .name("abaqus-header");
     material           .name("abaqus-material");
     elements           .name("abaqus-elements");
     elements_set       .name("abaqus-elements-set");
     nodes_set          .name("abaqus-nodes-set");
     key                .name("abaqus-key");
     value              .name("abaqus-value");
     option             .name("abaqus-option");
     keyword            .name("abaqus-keyword");
     any_line           .name("abaqus-any-line");
     abaqus_element_type.name("abaqus-element-type");
 
     /* clang-format on */
   }
 
 public:
   AKANTU_GET_MACRO(MaterialNames, material_names,
                    const std::vector<std::string> &);
 
   /* ------------------------------------------------------------------------ */
   /* Rules                                                                    */
   /* ------------------------------------------------------------------------ */
 private:
   qi::rule<Iterator, void(), Skipper> start;
   qi::rule<Iterator, std::vector<int>(), Skipper> connectivity;
   qi::rule<Iterator, std::vector<Real>(), Skipper> node_position;
   qi::rule<Iterator, void(), Skipper> nodes, any_section, header, material;
   qi::rule<Iterator, void(), qi::locals<ElementType>, Skipper> elements;
   qi::rule<Iterator, void(), qi::locals<ElementGroup *>, Skipper> elements_set;
   qi::rule<Iterator, void(), qi::locals<NodeGroup *>, Skipper> nodes_set;
 
   qi::rule<Iterator, std::string(), Skipper> key, value, option, keyword,
       any_line;
 
   qi::real_parser<Real, qi::real_policies<Real>> real;
 
   qi::symbols<char, ElementType> abaqus_element_type;
 
   /* ------------------------------------------------------------------------ */
   /* Mambers                                                                  */
   /* ------------------------------------------------------------------------ */
 private:
   /// reference to the mesh to read
   Mesh & mesh;
 
   /// correspondance between the numbering of nodes in the abaqus file and in
   /// the akantu mesh
   std::map<UInt, UInt> abaqus_nodes_to_akantu;
 
   /// correspondance between the element number in the abaqus file and the
   /// Element in the akantu mesh
   std::map<UInt, Element> abaqus_elements_to_akantu;
 
   /// list of the material names
   std::vector<std::string> material_names;
 };
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 void MeshIOAbaqus::read(const std::string & filename, Mesh & mesh) {
   namespace spirit = boost::spirit;
   namespace qi = boost::spirit::qi;
   namespace lbs = boost::spirit::qi::labels;
   namespace ascii = boost::spirit::ascii;
   namespace phx = boost::phoenix;
 
   std::ifstream infile;
   infile.open(filename.c_str());
 
   if (!infile.good()) {
     AKANTU_DEBUG_ERROR("Cannot open file " << filename);
   }
 
   std::string storage;             // We will read the contents here.
   infile.unsetf(std::ios::skipws); // No white space skipping!
   std::copy(std::istream_iterator<char>(infile), std::istream_iterator<char>(),
             std::back_inserter(storage));
 
-  typedef std::string::const_iterator iterator_t;
-  typedef AbaqusSkipper<iterator_t> skipper;
+  using iterator_t = std::string::const_iterator;
+  using skipper = AbaqusSkipper<iterator_t>;
   typedef AbaqusMeshGrammar<iterator_t, skipper> grammar;
 
   grammar g(mesh);
   skipper ws;
 
   iterator_t iter = storage.begin();
   iterator_t end = storage.end();
 
   qi::phrase_parse(iter, end, g, ws);
 
   MeshAccessor mesh_accessor(mesh);
 
   for (auto & mat_name : g.getMaterialNames()) {
     auto eg_it = mesh.element_group_find(mat_name);
     auto & eg = *eg_it->second;
     if (eg_it != mesh.element_group_end()) {
       for (auto & type : eg.elementTypes()) {
         Array<std::string> & abaqus_material =
             mesh_accessor.getData<std::string>("abaqus_material", type);
 
         for (auto elem : eg.getElements(type)) {
           abaqus_material(elem) = mat_name;
         }
       }
     }
   }
 
   mesh_accessor.setNbGlobalNodes(mesh.getNodes().size());
   MeshUtils::fillElementToSubElementsData(mesh);
 }
 
 } // namespace akantu
diff --git a/src/io/mesh_io/mesh_io_diana.cc b/src/io/mesh_io/mesh_io_diana.cc
index d2037f66c..f53e0cae9 100644
--- a/src/io/mesh_io/mesh_io_diana.cc
+++ b/src/io/mesh_io/mesh_io_diana.cc
@@ -1,604 +1,602 @@
 /**
  * @file   mesh_io_diana.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Alodie Schneuwly <alodie.schneuwly@epfl.ch>
  *
  * @date creation: Sat Mar 26 2011
  * @date last modification: Thu Jan 21 2016
  *
  * @brief  handles diana meshes
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 #include <iostream>
 
 /* -------------------------------------------------------------------------- */
 #include "element_group.hh"
 #include "mesh_io_diana.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 #include <string.h>
 /* -------------------------------------------------------------------------- */
 #include <stdio.h>
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /*   Methods Implentations                                                    */
 /* -------------------------------------------------------------------------- */
 
 MeshIODiana::MeshIODiana() {
   canReadSurface = true;
   canReadExtendedData = true;
   _diana_to_akantu_element_types["T9TM"] = _triangle_3;
   _diana_to_akantu_element_types["CT6CM"] = _triangle_6;
   _diana_to_akantu_element_types["Q12TM"] = _quadrangle_4;
   _diana_to_akantu_element_types["CQ8CM"] = _quadrangle_8;
   _diana_to_akantu_element_types["TP18L"] = _pentahedron_6;
   _diana_to_akantu_element_types["CTP45"] = _pentahedron_15;
   _diana_to_akantu_element_types["TE12L"] = _tetrahedron_4;
   _diana_to_akantu_element_types["HX24L"] = _hexahedron_8;
   _diana_to_akantu_element_types["CHX60"] = _hexahedron_20;
   _diana_to_akantu_mat_prop["YOUNG"] = "E";
   _diana_to_akantu_mat_prop["DENSIT"] = "rho";
   _diana_to_akantu_mat_prop["POISON"] = "nu";
 
   std::map<std::string, ElementType>::iterator it;
   for (it = _diana_to_akantu_element_types.begin();
        it != _diana_to_akantu_element_types.end(); ++it) {
     UInt nb_nodes = Mesh::getNbNodesPerElement(it->second);
 
-    UInt * tmp = new UInt[nb_nodes];
+    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() {}
+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
+  size_t pos = line.find('\r'); /// remove the extra \r if needed
   line = line.substr(0, pos);
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIODiana::read(const std::string & filename, Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   MeshAccessor mesh_accessor(mesh);
 
   std::ifstream infile;
   infile.open(filename.c_str());
 
   std::string line;
   UInt first_node_number = std::numeric_limits<UInt>::max();
   diana_element_number_to_elements.clear();
 
   if (!infile.good()) {
     AKANTU_DEBUG_ERROR("Cannot open file " << filename);
   }
 
   while (infile.good()) {
     my_getline(infile, line);
 
     /// read all nodes
     if (line == "'COORDINATES'") {
       line = readCoordinates(infile, mesh, first_node_number);
     }
 
     /// read all elements
     if (line == "'ELEMENTS'") {
       line = readElements(infile, mesh, first_node_number);
     }
 
     /// read the material properties and write a .dat file
     if (line == "'MATERIALS'") {
       line = readMaterial(infile, filename);
     }
 
     /// read the material properties and write a .dat file
     if (line == "'GROUPS'") {
       line = readGroups(infile, mesh, first_node_number);
     }
   }
   infile.close();
 
   mesh_accessor.setNbGlobalNodes(mesh.getNbNodes());
 
   MeshUtils::fillElementToSubElementsData(mesh);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIODiana::write(__attribute__((unused)) const std::string & filename,
                         __attribute__((unused)) const Mesh & mesh) {
   AKANTU_DEBUG_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readCoordinates(std::ifstream & infile, Mesh & mesh,
                                          UInt & first_node_number) {
   AKANTU_DEBUG_IN();
 
   MeshAccessor mesh_accessor(mesh);
 
   Array<Real> & nodes = mesh_accessor.getNodes();
 
   std::string line;
 
   UInt index;
   Vector<Real> coord(3);
 
   do {
     my_getline(infile, line);
     if ("'ELEMENTS'" == line)
       break;
 
     std::stringstream sstr_node(line);
     sstr_node >> index >> coord(0) >> coord(1) >> coord(2);
 
     first_node_number = first_node_number < index ? first_node_number : index;
 
     nodes.push_back(coord);
   } while (true);
 
   AKANTU_DEBUG_OUT();
   return line;
 }
 
 /* -------------------------------------------------------------------------- */
 UInt MeshIODiana::readInterval(std::stringstream & line,
                                std::set<UInt> & interval) {
   UInt first;
   line >> first;
   if (line.fail()) {
     return 0;
   }
   interval.insert(first);
 
   UInt second;
   int dash;
   dash = line.get();
   if (dash == '-') {
     line >> second;
     interval.insert(second);
     return 2;
   }
 
   if (line.fail())
     line.clear(std::ios::eofbit); // in case of get at end of the line
   else
     line.unget();
   return 1;
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readGroups(std::ifstream & infile, Mesh & mesh,
                                     UInt first_node_number) {
   AKANTU_DEBUG_IN();
 
   std::string line;
   my_getline(infile, line);
 
   bool reading_nodes_group = false;
 
   while (line != "'SUPPORTS'") {
     if (line == "NODES") {
       reading_nodes_group = true;
       my_getline(infile, line);
     }
 
     if (line == "ELEMEN") {
       reading_nodes_group = false;
       my_getline(infile, line);
     }
 
-    std::stringstream * str = new std::stringstream(line);
+    auto * str = new std::stringstream(line);
 
     UInt id;
     std::string name;
     char c;
     *str >> id >> name >> c;
 
-    Array<UInt> * list_ids = new Array<UInt>(0, 1, name);
+    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);
-        std::set<UInt>::iterator it = interval.begin();
+        auto it = interval.begin();
         if (s == 1)
           list_ids->push_back(*it);
         if (s == 2) {
           UInt first = *it;
           ++it;
           UInt second = *it;
           for (UInt i = first; i <= second; ++i) {
             list_ids->push_back(i);
           }
         }
       }
       if (str->fail())
         end = true;
       else {
         my_getline(infile, line);
         delete str;
         str = new std::stringstream(line);
       }
     }
 
     delete str;
 
     if (reading_nodes_group) {
       NodeGroup & ng = mesh.createNodeGroup(name);
       for (UInt i = 0; i < list_ids->size(); ++i) {
         UInt node = (*list_ids)(i)-first_node_number;
         ng.add(node, false);
       }
       delete list_ids;
 
     } else {
       ElementGroup & eg = mesh.createElementGroup(name);
       for (UInt i = 0; i < list_ids->size(); ++i) {
         Element & elem = diana_element_number_to_elements[(*list_ids)(i)];
         if (elem.type != _not_defined)
           eg.add(elem, false, false);
       }
 
       eg.optimize();
       delete list_ids;
     }
 
     my_getline(infile, line);
   }
 
   AKANTU_DEBUG_OUT();
   return line;
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readElements(std::ifstream & infile, Mesh & mesh,
                                       UInt first_node_number) {
   AKANTU_DEBUG_IN();
 
   std::string line;
   my_getline(infile, line);
 
   if ("CONNECTIVITY" == line) {
     line = readConnectivity(infile, mesh, first_node_number);
   }
 
   /// read the line corresponding to the materials
   if ("MATERIALS" == line) {
     line = readMaterialElement(infile, mesh);
   }
 
   AKANTU_DEBUG_OUT();
   return line;
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readConnectivity(std::ifstream & infile, Mesh & mesh,
                                           UInt first_node_number) {
   AKANTU_DEBUG_IN();
 
   MeshAccessor mesh_accessor(mesh);
   Int index;
   std::string lline;
 
   std::string diana_type;
   ElementType akantu_type, akantu_type_old = _not_defined;
   Array<UInt> * connectivity = nullptr;
   UInt node_per_element = 0;
   Element elem;
   UInt * read_order = nullptr;
 
-  while (1) {
+  while (true) {
     my_getline(infile, lline);
     //    std::cerr << lline << std::endl;
     std::stringstream sstr_elem(lline);
     if (lline == "MATERIALS")
       break;
 
     /// traiter les coordonnees
     sstr_elem >> index;
     sstr_elem >> diana_type;
 
     akantu_type = _diana_to_akantu_element_types[diana_type];
 
     if (akantu_type == _not_defined)
       continue;
 
     if (akantu_type != akantu_type_old) {
       connectivity = &(mesh_accessor.getConnectivity(akantu_type));
 
       node_per_element = connectivity->getNbComponent();
       akantu_type_old = akantu_type;
       read_order = _read_order[akantu_type];
     }
 
     Vector<UInt> local_connect(node_per_element);
 
     // used if element is written on two lines
     UInt j_last = 0;
 
     for (UInt j = 0; j < node_per_element; ++j) {
       UInt node_index;
       sstr_elem >> node_index;
 
       // check s'il y a pas plus rien après un certain point
 
       if (sstr_elem.fail()) {
         sstr_elem.clear();
         sstr_elem.ignore();
         break;
       }
 
       node_index -= first_node_number;
       local_connect(read_order[j]) = node_index;
       j_last = j;
     }
 
     // check if element is written in two lines
     if (j_last != (node_per_element - 1)) {
 
       // if this is the case, read on more line
       my_getline(infile, lline);
       std::stringstream sstr_elem(lline);
 
       for (UInt j = (j_last + 1); j < node_per_element; ++j) {
 
         UInt node_index;
         sstr_elem >> node_index;
 
         node_index -= first_node_number;
         local_connect(read_order[j]) = node_index;
       }
     }
 
     connectivity->push_back(local_connect);
 
     elem.type = akantu_type;
     elem.element = connectivity->size() - 1;
 
     diana_element_number_to_elements[index] = elem;
     akantu_number_to_diana_number[elem] = index;
   }
 
   AKANTU_DEBUG_OUT();
   return lline;
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readMaterialElement(std::ifstream & infile,
                                              Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   std::string line;
   std::stringstream sstr_tag_name;
   sstr_tag_name << "tag_" << 0;
 
   Mesh::type_iterator it = mesh.firstType();
   Mesh::type_iterator end = mesh.lastType();
   for (; it != end; ++it) {
     UInt nb_element = mesh.getNbElement(*it);
     mesh.getDataPointer<UInt>("material", *it, _not_ghost, 1)
         .resize(nb_element);
   }
 
   my_getline(infile, line);
   while (line != "'MATERIALS'") {
     line =
         line.substr(line.find('/') + 1,
                     std::string::npos); // erase the first slash / of the line
     char tutu[250];
     strcpy(tutu, line.c_str());
 
     AKANTU_DEBUG_WARNING("reading line " << line);
     Array<UInt> temp_id(0, 2);
     UInt mat;
     while (true) {
       std::stringstream sstr_intervals_elements(line);
       Vector<UInt> id(2);
       char temp;
       while (sstr_intervals_elements.good()) {
         sstr_intervals_elements >> id(0) >> temp >> id(1); // >> "/" >> mat;
         if (!sstr_intervals_elements.fail())
           temp_id.push_back(id);
       }
       if (sstr_intervals_elements.fail()) {
         sstr_intervals_elements.clear();
         sstr_intervals_elements.ignore();
         sstr_intervals_elements >> mat;
         break;
       }
       my_getline(infile, line);
     }
 
     // loop over elements
     //    UInt * temp_id_val = temp_id.storage();
     for (UInt i = 0; i < temp_id.size(); ++i)
       for (UInt j = temp_id(i, 0); j <= temp_id(i, 1); ++j) {
         Element & element = diana_element_number_to_elements[j];
         if (element.type == _not_defined)
           continue;
         UInt elem = element.element;
         ElementType type = element.type;
         Array<UInt> & data =
             mesh.getDataPointer<UInt>("material", type, _not_ghost);
         data(elem) = mat;
       }
 
     my_getline(infile, line);
   }
 
   AKANTU_DEBUG_OUT();
   return line;
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readMaterial(std::ifstream & infile,
                                       const std::string & filename) {
   AKANTU_DEBUG_IN();
 
   std::stringstream mat_file_name;
 
   mat_file_name << "material_" << filename;
 
   std::ofstream material_file;
   material_file.open(mat_file_name.str().c_str()); // mat_file_name.str());
 
   UInt mat_index;
   std::string line;
 
   bool first_mat = true;
   bool end = false;
 
   UInt mat_id = 0;
 
   typedef std::map<std::string, Real> MatProp;
   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 (MatProp::iterator it = mat_prop.begin(); it != mat_prop.end();
-             ++it)
+        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 (MatProp::iterator it = mat_prop.begin(); it != mat_prop.end();
-                 ++it)
+            for (auto it = mat_prop.begin(); it != mat_prop.end(); ++it)
               material_file << "\t" << it->first << " = " << it->second
                             << std::endl;
             material_file << "]" << std::endl;
             mat_prop.clear();
           }
         }
         first_mat = false;
       } else {
         sstr_material.clear();
       }
 
       std::string prop_name;
       sstr_material >> prop_name;
 
       std::map<std::string, std::string>::iterator it;
       it = _diana_to_akantu_mat_prop.find(prop_name);
 
       if (it != _diana_to_akantu_mat_prop.end()) {
         Real value;
         sstr_material >> value;
         mat_prop[it->second] = value;
       } else {
         AKANTU_DEBUG_INFO("In material reader, property " << prop_name
                                                           << "not recognized");
       }
     }
   } while (!end);
 
   AKANTU_DEBUG_OUT();
   return line;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/io/mesh_io/mesh_io_msh.cc b/src/io/mesh_io/mesh_io_msh.cc
index c2b7287bf..b765820c0 100644
--- a/src/io/mesh_io/mesh_io_msh.cc
+++ b/src/io/mesh_io/mesh_io_msh.cc
@@ -1,971 +1,971 @@
 /**
  * @file   mesh_io_msh.cc
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Jan 21 2016
  *
  * @brief  Read/Write for MSH files generated by gmsh
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -----------------------------------------------------------------------------
    Version (Legacy) 1.0
 
    $NOD
    number-of-nodes
    node-number x-coord y-coord z-coord
    ...
    $ENDNOD
    $ELM
    number-of-elements
    elm-number elm-type reg-phys reg-elem number-of-nodes node-number-list
    ...
    $ENDELM
    -----------------------------------------------------------------------------
    Version 2.1
 
    $MeshFormat
    version-number file-type data-size
    $EndMeshFormat
    $Nodes
    number-of-nodes
    node-number x-coord y-coord z-coord
    ...
    $EndNodes
    $Elements
    number-of-elements
    elm-number elm-type number-of-tags < tag > ... node-number-list
    ...
    $EndElements
    $PhysicalNames
    number-of-names
    physical-dimension physical-number "physical-name"
    ...
    $EndPhysicalNames
    $NodeData
    number-of-string-tags
    < "string-tag" >
    ...
    number-of-real-tags
    < real-tag >
    ...
    number-of-integer-tags
    < integer-tag >
    ...
    node-number value ...
    ...
    $EndNodeData
    $ElementData
    number-of-string-tags
    < "string-tag" >
    ...
    number-of-real-tags
    < real-tag >
    ...
    number-of-integer-tags
    < integer-tag >
    ...
    elm-number value ...
    ...
    $EndElementData
    $ElementNodeData
    number-of-string-tags
    < "string-tag" >
    ...
    number-of-real-tags
    < real-tag >
    ...
    number-of-integer-tags
    < integer-tag >
    ...
    elm-number number-of-nodes-per-element value ...
    ...
    $ElementEndNodeData
 
    -----------------------------------------------------------------------------
    elem-type
 
    1:  2-node line.
    2:  3-node triangle.
    3:  4-node quadrangle.
    4:  4-node tetrahedron.
    5:  8-node hexahedron.
    6:  6-node prism.
    7:  5-node pyramid.
    8:  3-node second order line
    9:  6-node second order triangle
    10: 9-node second order quadrangle
    11: 10-node second order tetrahedron
    12: 27-node second order hexahedron
    13: 18-node second order prism
    14: 14-node second order pyramid
    15: 1-node point.
    16: 8-node second order quadrangle
    17: 20-node second order hexahedron
    18: 15-node second order prism
    19: 13-node second order pyramid
    20: 9-node third order incomplete triangle
    21: 10-node third order triangle
    22: 12-node fourth order incomplete triangle
    23: 15-node fourth order triangle
    24: 15-node fifth order incomplete triangle
    25: 21-node fifth order complete triangle
    26: 4-node third order edge
    27: 5-node fourth order edge
    28: 6-node fifth order edge
    29: 20-node third order tetrahedron
    30: 35-node fourth order tetrahedron
    31: 56-node fifth order tetrahedron
    -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "mesh_io.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 // The boost spirit is a work on the way it does not compile so I kept the
 // current code. The current code does not handle files generated on Windows
 // <CRLF>
 
 // #include <boost/config/warning_disable.hpp>
 // #include <boost/spirit/include/qi.hpp>
 // #include <boost/spirit/include/phoenix_core.hpp>
 // #include <boost/spirit/include/phoenix_fusion.hpp>
 // #include <boost/spirit/include/phoenix_object.hpp>
 // #include <boost/spirit/include/phoenix_container.hpp>
 // #include <boost/spirit/include/phoenix_operator.hpp>
 // #include <boost/spirit/include/phoenix_bind.hpp>
 // #include <boost/spirit/include/phoenix_stl.hpp>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /*   Methods Implentations                                                    */
 /* -------------------------------------------------------------------------- */
 MeshIOMSH::MeshIOMSH() {
   canReadSurface = true;
   canReadExtendedData = true;
 
   _msh_nodes_per_elem[_msh_not_defined] = 0;
   _msh_nodes_per_elem[_msh_segment_2] = 2;
   _msh_nodes_per_elem[_msh_triangle_3] = 3;
   _msh_nodes_per_elem[_msh_quadrangle_4] = 4;
   _msh_nodes_per_elem[_msh_tetrahedron_4] = 4;
   _msh_nodes_per_elem[_msh_hexahedron_8] = 8;
   _msh_nodes_per_elem[_msh_prism_1] = 6;
   _msh_nodes_per_elem[_msh_pyramid_1] = 1;
   _msh_nodes_per_elem[_msh_segment_3] = 3;
   _msh_nodes_per_elem[_msh_triangle_6] = 6;
   _msh_nodes_per_elem[_msh_quadrangle_9] = 9;
   _msh_nodes_per_elem[_msh_tetrahedron_10] = 10;
   _msh_nodes_per_elem[_msh_hexahedron_27] = 27;
   _msh_nodes_per_elem[_msh_hexahedron_20] = 20;
   _msh_nodes_per_elem[_msh_prism_18] = 18;
   _msh_nodes_per_elem[_msh_prism_15] = 15;
   _msh_nodes_per_elem[_msh_pyramid_14] = 14;
   _msh_nodes_per_elem[_msh_point] = 1;
   _msh_nodes_per_elem[_msh_quadrangle_8] = 8;
 
   _msh_to_akantu_element_types[_msh_not_defined] = _not_defined;
   _msh_to_akantu_element_types[_msh_segment_2] = _segment_2;
   _msh_to_akantu_element_types[_msh_triangle_3] = _triangle_3;
   _msh_to_akantu_element_types[_msh_quadrangle_4] = _quadrangle_4;
   _msh_to_akantu_element_types[_msh_tetrahedron_4] = _tetrahedron_4;
   _msh_to_akantu_element_types[_msh_hexahedron_8] = _hexahedron_8;
   _msh_to_akantu_element_types[_msh_prism_1] = _pentahedron_6;
   _msh_to_akantu_element_types[_msh_pyramid_1] = _not_defined;
   _msh_to_akantu_element_types[_msh_segment_3] = _segment_3;
   _msh_to_akantu_element_types[_msh_triangle_6] = _triangle_6;
   _msh_to_akantu_element_types[_msh_quadrangle_9] = _not_defined;
   _msh_to_akantu_element_types[_msh_tetrahedron_10] = _tetrahedron_10;
   _msh_to_akantu_element_types[_msh_hexahedron_27] = _not_defined;
   _msh_to_akantu_element_types[_msh_hexahedron_20] = _hexahedron_20;
   _msh_to_akantu_element_types[_msh_prism_18] = _not_defined;
   _msh_to_akantu_element_types[_msh_prism_15] = _pentahedron_15;
   _msh_to_akantu_element_types[_msh_pyramid_14] = _not_defined;
   _msh_to_akantu_element_types[_msh_point] = _point_1;
   _msh_to_akantu_element_types[_msh_quadrangle_8] = _quadrangle_8;
 
   _akantu_to_msh_element_types[_not_defined] = _msh_not_defined;
   _akantu_to_msh_element_types[_segment_2] = _msh_segment_2;
   _akantu_to_msh_element_types[_segment_3] = _msh_segment_3;
   _akantu_to_msh_element_types[_triangle_3] = _msh_triangle_3;
   _akantu_to_msh_element_types[_triangle_6] = _msh_triangle_6;
   _akantu_to_msh_element_types[_tetrahedron_4] = _msh_tetrahedron_4;
   _akantu_to_msh_element_types[_tetrahedron_10] = _msh_tetrahedron_10;
   _akantu_to_msh_element_types[_quadrangle_4] = _msh_quadrangle_4;
   _akantu_to_msh_element_types[_quadrangle_8] = _msh_quadrangle_8;
   _akantu_to_msh_element_types[_hexahedron_8] = _msh_hexahedron_8;
   _akantu_to_msh_element_types[_hexahedron_20] = _msh_hexahedron_20;
   _akantu_to_msh_element_types[_pentahedron_6] = _msh_prism_1;
   _akantu_to_msh_element_types[_pentahedron_15] = _msh_prism_15;
   _akantu_to_msh_element_types[_point_1] = _msh_point;
 
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
   _akantu_to_msh_element_types[_bernoulli_beam_2] = _msh_segment_2;
   _akantu_to_msh_element_types[_bernoulli_beam_3] = _msh_segment_2;
   _akantu_to_msh_element_types[_kirchhoff_shell] = _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() {}
+MeshIOMSH::~MeshIOMSH() = default;
 
 /* -------------------------------------------------------------------------- */
 /* Spirit stuff                                                               */
 /* -------------------------------------------------------------------------- */
 // namespace _parser {
 //   namespace spirit  = ::boost::spirit;
 //   namespace qi      = ::boost::spirit::qi;
 //   namespace ascii   = ::boost::spirit::ascii;
 //   namespace lbs     = ::boost::spirit::qi::labels;
 //   namespace phx     = ::boost::phoenix;
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   /* Lazy functors */
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct _Element {
 //     int index;
 //     std::vector<int> tags;
 //     std::vector<int> connectivity;
 //     ElementType type;
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct lazy_get_nb_nodes_ {
 //     template <class elem_type> struct result { typedef int type; };
 //     template <class elem_type> bool operator()(elem_type et) {
 //       return MeshIOMSH::_msh_nodes_per_elem[et];
 //     }
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct lazy_element_ {
 //     template <class id_t, class tags_t, class elem_type, class conn_t>
 //     struct result {
 //       typedef _Element type;
 //     };
 //     template <class id_t, class tags_t, class elem_type, class conn_t>
 //     _Element operator()(id_t id, const elem_type & et, const tags_t & t,
 //                        const conn_t & c) {
 //       _Element tmp_el;
 //       tmp_el.index = id;
 //       tmp_el.tags = t;
 //       tmp_el.connectivity = c;
 //       tmp_el.type = et;
 //       return tmp_el;
 //     }
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct lazy_check_value_ {
 //     template <class T> struct result { typedef void type; };
 //     template <class T> void operator()(T v1, T v2) {
 //       if (v1 != v2) {
 //         AKANTU_EXCEPTION("The msh parser expected a "
 //                          << v2 << " in the header bug got a " << v1);
 //       }
 //     }
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct lazy_node_read_ {
 //     template <class Mesh, class ID, class V, class size, class Map>
 //     struct result {
 //       typedef bool type;
 //     };
 //     template <class Mesh, class ID, class V, class size, class Map>
 //     bool operator()(Mesh & mesh, const ID & id, const V & pos, size max,
 //                     Map & nodes_mapping) const {
 //       Vector<Real> tmp_pos(mesh.getSpatialDimension());
 //       UInt i = 0;
 //       for (typename V::const_iterator it = pos.begin();
 //            it != pos.end() || i < mesh.getSpatialDimension(); ++it)
 //         tmp_pos[i++] = *it;
 
 //       nodes_mapping[id] = mesh.getNbNodes();
 //       mesh.getNodes().push_back(tmp_pos);
 //       return (mesh.getNbNodes() < UInt(max));
 //     }
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct lazy_element_read_ {
 //     template <class Mesh, class EL, class size, class NodeMap, class ElemMap>
 //     struct result {
 //       typedef bool type;
 //     };
 
 //     template <class Mesh, class EL, class size, class NodeMap, class ElemMap>
 //     bool operator()(Mesh & mesh, const EL & element, size max,
 //                     const NodeMap & nodes_mapping,
 //                     ElemMap & elements_mapping) const {
 //       Vector<UInt> tmp_conn(Mesh::getNbNodesPerElement(element.type));
 
 //       AKANTU_DEBUG_ASSERT(element.connectivity.size() == tmp_conn.size(),
 //                           "The element "
 //                               << element.index
 //                               << "in the MSH file has too many nodes.");
 
 //       mesh.addConnectivityType(element.type);
 //       Array<UInt> & connectivity = mesh.getConnectivity(element.type);
 
 //       UInt i = 0;
 //       for (std::vector<int>::const_iterator it =
 //       element.connectivity.begin();
 //            it != element.connectivity.end(); ++it) {
 //         typename NodeMap::const_iterator nit = nodes_mapping.find(*it);
 //         AKANTU_DEBUG_ASSERT(nit != nodes_mapping.end(),
 //                             "There is an unknown node in the connectivity.");
 //         tmp_conn[i++] = nit->second;
 //       }
 
 //       ::akantu::Element el(element.type, connectivity.size());
 //       elements_mapping[element.index] = el;
 
 //       connectivity.push_back(tmp_conn);
 
 //       for (UInt i = 0; i < element.tags.size(); ++i) {
 //         std::stringstream tag_sstr;
 //         tag_sstr << "tag_" << i;
 //         Array<UInt> * data =
 //             mesh.template getDataPointer<UInt>(tag_sstr.str(), element.type,
 //             _not_ghost);
 //         data->push_back(element.tags[i]);
 //       }
 
 //       return (mesh.getNbElement() < UInt(max));
 //     }
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   template <class Iterator, typename Skipper = ascii::space_type>
 //   struct MshMeshGrammar : qi::grammar<Iterator, void(), Skipper> {
 //   public:
 //     MshMeshGrammar(Mesh & mesh)
 //         : MshMeshGrammar::base_type(start, "msh_mesh_reader"), mesh(mesh) {
 //       phx::function<lazy_element_> lazy_element;
 //       phx::function<lazy_get_nb_nodes_> lazy_get_nb_nodes;
 //       phx::function<lazy_check_value_> lazy_check_value;
 //       phx::function<lazy_node_read_> lazy_node_read;
 //       phx::function<lazy_element_read_> lazy_element_read;
 
 // clang-format off
 
 //       start
 //         =  *( known_section | unknown_section
 //             )
 //        ;
 
 //       known_section
 //         =  qi::char_("$")
 //            >> sections            [ lbs::_a = lbs::_1 ]
 //            >> qi::lazy(*lbs::_a)
 //            >> qi::lit("$End")
 //           //>> qi::lit(phx::ref(lbs::_a))
 //         ;
 
 //       unknown_section
 //         =  qi::char_("$")
 //            >> qi::char_("")     [ lbs::_a = lbs::_1 ]
 //            >> ignore_section
 //            >> qi::lit("$End")
 //            >> qi::lit(phx::val(lbs::_a))
 //         ;
 
 //       mesh_format // version followed by 0 or 1 for ascii or binary
 //         =  version >> (
 //                         ( qi::char_("0")
 //                           >> qi::int_       [ lazy_check_value(lbs::_1, 8) ]
 //                         )
 //                         | ( qi::char_("1")
 //                             >> qi::int_     [ lazy_check_value(lbs::_1, 8) ]
 //                             >> qi::dword    [ lazy_check_value(lbs::_1, 1) ]
 //                           )
 //                         )
 //         ;
 
 //       nodes
 //         =  nodes_
 //         ;
 
 //       nodes_
 //         =  qi::int_                      [ lbs::_a = lbs::_1 ]
 //            > *(
 //                 ( qi::int_ >> position ) [ lazy_node_read(phx::ref(mesh),
 //                                                           lbs::_1,
 //                                                           phx::cref(lbs::_2),
 //                                                           lbs::_a,
 //                                                           phx::ref(this->msh_nodes_to_akantu)) ]
 //               )
 //         ;
 
 //       element
 //         =  elements_
 //         ;
 
 //       elements_
 //         =  qi::int_                                 [ lbs::_a = lbs::_1 ]
 //            > qi::repeat(phx::ref(lbs::_a))[ element [ lazy_element_read(phx::ref(mesh),
 //                                                                         lbs::_1,
 //                                                                         phx::cref(lbs::_a),
 //                                                                         phx::cref(this->msh_nodes_to_akantu),
 //                                                                         phx::ref(this->msh_elemt_to_akantu)) ]]
 //         ;
 
 //       ignore_section
 //         =  *(qi::char_ - qi::char_('$'))
 //         ;
 
 //       interpolation_scheme = ignore_section;
 //       element_data         = ignore_section;
 //       node_data            = ignore_section;
 
 //       version
 //         =  qi::int_                         [ phx::push_back(lbs::_val, lbs::_1) ]
 //            >> *( qi::char_(".") >> qi::int_ [ phx::push_back(lbs::_val, lbs::_1) ] )
 //         ;
 
 //       position
 //         =  real   [ phx::push_back(lbs::_val, lbs::_1) ]
 //            > real [ phx::push_back(lbs::_val, lbs::_1) ]
 //            > real [ phx::push_back(lbs::_val, lbs::_1) ]
 //         ;
 
 //       tags
 //         =  qi::int_      [ lbs::_a = lbs::_1 ]
 //           > qi::repeat(phx::val(lbs::_a))[ qi::int_ [ phx::push_back(lbs::_val,
 //                                                                      lbs::_1) ] ]
 //         ;
 
 //       element
 //         =  ( qi::int_                [ lbs::_a = lbs::_1 ]
 //              > msh_element_type      [ lbs::_b = lazy_get_nb_nodes(lbs::_1) ]
 //              > tags                  [ lbs::_c = lbs::_1 ]
 //              > connectivity(lbs::_a) [ lbs::_d = lbs::_1 ]
 //            )                         [ lbs::_val = lazy_element(lbs::_a,
 //                                                                 phx::cref(lbs::_b),
 //                                                                 phx::cref(lbs::_c),
 //                                                                 phx::cref(lbs::_d)) ]
 //         ;
 //       connectivity
 //         =  qi::repeat(lbs::_r1)[ qi::int_ [ phx::push_back(lbs::_val,
 //                                                            lbs::_1) ] ]
 //         ;
 
 //       sections.add
 //           ("MeshFormat", &mesh_format)
 //           ("Nodes", &nodes)
 //           ("Elements", &elements)
 //           ("PhysicalNames", &physical_names)
 //           ("InterpolationScheme", &interpolation_scheme)
 //           ("ElementData", &element_data)
 //           ("NodeData", &node_data);
 
 //       msh_element_type.add
 //           ("0" , _not_defined   )
 //           ("1" , _segment_2     )
 //           ("2" , _triangle_3    )
 //           ("3" , _quadrangle_4  )
 //           ("4" , _tetrahedron_4 )
 //           ("5" , _hexahedron_8  )
 //           ("6" , _pentahedron_6 )
 //           ("7" , _not_defined   )
 //           ("8" , _segment_3     )
 //           ("9" , _triangle_6    )
 //           ("10", _not_defined   )
 //           ("11", _tetrahedron_10)
 //           ("12", _not_defined   )
 //           ("13", _not_defined   )
 //           ("14", _hexahedron_20 )
 //           ("15", _pentahedron_15)
 //           ("16", _not_defined   )
 //           ("17", _point_1       )
 //           ("18", _quadrangle_8  );
 
 //       mesh_format         .name("MeshFormat"         );
 //       nodes               .name("Nodes"              );
 //       elements            .name("Elements"           );
 //       physical_names      .name("PhysicalNames"      );
 //       interpolation_scheme.name("InterpolationScheme");
 //       element_data        .name("ElementData"        );
 //       node_data           .name("NodeData"           );
 
 // clang-format on
 //     }
 
 //     /* ----------------------------------------------------------------------
 //     */
 //     /* Rules */
 //     /* ----------------------------------------------------------------------
 //     */
 //   private:
 //     qi::symbols<char, ElementType> msh_element_type;
 //     qi::symbols<char, qi::rule<Iterator, void(), Skipper> *> sections;
 //     qi::rule<Iterator, void(), Skipper> start;
 //     qi::rule<Iterator, void(), Skipper, qi::locals<std::string> >
 //     unknown_section;
 //     qi::rule<Iterator, void(), Skipper, qi::locals<qi::rule<Iterator,
 //     Skipper> *> > known_section;
 //     qi::rule<Iterator, void(), Skipper> mesh_format, nodes, elements,
 //     physical_names, ignore_section,
 //         interpolation_scheme, element_data, node_data, any_line;
 //     qi::rule<Iterator, void(), Skipper, qi::locals<int> > nodes_;
 //     qi::rule<Iterator, void(), Skipper, qi::locals< int, int, vector<int>,
 //     vector<int> > > elements_;
 
 //     qi::rule<Iterator, std::vector<int>(), Skipper> version;
 //     qi::rule<Iterator, _Element(), Skipper, qi::locals<ElementType> >
 //     element;
 //     qi::rule<Iterator, std::vector<int>(), Skipper, qi::locals<int> > tags;
 //     qi::rule<Iterator, std::vector<int>(int), Skipper> connectivity;
 //     qi::rule<Iterator, std::vector<Real>(), Skipper> position;
 
 //     qi::real_parser<Real, qi::real_policies<Real> > real;
 
 //     /* ----------------------------------------------------------------------
 //     */
 //     /* Members */
 //     /* ----------------------------------------------------------------------
 //     */
 //   private:
 //     /// reference to the mesh to read
 //     Mesh & mesh;
 
 //     /// correspondance between the numbering of nodes in the abaqus file and
 //     in
 //     /// the akantu mesh
 //     std::map<UInt, UInt> msh_nodes_to_akantu;
 
 //     /// correspondance between the element number in the abaqus file and the
 //     /// Element in the akantu mesh
 //     std::map<UInt, Element> msh_elemt_to_akantu;
 //   };
 // }
 
 // /* --------------------------------------------------------------------------
 // */
 // void MeshIOAbaqus::read(const std::string& filename, Mesh& mesh) {
 //   namespace qi      = boost::spirit::qi;
 //   namespace ascii   = boost::spirit::ascii;
 
 //   std::ifstream infile;
 //   infile.open(filename.c_str());
 
 //   if(!infile.good()) {
 //     AKANTU_DEBUG_ERROR("Cannot open file " << filename);
 //   }
 
 //   std::string storage; // We will read the contents here.
 //   infile.unsetf(std::ios::skipws); // No white space skipping!
 //   std::copy(std::istream_iterator<char>(infile),
 //             std::istream_iterator<char>(),
 //             std::back_inserter(storage));
 
 //   typedef std::string::const_iterator iterator_t;
 //   typedef ascii::space_type skipper;
 //   typedef _parser::MshMeshGrammar<iterator_t, skipper> grammar;
 
 //   grammar g(mesh);
 //   skipper ws;
 
 //   iterator_t iter = storage.begin();
 //   iterator_t end  = storage.end();
 
 //   qi::phrase_parse(iter, end, g, ws);
 
 //   this->setNbGlobalNodes(mesh, mesh.getNodes().size());
 //   MeshUtils::fillElementToSubElementsData(mesh);
 // }
 
 static void my_getline(std::ifstream & infile, std::string & str) {
   std::string tmp_str;
   std::getline(infile, tmp_str);
   str = trim(tmp_str);
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIOMSH::read(const std::string & filename, Mesh & mesh) {
 
   MeshAccessor mesh_accessor(mesh);
 
   std::ifstream infile;
   infile.open(filename.c_str());
 
   std::string line;
   UInt first_node_number = std::numeric_limits<UInt>::max(),
        last_node_number = 0, file_format = 1, current_line = 0;
   bool has_physical_names = false;
 
   if (!infile.good()) {
     AKANTU_DEBUG_ERROR("Cannot open file " << filename);
   }
 
   while (infile.good()) {
     my_getline(infile, line);
     current_line++;
 
     /// read the header
     if (line == "$MeshFormat") {
       my_getline(infile, line); /// the format line
       std::stringstream sstr(line);
       std::string version;
       sstr >> version;
       Int format;
       sstr >> format;
       if (format != 0)
         AKANTU_DEBUG_ERROR("This reader can only read ASCII files.");
       my_getline(infile, line); /// the end of block line
       current_line += 2;
       file_format = 2;
     }
 
     /// read the physical names
     if (line == "$PhysicalNames") {
       has_physical_names = true;
       my_getline(infile, line); /// the format line
       std::stringstream sstr(line);
 
       UInt num_of_phys_names;
       sstr >> num_of_phys_names;
 
       for (UInt k(0); k < num_of_phys_names; k++) {
         my_getline(infile, line);
         std::stringstream sstr_phys_name(line);
         UInt phys_name_id;
         UInt phys_dim;
 
         sstr_phys_name >> phys_dim >> phys_name_id;
 
-        std::size_t b = line.find("\"");
-        std::size_t e = line.rfind("\"");
+        std::size_t b = line.find('\"');
+        std::size_t e = line.rfind('\"');
         std::string phys_name = line.substr(b + 1, e - b - 1);
 
         phys_name_map[phys_name_id] = phys_name;
       }
     }
 
     /// read all nodes
     if (line == "$Nodes" || line == "$NOD") {
       UInt nb_nodes;
 
       my_getline(infile, line);
       std::stringstream sstr(line);
       sstr >> nb_nodes;
       current_line++;
 
       Array<Real> & nodes = mesh_accessor.getNodes();
       nodes.resize(nb_nodes);
       mesh_accessor.setNbGlobalNodes(nb_nodes);
 
       UInt index;
       Real coord[3];
       UInt spatial_dimension = nodes.getNbComponent();
       /// for each node, read the coordinates
       for (UInt i = 0; i < nb_nodes; ++i) {
         UInt offset = i * spatial_dimension;
 
         my_getline(infile, line);
         std::stringstream sstr_node(line);
         sstr_node >> index >> coord[0] >> coord[1] >> coord[2];
         current_line++;
 
         first_node_number = std::min(first_node_number, index);
         last_node_number = std::max(last_node_number, index);
 
         /// read the coordinates
         for (UInt j = 0; j < spatial_dimension; ++j)
           nodes.storage()[offset + j] = coord[j];
       }
       my_getline(infile, line); /// the end of block line
     }
 
     /// read all elements
     if (line == "$Elements" || line == "$ELM") {
       UInt nb_elements;
 
       std::vector<UInt> read_order;
 
       my_getline(infile, line);
       std::stringstream sstr(line);
       sstr >> nb_elements;
       current_line++;
 
       Int index;
       UInt msh_type;
       ElementType akantu_type, akantu_type_old = _not_defined;
       Array<UInt> * connectivity = nullptr;
       UInt node_per_element = 0;
 
       for (UInt i = 0; i < nb_elements; ++i) {
         my_getline(infile, line);
         std::stringstream sstr_elem(line);
         current_line++;
 
         sstr_elem >> index;
         sstr_elem >> msh_type;
 
         /// get the connectivity vector depending on the element type
         akantu_type =
             this->_msh_to_akantu_element_types[(MSHElementType)msh_type];
 
         if (akantu_type == _not_defined) {
           AKANTU_DEBUG_WARNING("Unsuported element kind "
                                << msh_type << " at line " << current_line);
           continue;
         }
 
         if (akantu_type != akantu_type_old) {
           connectivity = &mesh_accessor.getConnectivity(akantu_type);
           //          connectivity->resize(0);
 
           node_per_element = connectivity->getNbComponent();
           akantu_type_old = akantu_type;
           read_order = this->_read_order[akantu_type];
         }
 
         /// read tags informations
         if (file_format == 2) {
           UInt nb_tags;
           sstr_elem >> nb_tags;
           for (UInt j = 0; j < nb_tags; ++j) {
             Int tag;
             sstr_elem >> tag;
             std::stringstream sstr_tag_name;
             sstr_tag_name << "tag_" << j;
             Array<UInt> & data = mesh.getDataPointer<UInt>(
                 sstr_tag_name.str(), akantu_type, _not_ghost);
             data.push_back(tag);
           }
         } else if (file_format == 1) {
           Int tag;
           sstr_elem >> tag; // reg-phys
           std::string tag_name = "tag_0";
           Array<UInt> * data =
               &mesh.getDataPointer<UInt>(tag_name, akantu_type, _not_ghost);
           data->push_back(tag);
 
           sstr_elem >> tag; // reg-elem
           tag_name = "tag_1";
           data = &mesh.getDataPointer<UInt>(tag_name, akantu_type, _not_ghost);
           data->push_back(tag);
 
           sstr_elem >> tag; // number-of-nodes
         }
 
         Vector<UInt> local_connect(node_per_element);
         for (UInt j = 0; j < node_per_element; ++j) {
           UInt node_index;
           sstr_elem >> node_index;
 
           AKANTU_DEBUG_ASSERT(node_index <= last_node_number,
                               "Node number not in range : line "
                                   << current_line);
 
           node_index -= first_node_number;
           local_connect(read_order[j]) = node_index;
         }
         connectivity->push_back(local_connect);
       }
       my_getline(infile, line); /// the end of block line
     }
 
     if ((line[0] == '$') && (line.find("End") == std::string::npos)) {
       AKANTU_DEBUG_WARNING("Unsuported block_kind " << line << " at line "
                                                     << current_line);
     }
   }
 
   // mesh.updateTypesOffsets(_not_ghost);
 
   infile.close();
 
   this->constructPhysicalNames("tag_0", mesh);
 
   if (has_physical_names)
     mesh.createGroupsFromMeshData<std::string>("physical_names");
 
   MeshUtils::fillElementToSubElementsData(mesh);
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIOMSH::write(const std::string & filename, const Mesh & mesh) {
   std::ofstream outfile;
   const Array<Real> & nodes = mesh.getNodes();
 
   outfile.open(filename.c_str());
 
   outfile << "$MeshFormat" << std::endl;
   outfile << "2.1 0 8" << std::endl;
   outfile << "$EndMeshFormat" << std::endl;
 
   outfile << std::setprecision(std::numeric_limits<Real>::digits10);
   outfile << "$Nodes" << std::endl;
 
   outfile << nodes.size() << std::endl;
 
   outfile << std::uppercase;
   for (UInt i = 0; i < nodes.size(); ++i) {
     Int offset = i * nodes.getNbComponent();
     outfile << i + 1;
     for (UInt j = 0; j < nodes.getNbComponent(); ++j) {
       outfile << " " << nodes.storage()[offset + j];
     }
 
     for (UInt p = nodes.getNbComponent(); p < 3; ++p)
       outfile << " " << 0.;
     outfile << std::endl;
     ;
   }
   outfile << std::nouppercase;
   outfile << "$EndNodes" << std::endl;
   ;
 
   outfile << "$Elements" << std::endl;
   ;
 
   Int nb_elements = 0;
   for (auto && type :
        mesh.elementTypes(_all_dimensions, _not_ghost, _ek_not_defined)) {
     const Array<UInt> & connectivity = mesh.getConnectivity(type, _not_ghost);
     nb_elements += connectivity.size();
   }
   outfile << nb_elements << std::endl;
 
   UInt element_idx = 1;
   for (auto && type :
        mesh.elementTypes(_all_dimensions, _not_ghost, _ek_not_defined)) {
     const auto & connectivity = mesh.getConnectivity(type, _not_ghost);
 
     UInt * tag[2] = {nullptr, nullptr};
     if (mesh.hasData<UInt>("tag_0", type, _not_ghost)) {
       const auto & data_tag_0 = mesh.getData<UInt>("tag_0", type, _not_ghost);
       tag[0] = data_tag_0.storage();
     }
 
     if (mesh.hasData<UInt>("tag_1", type, _not_ghost)) {
       const auto & data_tag_1 = mesh.getData<UInt>("tag_1", type, _not_ghost);
       tag[1] = data_tag_1.storage();
     }
 
     for (UInt i = 0; i < connectivity.size(); ++i) {
       UInt offset = i * connectivity.getNbComponent();
       outfile << element_idx << " " << _akantu_to_msh_element_types[type]
               << " 2";
 
       /// \todo write the real data in the file
       for (UInt t = 0; t < 2; ++t)
         if (tag[t])
           outfile << " " << tag[t][i];
         else
           outfile << " 0";
 
       for (UInt j = 0; j < connectivity.getNbComponent(); ++j) {
         outfile << " " << connectivity.storage()[offset + j] + 1;
       }
       outfile << std::endl;
       element_idx++;
     }
   }
 
   outfile << "$EndElements" << std::endl;
   ;
 
   outfile.close();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/io/parser/algebraic_parser.hh b/src/io/parser/algebraic_parser.hh
index c32a6a8d2..be4102241 100644
--- a/src/io/parser/algebraic_parser.hh
+++ b/src/io/parser/algebraic_parser.hh
@@ -1,513 +1,513 @@
 /**
  * @file   algebraic_parser.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Wed Nov 11 2015
  *
  * @brief  algebraic_parser definition of the grammar
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 /* -------------------------------------------------------------------------- */
 // Boost
 #include <boost/config/warning_disable.hpp>
 #include <boost/spirit/include/qi.hpp>
 #include <boost/spirit/include/phoenix.hpp>
 /* -------------------------------------------------------------------------- */
 
 
 #ifndef __AKANTU_ALGEBRAIC_PARSER_HH__
 #define __AKANTU_ALGEBRAIC_PARSER_HH__
 
 namespace spirit = boost::spirit;
 namespace qi = boost::spirit::qi;
 namespace lbs = boost::spirit::qi::labels;
 namespace ascii = boost::spirit::ascii;
 namespace phx = boost::phoenix;
 
 namespace akantu {
 namespace parser {
   struct algebraic_error_handler_ {
     template <typename, typename, typename> struct result {
-      typedef void type;
+      using type = void;
     };
 
     template <typename Iterator>
     void operator()(qi::info const & what, Iterator err_pos,
                     Iterator last) const {
       AKANTU_EXCEPTION(
           "Error! Expecting "
           << what // what failed?
           << " here: \""
           << std::string(err_pos, last) // iterators to error-pos, end
           << "\"");
     }
   };
 
   static Real my_min(Real a, Real b) { return std::min(a, b); }
   static Real my_max(Real a, Real b) { return std::max(a, b); }
   static Real my_pow(Real a, Real b) { return std::pow(a, b); }
 
   static Real eval_param(const ID & a, const ParserSection & section) {
     return section.getParameter(a, _ppsc_current_and_parent_scope);
   }
 
   static Real unary_func(Real (*func)(Real), Real a) { return func(a); }
 
   static Real binary_func(Real (*func)(Real, Real), Real a, Real b) {
     return func(a, b);
   }
 
   template <class Iterator, typename Skipper = spirit::unused_type>
   struct AlgebraicGrammar : qi::grammar<Iterator, Real(), Skipper> {
     AlgebraicGrammar(const ParserSection & section)
         : AlgebraicGrammar::base_type(start, "algebraic_grammar"),
           section(section) {
       // phx::function<lazy_pow_>  lazy_pow;
       // phx::function<lazy_unary_func_>  lazy_unary_func;
       // phx::function<lazy_binary_func_> lazy_binary_func;
       // phx::function<lazy_eval_param_> lazy_eval_param;
       /* clang-format off */
       start
         =   expr.alias()
         ;
 
       expr
         =   term                  [ lbs::_val  = lbs::_1 ]
             >> *( ('+' > term     [ lbs::_val += lbs::_1 ])
                 | ('-' > term     [ lbs::_val -= lbs::_1 ])
                 )
         ;
 
       term
         =   factor                [ lbs::_val  = lbs::_1 ]
             >> *( ('*' > factor   [ lbs::_val *= lbs::_1 ])
                 | ('/' > factor   [ lbs::_val /= lbs::_1 ])
                 )
         ;
 
       factor
         =   number                [ lbs::_val = lbs::_1 ]
         >> *("**" > number    [ lbs::_val = phx::bind(&my_pow, lbs::_val, lbs::_1) ])
         ;
 
       number
         =   real                  [ lbs::_val =  lbs::_1 ]
         |   ('-' > number         [ lbs::_val = -lbs::_1 ])
         |   ('+' > number         [ lbs::_val =  lbs::_1 ])
         |   constant              [ lbs::_val =  lbs::_1 ]
         |   function              [ lbs::_val =  lbs::_1 ]
         |   ('(' > expr > ')')    [ lbs::_val =  lbs::_1 ]
         |   variable              [ lbs::_val =  lbs::_1 ]
         ;
 
       function
         =   (qi::no_case[unary_function]
              > '('
              > expr
              > ')')               [ lbs::_val = phx::bind(&unary_func, lbs::_1, lbs::_2) ]
         |   (qi::no_case[binary_function]
              > '(' >> expr
              > ',' >> expr
              > ')')               [ lbs::_val = phx::bind(&binary_func ,lbs::_1, lbs::_2, lbs::_3) ]
         ;
 
       variable
         =   key [ lbs::_val = phx::bind(&eval_param, lbs::_1, section) ]
         ;
 
       key
         =   qi::no_skip[qi::char_("a-zA-Z_") >> *qi::char_("a-zA-Z_0-9")] // coming from the InputFileGrammar
         ;
 
 #ifndef M_PI
 #  define M_PI          3.14159265358979323846
 #endif
 #ifndef M_E
 #  define M_E           2.7182818284590452354
 #endif
       constant.add
         ("pi", M_PI)
         ("e",  M_E);
 
       unary_function.add
         ("abs"   , &std::abs   )
         ("acos"  , &std::acos  )
         ("asin"  , &std::asin  )
         ("atan"  , &std::atan  )
         ("ceil"  , &std::ceil  )
         ("cos"   , &std::cos   )
         ("cosh"  , &std::cosh  )
         ("exp"   , &std::exp   )
         ("floor" , &std::floor )
         ("log10" , &std::log10 )
         ("log"   , &std::log   )
         ("sin"   , &std::sin   )
         ("sinh"  , &std::sinh  )
         ("sqrt"  , &std::sqrt  )
         ("tan"   , &std::tan   )
         ("tanh"  , &std::tanh  )
         ("acosh" , &std::acosh )
         ("asinh" , &std::asinh )
         ("atanh" , &std::atanh )
         ("exp2"  , &std::exp2  )
         ("expm1" , &std::expm1 )
         ("log1p" , &std::log1p )
         ("log2"  , &std::log2  )
         ("erf"   , &std::erf   )
         ("erfc"  , &std::erfc  )
         ("lgamma", &std::lgamma)
         ("tgamma", &std::tgamma)
         ("trunc" , &std::trunc )
         ("round" , &std::round )
         //      ("crbt"  , &std::crbt  )
         ;
 
       binary_function.add
         ("pow"  , &std::pow      )
         ("min"  , &parser::my_min)
         ("max"  , &parser::my_max)
         ("atan2", &std::atan2    )
         ("fmod" , &std::fmod     )
         ("hypot", &std::hypot    )
           ;
 
 #if !defined(AKANTU_NDEBUG)
       phx::function<algebraic_error_handler_> const error_handler = algebraic_error_handler_();
       qi::on_error<qi::fail>(start, error_handler(lbs::_4, lbs::_3, lbs::_2));
 #endif
 
       expr    .name("expression");
       term    .name("term");
       factor  .name("factor");
       number  .name("numerical-value");
       variable.name("variable");
       function.name("function");
 
       constant.name("constants-list");
       unary_function.name("unary-functions-list");
       binary_function.name("binary-functions-list");
 
 #if !defined AKANTU_NDEBUG
       if(AKANTU_DEBUG_TEST(dblDebug)) {
         qi::debug(expr);
         qi::debug(term);
         qi::debug(factor);
         qi::debug(number);
         qi::debug(variable);
         qi::debug(function);
       }
 #endif
     }
     /* clang-format on */
   private:
     qi::rule<Iterator, Real(), Skipper> start;
     qi::rule<Iterator, Real(), Skipper> expr;
     qi::rule<Iterator, Real(), Skipper> term;
     qi::rule<Iterator, Real(), Skipper> factor;
     qi::rule<Iterator, Real(), Skipper> number;
     qi::rule<Iterator, Real(), Skipper> variable;
     qi::rule<Iterator, Real(), Skipper> function;
 
     qi::rule<Iterator, std::string(), Skipper> key;
 
     qi::real_parser<Real, qi::real_policies<Real> > real;
 
     qi::symbols<char, Real> constant;
     qi::symbols<char, Real (*)(Real)> unary_function;
     qi::symbols<char, Real (*)(Real, Real)> binary_function;
 
     const ParserSection & section;
   };
 
   /* ---------------------------------------------------------------------- */
   /* Vector Parser                                                          */
   /* ---------------------------------------------------------------------- */
   struct parsable_vector {
     operator Vector<Real>() {
       Vector<Real> tmp(_cells.size());
-      std::vector<Real>::iterator it = _cells.begin();
+      auto it = _cells.begin();
       for (UInt i = 0; it != _cells.end(); ++it, ++i)
         tmp(i) = *it;
       return tmp;
     }
 
     std::vector<Real> _cells;
   };
 
   inline std::ostream & operator<<(std::ostream & stream,
                                    const parsable_vector & pv) {
     stream << "pv[";
-    std::vector<Real>::const_iterator it = pv._cells.begin();
+    auto it = pv._cells.begin();
     if (it != pv._cells.end()) {
       stream << *it;
       for (++it; it != pv._cells.end(); ++it)
         stream << ", " << *it;
     }
     stream << "]";
     return stream;
   }
 
   struct parsable_matrix {
     operator Matrix<Real>() {
       size_t cols = 0;
-      std::vector<parsable_vector>::iterator it_rows = _cells.begin();
+      auto it_rows = _cells.begin();
       for (; it_rows != _cells.end(); ++it_rows)
         cols = std::max(cols, it_rows->_cells.size());
 
       Matrix<Real> tmp(_cells.size(), _cells[0]._cells.size(), 0.);
 
       it_rows = _cells.begin();
       for (UInt i = 0; it_rows != _cells.end(); ++it_rows, ++i) {
-        std::vector<Real>::iterator it_cols = it_rows->_cells.begin();
+        auto it_cols = it_rows->_cells.begin();
         for (UInt j = 0; it_cols != it_rows->_cells.end(); ++it_cols, ++j) {
           tmp(i, j) = *it_cols;
         }
       }
       return tmp;
     }
 
     std::vector<parsable_vector> _cells;
   };
 
   inline std::ostream & operator<<(std::ostream & stream,
                                    const parsable_matrix & pm) {
     stream << "pm[";
-    std::vector<parsable_vector>::const_iterator it = pm._cells.begin();
+    auto it = pm._cells.begin();
     if (it != pm._cells.end()) {
       stream << *it;
       for (++it; it != pm._cells.end(); ++it)
         stream << ", " << *it;
     }
     stream << "]";
     return stream;
   }
 
   /* ---------------------------------------------------------------------- */
   template <typename T1, typename T2>
   static void cont_add(T1 & cont, T2 & value) {
     cont._cells.push_back(value);
   }
 
   /* ---------------------------------------------------------------------- */
   template <class Iterator, typename Skipper = spirit::unused_type>
   struct VectorGrammar : qi::grammar<Iterator, parsable_vector(), Skipper> {
     VectorGrammar(const ParserSection & section)
         : VectorGrammar::base_type(start, "vector_algebraic_grammar"),
           number(section) {
 
       start = '[' > vector > ']';
 
       vector =
           (number[phx::bind(&cont_add<parsable_vector, Real>, lbs::_a,
                             lbs::_1)] >>
            *(',' >> number[phx::bind(&cont_add<parsable_vector, Real>, lbs::_a,
                                      lbs::_1)]))[lbs::_val = lbs::_a];
 
 #if !defined(AKANTU_NDEBUG) && defined(AKANTU_CORE_CXX_11)
       phx::function<algebraic_error_handler_> const error_handler =
           algebraic_error_handler_();
       qi::on_error<qi::fail>(start, error_handler(lbs::_4, lbs::_3, lbs::_2));
 #endif
 
       start.name("start");
       vector.name("vector");
       number.name("value");
 
 #if !defined AKANTU_NDEBUG
       if (AKANTU_DEBUG_TEST(dblDebug)) {
         qi::debug(start);
         qi::debug(vector);
       }
 #endif
     }
 
   private:
     qi::rule<Iterator, parsable_vector(), Skipper> start;
     qi::rule<Iterator, parsable_vector(), qi::locals<parsable_vector>, Skipper>
         vector;
     qi::rule<Iterator, Real(), Skipper> value;
     AlgebraicGrammar<Iterator, Skipper> number;
   };
 
   /* ---------------------------------------------------------------------- */
   static inline bool vector_eval(const ID & a, const ParserSection & section,
                           parsable_vector & result) {
     std::string value = section.getParameter(a, _ppsc_current_and_parent_scope);
     std::string::const_iterator b = value.begin();
     std::string::const_iterator e = value.end();
     parser::VectorGrammar<std::string::const_iterator, qi::space_type> grammar(
         section);
     return qi::phrase_parse(b, e, grammar, qi::space, result);
   }
 
   /* ---------------------------------------------------------------------- */
   template <class Iterator, typename Skipper = spirit::unused_type>
   struct MatrixGrammar : qi::grammar<Iterator, parsable_matrix(), Skipper> {
     MatrixGrammar(const ParserSection & section)
         : MatrixGrammar::base_type(start, "matrix_algebraic_grammar"),
           vector(section) {
 
       start = '[' >> matrix >> ']';
 
       matrix =
           (rows[phx::bind(&cont_add<parsable_matrix, parsable_vector>, lbs::_a,
                           lbs::_1)] >>
            *(',' >> rows[phx::bind(&cont_add<parsable_matrix, parsable_vector>,
                                    lbs::_a, lbs::_1)]))[lbs::_val = lbs::_a];
 
       rows = eval_vector | vector;
 
       eval_vector = (key[lbs::_pass = phx::bind(&vector_eval, lbs::_1, section,
                                                 lbs::_a)])[lbs::_val = lbs::_a];
 
       key = qi::char_("a-zA-Z_") >>
             *qi::char_("a-zA-Z_0-9") // coming from the InputFileGrammar
           ;
 
 #if !defined(AKANTU_NDEBUG) && defined(AKANTU_CORE_CXX_11)
       phx::function<algebraic_error_handler_> const error_handler =
           algebraic_error_handler_();
       qi::on_error<qi::fail>(start, error_handler(lbs::_4, lbs::_3, lbs::_2));
 #endif
 
       start.name("matrix");
       matrix.name("all_rows");
       rows.name("rows");
       vector.name("vector");
       eval_vector.name("eval_vector");
 
 #ifndef AKANTU_NDEBUG
       if (AKANTU_DEBUG_TEST(dblDebug)) {
         qi::debug(start);
         qi::debug(matrix);
         qi::debug(rows);
         qi::debug(eval_vector);
         qi::debug(key);
       }
 #endif
     }
 
   private:
     qi::rule<Iterator, parsable_matrix(), Skipper> start;
     qi::rule<Iterator, parsable_matrix(), qi::locals<parsable_matrix>, Skipper>
         matrix;
     qi::rule<Iterator, parsable_vector(), Skipper> rows;
     qi::rule<Iterator, parsable_vector(), qi::locals<parsable_vector>, Skipper>
         eval_vector;
     qi::rule<Iterator, std::string(), Skipper> key;
     VectorGrammar<Iterator, Skipper> vector;
   };
 
   /* ---------------------------------------------------------------------- */
   /* Randon Generator                                                       */
   /* ---------------------------------------------------------------------- */
   struct ParsableRandomGenerator {
     ParsableRandomGenerator(
         Real base = Real(),
         const RandomDistributionType & type = _rdt_not_defined,
         const parsable_vector & parameters = parsable_vector())
         : base(base), type(type), parameters(parameters) {}
 
     Real base;
     RandomDistributionType type;
     parsable_vector parameters;
   };
 
   inline std::ostream & operator<<(std::ostream & stream,
                                    const ParsableRandomGenerator & prg) {
     stream << "prg[" << prg.base << " " << UInt(prg.type) << " "
            << prg.parameters << "]";
     return stream;
   }
 
   /* ---------------------------------------------------------------------- */
   template <class Iterator, typename Skipper = spirit::unused_type>
   struct RandomGeneratorGrammar
       : qi::grammar<Iterator, ParsableRandomGenerator(), Skipper> {
     RandomGeneratorGrammar(const ParserSection & section)
         : RandomGeneratorGrammar::base_type(start, "random_generator_grammar"),
           number(section) {
 
       start = generator.alias();
 
       generator =
           qi::hold[distribution[lbs::_val = lbs::_1]] |
           number[lbs::_val = phx::construct<ParsableRandomGenerator>(lbs::_1)];
 
       distribution = (number >> generator_type >> '[' >> generator_params >>
                       ']')[lbs::_val = phx::construct<ParsableRandomGenerator>(
                                lbs::_1, lbs::_2, lbs::_3)];
 
       generator_params =
           (number[phx::bind(&cont_add<parsable_vector, Real>, lbs::_a,
                             lbs::_1)] >>
            *(',' > number[phx::bind(&cont_add<parsable_vector, Real>, lbs::_a,
                                     lbs::_1)]))[lbs::_val = lbs::_a];
 
 #define AKANTU_RANDOM_DISTRIBUTION_TYPE_ADD(r, data, elem)                     \
   (BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(2, 0, elem)),                        \
    AKANTU_RANDOM_DISTRIBUTION_TYPES_PREFIX(BOOST_PP_TUPLE_ELEM(2, 0, elem)))
 
       generator_type.add BOOST_PP_SEQ_FOR_EACH(
           AKANTU_RANDOM_DISTRIBUTION_TYPE_ADD, _,
           AKANTU_RANDOM_DISTRIBUTION_TYPES);
 #undef AKANTU_RANDOM_DISTRIBUTION_TYPE_ADD
 
 #if !defined(AKANTU_NDEBUG) && defined(AKANTU_CORE_CXX_11)
       phx::function<algebraic_error_handler_> const error_handler =
           algebraic_error_handler_();
       qi::on_error<qi::fail>(start, error_handler(lbs::_4, lbs::_3, lbs::_2));
 #endif
 
       start.name("random-generator");
       generator.name("random-generator");
       distribution.name("random-distribution");
       generator_type.name("generator-type");
       generator_params.name("generator-parameters");
       number.name("number");
 
 #ifndef AKANTU_NDEBUG
       if (AKANTU_DEBUG_TEST(dblDebug)) {
         qi::debug(generator);
         qi::debug(distribution);
         qi::debug(generator_params);
       }
 #endif
     }
 
   private:
     qi::rule<Iterator, ParsableRandomGenerator(), Skipper> start;
     qi::rule<Iterator, ParsableRandomGenerator(), Skipper> generator;
     qi::rule<Iterator, ParsableRandomGenerator(), Skipper> distribution;
     qi::rule<Iterator, parsable_vector(), qi::locals<parsable_vector>, Skipper>
         generator_params;
     AlgebraicGrammar<Iterator, Skipper> number;
     qi::symbols<char, RandomDistributionType> generator_type;
   };
 }
 }
 
 #endif /* __AKANTU_ALGEBRAIC_PARSER_HH__ */
diff --git a/src/io/parser/cppargparse/cppargparse.cc b/src/io/parser/cppargparse/cppargparse.cc
index acdc871a8..bb1c85158 100644
--- a/src/io/parser/cppargparse/cppargparse.cc
+++ b/src/io/parser/cppargparse/cppargparse.cc
@@ -1,531 +1,523 @@
 /**
  * @file   cppargparse.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Apr 03 2014
  * @date last modification: Wed Nov 11 2015
  *
  * @brief  implementation of the ArgumentParser
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "cppargparse.hh"
 
 #include <cstdlib>
 #include <cstring>
 #include <libgen.h>
 
 #include <iostream>
 #include <iomanip>
 #include <string>
 #include <queue>
 #include <sstream>
 #include <algorithm>
 
 #include <exception>
 #include <stdexcept>
 #include <string.h>
 
 namespace cppargparse {
 
 /* -------------------------------------------------------------------------- */
 static inline std::string to_upper(const std::string & str) {
   std::string lstr = str;
   std::transform(lstr.begin(), lstr.end(), lstr.begin(),
                  (int (*)(int))std::toupper);
   return lstr;
 }
 
 /* -------------------------------------------------------------------------- */
 /* ArgumentParser                                                             */
 /* -------------------------------------------------------------------------- */
-ArgumentParser::ArgumentParser() : external_exit(nullptr), prank(0), psize(1) {
+ArgumentParser::ArgumentParser() {
   this->addArgument("-h;--help", "show this help message and exit", 0, _boolean,
                     false, true);
 }
 
 /* -------------------------------------------------------------------------- */
 ArgumentParser::~ArgumentParser() {
-  for (_Arguments::iterator it = arguments.begin(); it != arguments.end();
-       ++it) {
+  for (auto it = arguments.begin(); it != arguments.end(); ++it) {
     delete it->second;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void ArgumentParser::setParallelContext(int prank, int psize) {
   this->prank = prank;
   this->psize = psize;
 }
 
 /* -------------------------------------------------------------------------- */
 void ArgumentParser::_exit(const std::string & msg, int status) {
   if (prank == 0) {
     if (msg != "") {
       std::cerr << msg << std::endl;
       std::cerr << std::endl;
     }
 
     this->print_help(std::cerr);
   }
 
   if (external_exit)
     (*external_exit)(status);
   else {
     exit(status);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 const ArgumentParser::Argument & ArgumentParser::
 operator[](const std::string & name) const {
-  Arguments::const_iterator it = success_parsed.find(name);
+  auto it = success_parsed.find(name);
 
   if (it != success_parsed.end()) {
     return *(it->second);
   } else {
     throw std::range_error("No argument named \'" + name +
                            "\' was found in the parsed argument," +
                            " make sur to specify it \'required\'" +
                            " or to give it a default value");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 bool ArgumentParser::has(const std::string & name) const {
   return (success_parsed.find(name) != success_parsed.end());
 }
 
 /* -------------------------------------------------------------------------- */
 void ArgumentParser::addArgument(const std::string & name_or_flag,
                                  const std::string & help, int nargs,
                                  ArgumentType type) {
   _addArgument(name_or_flag, help, nargs, type);
 }
 
 /* -------------------------------------------------------------------------- */
 ArgumentParser::_Argument &
 ArgumentParser::_addArgument(const std::string & name, const std::string & help,
                              int nargs, ArgumentType type) {
   _Argument * arg = nullptr;
 
   switch (type) {
   case _string: {
     arg = new ArgumentStorage<std::string>();
     break;
   }
   case _float: {
     arg = new ArgumentStorage<double>();
     break;
   }
   case _integer: {
     arg = new ArgumentStorage<int>();
     break;
   }
   case _boolean: {
     arg = new ArgumentStorage<bool>();
     break;
   }
   }
 
   arg->help = help;
   arg->nargs = nargs;
   arg->type = type;
 
   std::stringstream sstr(name);
   std::string item;
   std::vector<std::string> tmp_keys;
   while (std::getline(sstr, item, ';')) {
     tmp_keys.push_back(item);
   }
 
   int long_key = -1;
   int short_key = -1;
   bool problem = (tmp_keys.size() > 2) || (name == "");
-  for (std::vector<std::string>::iterator it = tmp_keys.begin();
-       it != tmp_keys.end(); ++it) {
+  for (auto it = tmp_keys.begin(); it != tmp_keys.end(); ++it) {
     if (it->find("--") == 0) {
       problem |= (long_key != -1);
       long_key = it - tmp_keys.begin();
     } else if (it->find("-") == 0) {
       problem |= (long_key != -1);
       short_key = it - tmp_keys.begin();
     }
   }
 
   problem |= ((tmp_keys.size() == 2) && (long_key == -1 || short_key == -1));
 
   if (problem) {
     delete arg;
     throw std::invalid_argument("Synthax of name or flags is not correct. "
                                 "Possible synthax are \'-f\', \'-f;--foo\', "
                                 "\'--foo\', \'bar\'");
   }
 
   if (long_key != -1) {
     arg->name = tmp_keys[long_key];
     arg->name.erase(0, 2);
   } else if (short_key != -1) {
     arg->name = tmp_keys[short_key];
     arg->name.erase(0, 1);
   } else {
     arg->name = tmp_keys[0];
     pos_args.push_back(arg);
     arg->required = (nargs != _one_if_possible);
     arg->is_positional = true;
   }
 
   arguments[arg->name] = arg;
 
   if (!arg->is_positional) {
     if (short_key != -1) {
       std::string key = tmp_keys[short_key];
       key_args[key] = arg;
       arg->keys.push_back(key);
     }
 
     if (long_key != -1) {
       std::string key = tmp_keys[long_key];
       key_args[key] = arg;
       arg->keys.push_back(key);
     }
   }
 
   return *arg;
 }
 
 #if not HAVE_STRDUP
 static char * strdup(const char * str) {
   size_t len = strlen(str);
-  char *x = (char *)malloc(len+1); /* 1 for the null terminator */
+  auto * x = (char *)malloc(len + 1); /* 1 for the null terminator */
   if(!x)
     return nullptr;    /* malloc could not allocate memory */
   memcpy(x,str,len+1); /* copy the string into the new buffer */
   return x;
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 void ArgumentParser::parse(int & argc, char **& argv, int flags,
                            bool parse_help) {
   bool stop_in_not_parsed = flags & _stop_on_not_parsed;
   bool remove_parsed = flags & _remove_parsed;
 
   std::vector<std::string> argvs;
 
+  argvs.reserve(argc);
   for (int i = 0; i < argc; ++i) {
-    argvs.push_back(std::string(argv[i]));
+    argvs.emplace_back(argv[i]);
   }
 
   unsigned int current_position = 0;
   if (this->program_name == "" && argc > 0) {
     std::string prog = argvs[current_position];
     const char * c_prog = prog.c_str();
     char * c_prog_tmp = strdup(c_prog);
     std::string base_prog(basename(c_prog_tmp));
     this->program_name = base_prog;
     std::free(c_prog_tmp);
   }
 
   std::queue<_Argument *> positional_queue;
-  for (PositionalArgument::iterator it = pos_args.begin(); it != pos_args.end();
-       ++it)
+  for (auto it = pos_args.begin(); it != pos_args.end(); ++it)
     positional_queue.push(*it);
 
   std::vector<int> argvs_to_remove;
   ++current_position; // consume argv[0]
   while (current_position < argvs.size()) {
     std::string arg = argvs[current_position];
     ++current_position;
 
-    ArgumentKeyMap::iterator key_it = key_args.find(arg);
+    auto key_it = key_args.find(arg);
 
     bool is_positional = false;
     _Argument * argument_ptr = nullptr;
     if (key_it == key_args.end()) {
       if (positional_queue.empty()) {
         if (stop_in_not_parsed)
           this->_exit("Argument " + arg + " not recognized", EXIT_FAILURE);
         continue;
       } else {
         argument_ptr = positional_queue.front();
         is_positional = true;
         --current_position;
       }
     } else {
       argument_ptr = key_it->second;
     }
 
     if (remove_parsed && !is_positional && argument_ptr->name != "help") {
       argvs_to_remove.push_back(current_position - 1);
     }
 
     _Argument & argument = *argument_ptr;
 
     unsigned int min_nb_val = 0, max_nb_val = 0;
     switch (argument.nargs) {
     case _one_if_possible:
       max_nb_val = 1;
       break; // "?"
     case _at_least_one:
       min_nb_val = 1; // "+"
       /* FALLTHRU */
       /* [[fallthrough]]; un-comment when compiler will get it*/
     case _any:
       max_nb_val = argc - current_position;
       break; // "*"
     default:
       min_nb_val = max_nb_val = argument.nargs; // "N"
     }
 
     std::vector<std::string> values;
     unsigned int arg_consumed = 0;
     if (max_nb_val <= (argc - current_position)) {
       for (; arg_consumed < max_nb_val; ++arg_consumed) {
         std::string v = argvs[current_position];
         ++current_position;
         bool is_key = key_args.find(v) != key_args.end();
         bool is_good_type = checkType(argument.type, v);
 
         if (!is_key && is_good_type) {
           values.push_back(v);
           if (remove_parsed)
             argvs_to_remove.push_back(current_position - 1);
         } else {
           // unconsume not parsed argument for optional
           if (!is_positional || is_key)
             --current_position;
           break;
         }
       }
     }
 
     if (arg_consumed < min_nb_val) {
       if (!is_positional) {
         this->_exit("Not enought values for the argument " + argument.name +
                         " where provided",
                     EXIT_FAILURE);
       } else {
         if (stop_in_not_parsed)
           this->_exit("Argument " + arg + " not recognized", EXIT_FAILURE);
       }
     } else {
       if (is_positional)
         positional_queue.pop();
 
       if (!argument.parsed) {
         success_parsed[argument.name] = &argument;
         argument.parsed = true;
         if ((argument.nargs == _one_if_possible || argument.nargs == 0) &&
             arg_consumed == 0) {
           if (argument.has_const)
             argument.setToConst();
           else if (argument.has_default)
             argument.setToDefault();
         } else {
           argument.setValues(values);
         }
       } else {
         this->_exit("Argument " + argument.name +
                         " already present in the list of argument",
                     EXIT_FAILURE);
       }
     }
   }
 
-  for (_Arguments::iterator ait = arguments.begin(); ait != arguments.end();
-       ++ait) {
+  for (auto ait = arguments.begin(); ait != arguments.end(); ++ait) {
     _Argument & argument = *(ait->second);
     if (!argument.parsed) {
       if (argument.has_default) {
         argument.setToDefault();
         success_parsed[argument.name] = &argument;
       }
 
       if (argument.required) {
         this->_exit("Argument " + argument.name + " required but not given!",
                     EXIT_FAILURE);
       }
     }
   }
 
   // removing the parsed argument if remove_parsed is true
   if (argvs_to_remove.size()) {
     std::vector<int>::const_iterator next_to_remove = argvs_to_remove.begin();
     for (int i = 0, c = 0; i < argc; ++i) {
       if (next_to_remove == argvs_to_remove.end() || i != *next_to_remove) {
         argv[c] = argv[i];
         ++c;
       } else {
         if (next_to_remove != argvs_to_remove.end())
           ++next_to_remove;
       }
     }
 
     argc -= argvs_to_remove.size();
   }
 
   this->argc = &argc;
   this->argv = &argv;
 
   if (this->arguments["help"]->parsed && parse_help) {
     this->_exit();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 bool ArgumentParser::checkType(ArgumentType type,
                                const std::string & value) const {
   std::stringstream sstr(value);
   switch (type) {
   case _string: {
     std::string s;
     sstr >> s;
     break;
   }
   case _float: {
     double d;
     sstr >> d;
     break;
   }
   case _integer: {
     int i;
     sstr >> i;
     break;
   }
   case _boolean: {
     bool b;
     sstr >> b;
     break;
   }
   }
 
   return (sstr.fail() == false);
 }
 
 /* -------------------------------------------------------------------------- */
 void ArgumentParser::printself(std::ostream & stream) const {
-  for (Arguments::const_iterator it = success_parsed.begin();
-       it != success_parsed.end(); ++it) {
+  for (auto it = success_parsed.begin(); it != success_parsed.end(); ++it) {
     const Argument & argument = *(it->second);
     argument.printself(stream);
     stream << std::endl;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void ArgumentParser::print_usage(std::ostream & stream) const {
   stream << "Usage: " << this->program_name;
 
   // print shorten usage
-  for (_Arguments::const_iterator it = arguments.begin(); it != arguments.end();
-       ++it) {
+  for (auto it = arguments.begin(); it != arguments.end(); ++it) {
     const _Argument & argument = *(it->second);
     if (!argument.is_positional) {
       if (!argument.required)
         stream << " [";
       stream << argument.keys[0];
       this->print_usage_nargs(stream, argument);
       if (!argument.required)
         stream << "]";
     }
   }
 
-  for (PositionalArgument::const_iterator it = pos_args.begin();
-       it != pos_args.end(); ++it) {
+  for (auto it = pos_args.begin(); it != pos_args.end(); ++it) {
     const _Argument & argument = **it;
     this->print_usage_nargs(stream, argument);
   }
 
   stream << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 void ArgumentParser::print_usage_nargs(std::ostream & stream,
                                        const _Argument & argument) const {
   std::string u_name = to_upper(argument.name);
   switch (argument.nargs) {
   case _one_if_possible:
     stream << " [" << u_name << "]";
     break;
   case _at_least_one:
     stream << " " << u_name;
     /* FALLTHRU */
     /* [[fallthrough]]; un-comment when compiler will get it */
   case _any:
     stream << " [" << u_name << " ...]";
     break;
   default:
     for (int i = 0; i < argument.nargs; ++i) {
       stream << " " << u_name;
     }
   }
 }
 
 void ArgumentParser::print_help(std::ostream & stream) const {
   this->print_usage(stream);
   if (!pos_args.empty()) {
     stream << std::endl;
     stream << "positional arguments:" << std::endl;
-    for (PositionalArgument::const_iterator it = pos_args.begin();
-         it != pos_args.end(); ++it) {
+    for (auto it = pos_args.begin(); it != pos_args.end(); ++it) {
       const _Argument & argument = **it;
       this->print_help_argument(stream, argument);
     }
   }
 
   if (!key_args.empty()) {
     stream << std::endl;
     stream << "optional arguments:" << std::endl;
-    for (_Arguments::const_iterator it = arguments.begin();
-         it != arguments.end(); ++it) {
+    for (auto it = arguments.begin(); it != arguments.end(); ++it) {
       const _Argument & argument = *(it->second);
       if (!argument.is_positional) {
         this->print_help_argument(stream, argument);
       }
     }
   }
 }
 
 void ArgumentParser::print_help_argument(std::ostream & stream,
                                          const _Argument & argument) const {
   std::string key("");
   if (argument.is_positional)
     key = argument.name;
   else {
     std::stringstream sstr;
     for (unsigned int i = 0; i < argument.keys.size(); ++i) {
       if (i != 0)
         sstr << ", ";
       sstr << argument.keys[i];
       this->print_usage_nargs(sstr, argument);
     }
     key = sstr.str();
   }
 
   stream << "  " << std::left << std::setw(15) << key << "  " << argument.help;
   argument.printDefault(stream);
 
   stream << std::endl;
 }
 }
diff --git a/src/io/parser/cppargparse/cppargparse.hh b/src/io/parser/cppargparse/cppargparse.hh
index 93ccfb49e..4f05d6aae 100644
--- a/src/io/parser/cppargparse/cppargparse.hh
+++ b/src/io/parser/cppargparse/cppargparse.hh
@@ -1,201 +1,201 @@
 /**
  * @file   cppargparse.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Apr 03 2014
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Get the commandline options and store them as short, long and others
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <map>
 #include <string>
 #include <iostream>
 #include <vector>
 
 #ifndef __CPPARGPARSE_HH__
 #define __CPPARGPARSE_HH__
 
 /* -------------------------------------------------------------------------- */
 namespace cppargparse {
 
 /// define the types of the arguments
 enum ArgumentType { _string, _integer, _float, _boolean };
 
 /// Defines how many arguments to expect
 enum ArgumentNargs { _one_if_possible = -1, _at_least_one = -2, _any = -3 };
 
 /// Flags for the parse function of ArgumentParser
 enum ParseFlags {
   _no_flags = 0x0,           ///< Default behavior
   _stop_on_not_parsed = 0x1, ///< Stop on unknown arguments
   _remove_parsed = 0x2       ///< Remove parsed arguments from argc argv
 };
 
 /// Helps to combine parse flags
 inline ParseFlags operator|(const ParseFlags & a, const ParseFlags & b) {
-  ParseFlags tmp = ParseFlags(int(a) | int(b));
+  auto tmp = ParseFlags(int(a) | int(b));
   return tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 
 /**
  * ArgumentParser is a class that mimics the Python argparse module
  */
 class ArgumentParser {
 public:
   /// public definition of an argument
   class Argument {
   public:
     Argument() : name(std::string()) {}
-    virtual ~Argument() {}
+    virtual ~Argument() = default;
     virtual void printself(std::ostream & stream) const = 0;
     template <class T> operator T() const;
     std::string name;
   };
 
   /// constructor
   ArgumentParser();
 
   /// destroy everything
   ~ArgumentParser();
 
   /// add an argument with a description
   void addArgument(const std::string & name_or_flag, const std::string & help,
                    int nargs = 1, ArgumentType type = _string);
 
   /// add an argument with an help and a default value
   template <class T>
   void addArgument(const std::string & name_or_flag, const std::string & help,
                    int nargs, ArgumentType type, T def);
 
   /// add an argument with an help and a default + const value
   template <class T>
   void addArgument(const std::string & name_or_flag, const std::string & help,
                    int nargs, ArgumentType type, T def, T cons);
 
   /// parse argc, argv
   void parse(int & argc, char **& argv, int flags = _stop_on_not_parsed,
              bool parse_help = true);
 
   /// get the last argc parsed
   int & getArgC() { return *(this->argc); }
 
   /// get the last argv parsed
   char** & getArgV() { return *(this->argv); }
 
   /// print the content in the stream
   void printself(std::ostream & stream) const;
 
   /// print the help text
   void print_help(std::ostream & stream = std::cout) const;
 
   /// print the usage text
   void print_usage(std::ostream & stream = std::cout) const;
 
   /// set an external function to replace the exit function from the stdlib
   void setExternalExitFunction(void (*external_exit)(int)) {
     this->external_exit = external_exit;
   }
 
   /// accessor for a registered argument that was parsed, throw an exception if
   /// the argument does not exist or was not set (parsed or default value)
   const Argument & operator[](const std::string & name) const;
 
   /// is the argument present
   bool has(const std::string &) const;
 
   /// set the parallel context to avoid multiple help messages in
   /// multiproc/thread cases
   void setParallelContext(int prank, int psize);
 
 public:
 
   /// Internal class describing the arguments
   struct _Argument;
   /// Stores that value of an argument
   template<class T> class ArgumentStorage;
 
 private:
   /// Internal function to be used by the public addArgument
   _Argument & _addArgument(const std::string & name_or_flag,
                            const std::string & description, int nargs,
                            ArgumentType type);
 
   void _exit(const std::string & msg = "", int status = 0);
   bool checkType(ArgumentType type, const std::string & value) const;
 
   /// function to help to print help
   void print_usage_nargs(std::ostream & stream,
                          const _Argument & argument) const;
   /// function to help to print help
   void print_help_argument(std::ostream & stream,
                            const _Argument & argument) const;
 
 private:
   /// public arguments storage
   typedef std::map<std::string, Argument *> Arguments;
   /// internal arguments storage
   typedef std::map<std::string, _Argument *> _Arguments;
   /// association key argument
   typedef std::map<std::string, _Argument *> ArgumentKeyMap;
   /// position arguments
-  typedef std::vector<_Argument *> PositionalArgument;
+  using PositionalArgument = std::vector<_Argument *>;
 
   /// internal storage of arguments declared by the user
   _Arguments arguments;
   /// list of arguments successfully parsed
   Arguments success_parsed;
   /// keys associated to arguments
   ArgumentKeyMap key_args;
   /// positional arguments
   PositionalArgument pos_args;
 
   /// program name
   std::string program_name;
 
   /// exit function to use
-  void (*external_exit)(int);
+  void (*external_exit)(int){nullptr};
 
   /// Parallel context, rank and size of communicator
-  int prank, psize;
+  int prank{0}, psize{1};
 
   /// The last argc parsed (those are the modified version after parse)
   int * argc;
 
   /// The last argv parsed (those are the modified version after parse)
   char *** argv;
 };
 }
 
 inline std::ostream & operator<<(std::ostream & stream,
                                  const cppargparse::ArgumentParser & argparse) {
   argparse.printself(stream);
   return stream;
 }
 
 #endif /* __CPPARGPARSE_HH__ */
 
 #include "cppargparse_tmpl.hh"
diff --git a/src/io/parser/cppargparse/cppargparse_tmpl.hh b/src/io/parser/cppargparse/cppargparse_tmpl.hh
index d62452a05..68192782a 100644
--- a/src/io/parser/cppargparse/cppargparse_tmpl.hh
+++ b/src/io/parser/cppargparse/cppargparse_tmpl.hh
@@ -1,245 +1,240 @@
 /**
  * @file   cppargparse_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Apr 03 2014
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Implementation of the templated part of the commandline argument
  * parser
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <stdexcept>
 #include <sstream>
 
 #ifndef __CPPARGPARSE_TMPL_HH__
 #define __CPPARGPARSE_TMPL_HH__
 
 namespace cppargparse {
 /* -------------------------------------------------------------------------- */
 /* Argument                                                                   */
 /* -------------------------------------------------------------------------- */
 
 /// internal description of arguments
 struct ArgumentParser::_Argument : public Argument {
-  _Argument()
-      : Argument(), help(std::string()), nargs(1), type(_string),
-        required(false), parsed(false), has_default(false), has_const(false),
-        is_positional(false) {}
-  ~_Argument() override {}
+  _Argument() : Argument(), help(std::string()) {}
+  ~_Argument() override = default;
 
   void setValues(std::vector<std::string> & values) {
-    for (std::vector<std::string>::iterator it = values.begin();
-         it != values.end(); ++it) {
+    for (auto it = values.begin(); it != values.end(); ++it) {
       this->addValue(*it);
     }
   }
 
   virtual void addValue(std::string & value) = 0;
   virtual void setToDefault() = 0;
   virtual void setToConst() = 0;
 
   std::ostream & printDefault(std::ostream & stream) const {
     stream << std::boolalpha;
     if (has_default) {
       stream << " (default: ";
       this->_printDefault(stream);
       stream << ")";
     }
     if (has_const) {
       stream << " (const: ";
       this->_printConst(stream);
       stream << ")";
     }
     return stream;
   }
 
   virtual std::ostream & _printDefault(std::ostream & stream) const = 0;
   virtual std::ostream & _printConst(std::ostream & stream) const = 0;
 
   std::string help;
-  int nargs;
-  ArgumentType type;
-  bool required;
-  bool parsed;
-  bool has_default;
-  bool has_const;
+  int nargs{1};
+  ArgumentType type{_string};
+  bool required{false};
+  bool parsed{false};
+  bool has_default{false};
+  bool has_const{false};
   std::vector<std::string> keys;
-  bool is_positional;
+  bool is_positional{false};
 };
 
 /* -------------------------------------------------------------------------- */
 /// typed storage of the arguments
 template <class T>
 class ArgumentParser::ArgumentStorage : public ArgumentParser::_Argument {
 public:
   ArgumentStorage() : _default(T()), _const(T()), values(std::vector<T>()) {}
 
   void addValue(std::string & value) override {
     std::stringstream sstr(value);
     T t;
     sstr >> t;
     values.push_back(t);
   }
 
   void setToDefault() override {
     values.clear();
     values.push_back(_default);
   }
 
   void setToConst() override {
     values.clear();
     values.push_back(_const);
   }
 
   void printself(std::ostream & stream) const override {
     stream << this->name << " =";
     stream << std::boolalpha; // for boolean
-    for (typename std::vector<T>::const_iterator vit = this->values.begin();
-         vit != this->values.end(); ++vit) {
+    for (auto vit = this->values.begin(); vit != this->values.end(); ++vit) {
       stream << " " << *vit;
     }
   }
 
   std::ostream & _printDefault(std::ostream & stream) const override {
     stream << _default;
     return stream;
   }
 
   std::ostream & _printConst(std::ostream & stream) const override {
     stream << _const;
     return stream;
   }
 
   T _default;
   T _const;
   std::vector<T> values;
 };
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ArgumentParser::ArgumentStorage<std::string>::addValue(std::string & value) {
   values.push_back(value);
 }
 
 template <class T> struct is_vector {
   enum { value = false };
 };
 
 template <class T> struct is_vector<std::vector<T> > {
   enum { value = true };
 };
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_vector = cppargparse::is_vector<T>::value>
 struct cast_helper {
   static T cast(const ArgumentParser::Argument & arg) {
-    const ArgumentParser::ArgumentStorage<T> & _arg =
+    const auto & _arg =
         dynamic_cast<const ArgumentParser::ArgumentStorage<T> &>(arg);
     if (_arg.values.size() == 1) {
       return _arg.values[0];
     } else {
       throw std::length_error("Not enougth or too many argument where passed "
                               "for the command line argument: " +
                               arg.name);
     }
   }
 };
 
 template <class T> struct cast_helper<T, true> {
   static T cast(const ArgumentParser::Argument & arg) {
-    const ArgumentParser::ArgumentStorage<T> & _arg =
+    const auto & _arg =
         dynamic_cast<const ArgumentParser::ArgumentStorage<T> &>(arg);
     return _arg.values;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <class T> ArgumentParser::Argument::operator T() const {
   return cast_helper<T>::cast(*this);
 }
 
 template <> inline ArgumentParser::Argument::operator const char *() const {
   return cast_helper<std::string>::cast(*this).c_str();
 }
 
 template <> inline ArgumentParser::Argument::operator unsigned int() const {
   return cast_helper<int>::cast(*this);
 }
 
 template <class T>
 void ArgumentParser::addArgument(const std::string & name_or_flag,
                                  const std::string & help, int nargs,
                                  ArgumentType type, T def) {
   _Argument & arg = _addArgument(name_or_flag, help, nargs, type);
   dynamic_cast<ArgumentStorage<T> &>(arg)._default = def;
   arg.has_default = true;
 }
 
 template <class T>
 void ArgumentParser::addArgument(const std::string & name_or_flag,
                                  const std::string & help, int nargs,
                                  ArgumentType type, T def, T cons) {
   _Argument & arg = _addArgument(name_or_flag, help, nargs, type);
   dynamic_cast<ArgumentStorage<T> &>(arg)._default = def;
   arg.has_default = true;
   dynamic_cast<ArgumentStorage<T> &>(arg)._const = cons;
   arg.has_const = true;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ArgumentParser::addArgument<const char *>(const std::string & name_or_flag,
                                           const std::string & help, int nargs,
                                           ArgumentType type, const char * def) {
   this->addArgument<std::string>(name_or_flag, help, nargs, type, def);
 }
 
 template <>
 inline void
 ArgumentParser::addArgument<unsigned int>(const std::string & name_or_flag,
                                           const std::string & help, int nargs,
                                           ArgumentType type, unsigned int def) {
   this->addArgument<int>(name_or_flag, help, nargs, type, def);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void ArgumentParser::addArgument<const char *>(
     const std::string & name_or_flag, const std::string & help, int nargs,
     ArgumentType type, const char * def, const char * cons) {
   this->addArgument<std::string>(name_or_flag, help, nargs, type, def, cons);
 }
 
 template <>
 inline void ArgumentParser::addArgument<unsigned int>(
     const std::string & name_or_flag, const std::string & help, int nargs,
     ArgumentType type, unsigned int def, unsigned int cons) {
   this->addArgument<int>(name_or_flag, help, nargs, type, def, cons);
 }
 }
 
 #endif /* __AKANTU_CPPARGPARSE_TMPL_HH__ */
diff --git a/src/io/parser/input_file_parser.hh b/src/io/parser/input_file_parser.hh
index 3494dae39..cf5354c1d 100644
--- a/src/io/parser/input_file_parser.hh
+++ b/src/io/parser/input_file_parser.hh
@@ -1,263 +1,263 @@
 /**
  * @file   input_file_parser.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Tue May 19 2015
  *
  * @brief  Grammar definition for the input files
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 // Boost
 /* -------------------------------------------------------------------------- */
 
 #include <boost/config/warning_disable.hpp>
 #include <boost/spirit/include/qi.hpp>
 #include <boost/spirit/include/phoenix_core.hpp>
 #include <boost/spirit/include/phoenix_fusion.hpp>
 #include <boost/spirit/include/phoenix_operator.hpp>
 #include <boost/spirit/include/phoenix_bind.hpp>
 #include <boost/variant/recursive_variant.hpp>
 
 #ifndef __AKANTU_INPUT_FILE_PARSER_HH__
 #define __AKANTU_INPUT_FILE_PARSER_HH__
 
 namespace spirit = boost::spirit;
 namespace qi = boost::spirit::qi;
 namespace lbs = boost::spirit::qi::labels;
 namespace ascii = boost::spirit::ascii;
 namespace phx = boost::phoenix;
 
 namespace akantu {
 
 namespace parser {
 struct error_handler_ {
   template <typename, typename, typename, typename> struct result {
-    typedef void type;
+    using type = void;
   };
 
   template <typename Iterator>
   void operator()(qi::info const & what, Iterator err_pos,
                   __attribute__((unused)) Iterator first,
                   __attribute__((unused)) Iterator last) const {
     spirit::classic::file_position pos = err_pos.get_position();
 
     AKANTU_EXCEPTION("Parse error [ "
                      << "Expecting " << what << " instead of \"" << *err_pos
                      << "\" ]"
                      << " in file " << pos.file << " line " << pos.line
                      << " column " << pos.column << std::endl
                      << "'" << err_pos.get_currentline() << "'" << std::endl
                      << std::setw(pos.column) << " "
                      << "^- here");
   }
 
 private:
 };
 
 static ParserSection &
 create_subsection(const SectionType & type, const std::string & name,
                   const boost::optional<std::string> & option,
                   ParserSection & sect) {
   std::string opt = "";
   if (option)
     opt = *option;
 
   ParserSection sect_tmp(name, type, opt, sect);
   return sect.addSubSection(sect_tmp);
 }
 
 template <typename Iter>
 static bool create_parameter(boost::iterator_range<Iter> & rng,
                              std::string & value, ParserSection & sect) {
   try {
     std::string name(rng.begin(), rng.end());
     name = trim(name);
     spirit::classic::file_position pos = rng.begin().get_position();
 
     ParserParameter param_tmp(name, value, sect);
     param_tmp.setDebugInfo(pos.file, pos.line, pos.column);
     sect.addParameter(param_tmp);
   } catch (debug::Exception & e) {
     return false;
   }
   return true;
 }
 
 static std::string concatenate(const std::string & t1, const std::string & t2) {
   return (t1 + t2);
 }
 
 /* ---------------------------------------------------------------------- */
 /* Grammars definitions                                                   */
 /* ---------------------------------------------------------------------- */
 template <class Iterator>
 struct InputFileGrammar
   : qi::grammar<Iterator, void(), typename Skipper<Iterator>::type> {
   InputFileGrammar(ParserSection * sect)
       : InputFileGrammar::base_type(start, "input_file_grammar"),
         parent_section(sect) {
 
     /* clang-format off */
     start
       =   mini_section(parent_section)
       ;
 
     mini_section
       =   *(
                entry  (lbs::_r1)
            |   section(lbs::_r1)
            )
       ;
 
     entry
       =   (
               qi::raw[key]
           >> '='
           > value
            ) [ lbs::_pass = phx::bind(&create_parameter<Iterator>,
                                       lbs::_1,
                                       lbs::_2,
                                       *lbs::_r1) ]
       ;
 
     section
       =   (
               qi::no_case[section_type]
           > qi::lexeme
                [
                    section_name
                    > -section_option
                ]
            ) [ lbs::_a = &phx::bind(&create_subsection,
                                     lbs::_1,
                                     phx::at_c<0>(lbs::_2),
                                     phx::at_c<1>(lbs::_2),
                                     *lbs::_r1) ]
           > '['
           > mini_section(lbs::_a)
           > ']'
       ;
 
     section_name
       =   qi::char_("a-zA-Z_") >> *qi::char_("a-zA-Z_0-9")
       ;
 
     section_option
       =   (+ascii::space >> section_name) [ lbs::_val = lbs::_2 ]
       ;
 
     key
       =   qi::char_("a-zA-Z_") >> *qi::char_("a-zA-Z_0-9")
       ;
 
     value
       =   (
            mono_line_value          [ lbs::_a = phx::bind(&concatenate, lbs::_a, lbs::_1) ]
         > *(
             '\\' > mono_line_value  [ lbs::_a = phx::bind(&concatenate, lbs::_a, lbs::_1) ]
            )
           ) [ lbs::_val = lbs::_a ]
       ;
 
     mono_line_value
       =   qi::lexeme
              [
            +(qi::char_ - (qi::char_('=') | spirit::eol | '#' | ';' | '\\'))
              ]
       ;
 
     skipper
       =     ascii::space
       |     "#" >> *(qi::char_ - spirit::eol)
       ;
 
 /* clang-format on */
 
 #define AKANTU_SECTION_TYPE_ADD(r, data, elem)                                 \
   (BOOST_PP_STRINGIZE(elem), AKANTU_SECTION_TYPES_PREFIX(elem))
 
     section_type.add BOOST_PP_SEQ_FOR_EACH(AKANTU_SECTION_TYPE_ADD, _,
                                            AKANTU_SECTION_TYPES);
 #undef AKANTU_SECTION_TYPE_ADD
 
 #if !defined(AKANTU_NDEBUG) && defined(AKANTU_CORE_CXX_11)
     phx::function<error_handler_> const error_handler = error_handler_();
     qi::on_error<qi::fail>(start,
                            error_handler(lbs::_4, lbs::_3, lbs::_1, lbs::_2));
 #endif
 
     section.name("section");
     section_name.name("section-name");
     section_option.name("section-option");
     mini_section.name("section-content");
     entry.name("parameter");
     key.name("parameter-name");
     value.name("parameter-value");
     section_type.name("section-types-list");
     mono_line_value.name("mono-line-value");
 
 #if !defined AKANTU_NDEBUG
     if (AKANTU_DEBUG_TEST(dblDebug)) {
       //        qi::debug(section);
       qi::debug(section_name);
       qi::debug(section_option);
       //        qi::debug(mini_section);
       //	qi::debug(entry);
       qi::debug(key);
       qi::debug(value);
       qi::debug(mono_line_value);
     }
 #endif
   }
 
   const std::string & getErrorMessage() const { return error_message; };
 
-  typedef typename Skipper<Iterator>::type skipper_type;
+  using skipper_type = typename Skipper<Iterator>::type;
   skipper_type skipper;
 
 private:
   std::string error_message;
 
   qi::rule<Iterator, void(ParserSection *), skipper_type> mini_section;
   qi::rule<Iterator, void(ParserSection *), qi::locals<ParserSection *>,
            skipper_type> section;
   qi::rule<Iterator, void(), skipper_type> start;
   qi::rule<Iterator, std::string()> section_name;
   qi::rule<Iterator, std::string()> section_option;
   qi::rule<Iterator, void(ParserSection *), skipper_type> entry;
   qi::rule<Iterator, std::string(), skipper_type> key;
   qi::rule<Iterator, std::string(), qi::locals<std::string>, skipper_type>
       value;
   qi::rule<Iterator, std::string(), skipper_type> mono_line_value;
 
   qi::symbols<char, SectionType> section_type;
 
   ParserSection * parent_section;
 };
 }
 
 } // akantu
 
 #endif /* __AKANTU_INPUT_FILE_PARSER_HH__ */
diff --git a/src/io/parser/parameter_registry.cc b/src/io/parser/parameter_registry.cc
index ead59bdca..3b94b2628 100644
--- a/src/io/parser/parameter_registry.cc
+++ b/src/io/parser/parameter_registry.cc
@@ -1,152 +1,153 @@
 /**
  * @file   parameter_registry.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Thu Nov 19 2015
  *
  * @brief  Parameter Registry and derived classes implementation
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
+#include <utility>
+
 #include "parameter_registry.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
-Parameter::Parameter() : name(""), description(""), param_type(_pat_internal) {}
+Parameter::Parameter() : name(""), description("") {}
 
 /* -------------------------------------------------------------------------- */
 Parameter::Parameter(std::string name, std::string description,
                      ParameterAccessType param_type)
-    : name(name), description(description), param_type(param_type) {}
+    : name(std::move(name)), description(std::move(description)),
+      param_type(param_type) {}
 
 /* -------------------------------------------------------------------------- */
 bool Parameter::isWritable() const { return param_type & _pat_writable; }
 
 /* -------------------------------------------------------------------------- */
 bool Parameter::isReadable() const { return param_type & _pat_readable; }
 
 /* -------------------------------------------------------------------------- */
 bool Parameter::isInternal() const { return param_type & _pat_internal; }
 
 /* -------------------------------------------------------------------------- */
 bool Parameter::isParsable() const { return param_type & _pat_parsable; }
 
 /* -------------------------------------------------------------------------- */
 void Parameter::setAccessType(ParameterAccessType ptype) {
   this->param_type = ptype;
 }
 
 /* -------------------------------------------------------------------------- */
 void Parameter::printself(std::ostream & stream) const {
   stream << " ";
   if (isInternal())
     stream << "iii";
   else {
     if (isReadable())
       stream << "r";
     else
       stream << "-";
 
     if (isWritable())
       stream << "w";
     else
       stream << "-";
 
     if (isParsable())
       stream << "p";
     else
       stream << "-";
   }
   stream << " ";
 
   std::stringstream sstr;
   sstr << name;
   UInt width = std::max(int(10 - sstr.str().length()), 0);
   sstr.width(width);
 
   if (description != "") {
     sstr << " [" << description << "]";
   }
 
   stream << sstr.str();
   width = std::max(int(50 - sstr.str().length()), 0);
   stream.width(width);
 
   stream << " : ";
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
-ParameterRegistry::ParameterRegistry() : consisder_sub(true) {
-
-}
+ParameterRegistry::ParameterRegistry() {}
 
 /* -------------------------------------------------------------------------- */
 ParameterRegistry::~ParameterRegistry() {
   std::map<std::string, Parameter *>::iterator it, end;
   for (it = params.begin(); it != params.end(); ++it) {
     delete it->second;
     it->second = NULL;
   }
   this->params.clear();
 }
 
 /* -------------------------------------------------------------------------- */
 void ParameterRegistry::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   Parameters::const_iterator it;
   for (it = params.begin(); it != params.end(); ++it) {
     stream << space;
     it->second->printself(stream);
   }
 
   SubRegisteries::const_iterator sub_it;
   for (sub_it = sub_registries.begin(); sub_it != sub_registries.end(); ++sub_it) {
     stream << space << "Registry [" << std::endl;
     sub_it->second->printself(stream, indent + 1);
     stream << space << "]";
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void ParameterRegistry::registerSubRegistry(const ID & id,
                                             ParameterRegistry & registry) {
   sub_registries[id] = &registry;
 }
 
 /* -------------------------------------------------------------------------- */
 void ParameterRegistry::setParameterAccessType(const std::string & name,
                                                ParameterAccessType ptype) {
-  Parameters::iterator it = params.find(name);
+  auto it = params.find(name);
   if (it == params.end())
     AKANTU_CUSTOM_EXCEPTION(debug::ParameterUnexistingException(name, *this));
   Parameter & param = *(it->second);
   param.setAccessType(ptype);
 }
 
 } // akantu
diff --git a/src/io/parser/parameter_registry.hh b/src/io/parser/parameter_registry.hh
index 5db930cb4..61d9312db 100644
--- a/src/io/parser/parameter_registry.hh
+++ b/src/io/parser/parameter_registry.hh
@@ -1,217 +1,217 @@
 /**
  * @file   parameter_registry.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Aug 09 2012
  * @date last modification: Thu Dec 17 2015
  *
  * @brief  Interface of the parameter registry
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "parser.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_PARAMETER_REGISTRY_HH__
 #define __AKANTU_PARAMETER_REGISTRY_HH__
 
 namespace akantu {
 class ParserParameter;
 }
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /// Defines the access modes of parsable parameters
 enum ParameterAccessType {
   _pat_internal = 0x0001,
   _pat_writable = 0x0010,
   _pat_readable = 0x0100,
   _pat_modifiable = 0x0110, //<_pat_readable | _pat_writable,
   _pat_parsable = 0x1000,
   _pat_parsmod = 0x1110 //< _pat_parsable | _pat_modifiable
 };
 
 /// Bit-wise operator between access modes
 inline ParameterAccessType operator|(const ParameterAccessType & a,
                                      const ParameterAccessType & b) {
-  ParameterAccessType tmp = ParameterAccessType(UInt(a) | UInt(b));
+  auto tmp = ParameterAccessType(UInt(a) | UInt(b));
   return tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> class ParameterTyped;
 
 /**
  * Interface for the Parameter
  */
 class Parameter {
 public:
   Parameter();
   Parameter(std::string name, std::string description,
             ParameterAccessType param_type);
 
   virtual ~Parameter() = default;
   /* ------------------------------------------------------------------------ */
   bool isInternal() const;
   bool isWritable() const;
   bool isReadable() const;
   bool isParsable() const;
 
   void setAccessType(ParameterAccessType ptype);
 
   /* ------------------------------------------------------------------------ */
   template <typename T, typename V> void set(const V & value);
   virtual void setAuto(const ParserParameter & param);
   template <typename T> T & get();
   template <typename T> const T & get() const;
 
   virtual inline operator Real() const { throw std::bad_cast(); };
   template <typename T> inline operator T() const;
   /* ------------------------------------------------------------------------ */
   virtual void printself(std::ostream & stream) const;
 
   virtual const std::type_info& type() const = 0;
 protected:
   /// Returns const instance of templated sub-class ParameterTyped
   template <typename T> const ParameterTyped<T> & getParameterTyped() const;
 
   /// Returns instance of templated sub-class ParameterTyped
   template <typename T> ParameterTyped<T> & getParameterTyped();
 
 protected:
   /// Name of parameter
   std::string name;
 private:
   /// Description of parameter
   std::string description;
   /// Type of access
-  ParameterAccessType param_type;
+  ParameterAccessType param_type{_pat_internal};
 };
 
 /* -------------------------------------------------------------------------- */
 /* Typed Parameter                                                            */
 /* -------------------------------------------------------------------------- */
 /**
  * Type parameter transfering a ParserParameter (string: string) to a typed
  * parameter in the memory of the p
  */
 template <typename T> class ParameterTyped : public Parameter {
 public:
   ParameterTyped(std::string name, std::string description,
                  ParameterAccessType param_type, T & param);
 
   /* ------------------------------------------------------------------------ */
   template <typename V> void setTyped(const V & value);
   void setAuto(const ParserParameter & param) override;
   T & getTyped();
   const T & getTyped() const;
 
   void printself(std::ostream & stream) const override;
 
   inline operator Real() const override;
 
   inline const std::type_info& type() const override { return typeid(T); }
 private:
   /// Value of parameter
   T & param;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Parsable Interface                                                         */
 /* -------------------------------------------------------------------------- */
 /// Defines interface for classes to manipulate parsable parameters
 class ParameterRegistry {
 public:
   ParameterRegistry();
   virtual ~ParameterRegistry();
 
   /* ------------------------------------------------------------------------ */
   /// Add parameter to the params map
   template <typename T>
   void registerParam(std::string name, T & variable, ParameterAccessType type,
                      const std::string & description = "");
 
   /// Add parameter to the params map (with default value)
   template <typename T>
   void registerParam(std::string name, T & variable, const T & default_value,
                      ParameterAccessType type,
                      const std::string & description = "");
 
   /*------------------------------------------------------------------------- */
 protected:
   void registerSubRegistry(const ID & id, ParameterRegistry & registry);
 
   /* ------------------------------------------------------------------------ */
 public:
   /// Set value to a parameter (with possible different type)
   template <typename T, typename V>
   void setMixed(const std::string & name, const V & value);
 
   /// Set value to a parameter
   template <typename T> void set(const std::string & name, const T & value);
 
   /// Get value of a parameter
   inline const Parameter & get(const std::string & name) const;
 
   std::vector<ID> listParameters() const {
     std::vector<ID> params;
     for(auto & pair : this->params) params.push_back(pair.first);
     return params;
   }
 
   std::vector<ID> listSubRegisteries() const {
     std::vector<ID> subs;
     for(auto & pair : this->sub_registries) subs.push_back(pair.first);
     return subs;
   }
 
 protected:
   template <typename T> T & get(const std::string & name);
 
 protected:
   void setParameterAccessType(const std::string & name,
                               ParameterAccessType ptype);
   /* ------------------------------------------------------------------------ */
   virtual void printself(std::ostream & stream, int indent) const;
 
 protected:
   /// Parameters map
   typedef std::map<std::string, Parameter *> Parameters;
   Parameters params;
 
   /// list of sub-registries
   typedef std::map<std::string, ParameterRegistry *> SubRegisteries;
   SubRegisteries sub_registries;
 
   /// should accessor check in sub registries
-  bool consisder_sub;
+  bool consisder_sub{true};
 };
 
 } // akantu
 
 #include "parameter_registry_tmpl.hh"
 
 #endif /* __AKANTU_PARAMETER_REGISTRY_HH__ */
diff --git a/src/io/parser/parameter_registry_tmpl.hh b/src/io/parser/parameter_registry_tmpl.hh
index 2beda2f33..1a32b3958 100644
--- a/src/io/parser/parameter_registry_tmpl.hh
+++ b/src/io/parser/parameter_registry_tmpl.hh
@@ -1,346 +1,341 @@
 /**
  * @file   parameter_registry_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Aug 09 2012
  * @date last modification: Fri Mar 27 2015
  *
  * @brief implementation of the templated part of ParameterRegistry class and
  * the derivated ones
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_error.hh"
 #include "parameter_registry.hh"
 #include "parser.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <string>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_PARAMETER_REGISTRY_TMPL_HH__
 #define __AKANTU_PARAMETER_REGISTRY_TMPL_HH__
 
 namespace akantu {
 
 namespace debug {
   class ParameterException : public Exception {
   public:
     ParameterException(const std::string & name, const std::string & message)
         : Exception(message), name(name) {}
     const std::string & name;
   };
 
   class ParameterUnexistingException : public ParameterException {
   public:
     ParameterUnexistingException(const std::string & name,
                                  const ParameterRegistry & registery)
         : ParameterException(name, "Parameter " + name +
                                        " does not exists in this scope") {
       auto && params = registery.listParameters();
       this->_info =
           std::accumulate(params.begin(), params.end(),
                           this->_info + "\n Possible parameters are: ",
                           [](auto && str, auto && param) {
                             static auto first = true;
                             auto && ret = str + (first ? " " : ", ") + param;
                             first = false;
                             return ret;
                           });
     }
   };
 
   class ParameterAccessRightException : public ParameterException {
   public:
     ParameterAccessRightException(const std::string & name,
                                   const std::string & perm)
         : ParameterException(name, "Parameter " + name + " is not " + perm) {}
   };
 
   class ParameterWrongTypeException : public ParameterException {
   public:
-    ParameterWrongTypeException(const std::string name,
+    ParameterWrongTypeException(const std::string & name,
                                 const std::type_info & wrong_type,
                                 const std::type_info & type)
         : ParameterException(name, "Parameter " + name +
                                        " type error, cannot convert " +
                                        debug::demangle(type.name()) + " to " +
                                        debug::demangle(wrong_type.name())) {}
   };
 } // namespace debug
 /* -------------------------------------------------------------------------- */
 template <typename T>
 const ParameterTyped<T> & Parameter::getParameterTyped() const {
   try {
-    const ParameterTyped<T> & tmp =
-        dynamic_cast<const ParameterTyped<T> &>(*this);
+    const auto & tmp = dynamic_cast<const ParameterTyped<T> &>(*this);
     return tmp;
   } catch (std::bad_cast &) {
     AKANTU_CUSTOM_EXCEPTION(
         debug::ParameterWrongTypeException(name, typeid(T), this->type()));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> ParameterTyped<T> & Parameter::getParameterTyped() {
   try {
-    ParameterTyped<T> & tmp = dynamic_cast<ParameterTyped<T> &>(*this);
+    auto & tmp = dynamic_cast<ParameterTyped<T> &>(*this);
     return tmp;
   } catch (std::bad_cast &) {
     AKANTU_CUSTOM_EXCEPTION(
         debug::ParameterWrongTypeException(name, typeid(T), this->type()));
   }
 }
 
 /* ------------------------------------------------------------------------ */
 template <typename T, typename V> void Parameter::set(const V & value) {
   if (!(isWritable()))
     AKANTU_CUSTOM_EXCEPTION(
         debug::ParameterAccessRightException(name, "writable"));
   ParameterTyped<T> & typed_param = getParameterTyped<T>();
   typed_param.setTyped(value);
 }
 
 /* ------------------------------------------------------------------------ */
 inline void Parameter::setAuto(__attribute__((unused))
                                const ParserParameter & value) {
   if (!(isParsable()))
     AKANTU_CUSTOM_EXCEPTION(
         debug::ParameterAccessRightException(name, "parsable"));
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> const T & Parameter::get() const {
   if (!(isReadable()))
     AKANTU_CUSTOM_EXCEPTION(
         debug::ParameterAccessRightException(name, "readable"));
   const ParameterTyped<T> & typed_param = getParameterTyped<T>();
   return typed_param.getTyped();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> T & Parameter::get() {
   ParameterTyped<T> & typed_param = getParameterTyped<T>();
   if (!(isReadable()) || !(this->isWritable()))
     AKANTU_CUSTOM_EXCEPTION(
         debug::ParameterAccessRightException(name, "accessible"));
   return typed_param.getTyped();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> inline Parameter::operator T() const {
   return this->get<T>();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 ParameterTyped<T>::ParameterTyped(std::string name, std::string description,
                                   ParameterAccessType param_type, T & param)
     : Parameter(name, description, param_type), param(param) {}
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 template <typename V>
 void ParameterTyped<T>::setTyped(const V & value) {
   param = value;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void ParameterTyped<T>::setAuto(const ParserParameter & value) {
   Parameter::setAuto(value);
   param = static_cast<T>(value);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ParameterTyped<std::string>::setAuto(const ParserParameter & value) {
   Parameter::setAuto(value);
   param = value.getValue();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ParameterTyped<Vector<Real>>::setAuto(const ParserParameter & in_param) {
   Parameter::setAuto(in_param);
   Vector<Real> tmp = in_param;
   for (UInt i = 0; i < param.size(); ++i) {
     param(i) = tmp(i);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ParameterTyped<Matrix<Real>>::setAuto(const ParserParameter & in_param) {
   Parameter::setAuto(in_param);
   Matrix<Real> tmp = in_param;
   for (UInt i = 0; i < param.rows(); ++i) {
     for (UInt j = 0; j < param.cols(); ++j) {
       param(i, j) = tmp(i, j);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> const T & ParameterTyped<T>::getTyped() const {
   return param;
 }
 /* -------------------------------------------------------------------------- */
 template <typename T> T & ParameterTyped<T>::getTyped() { return param; }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void ParameterTyped<T>::printself(std::ostream & stream) const {
   Parameter::printself(stream);
   stream << param << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void ParameterTyped<bool>::printself(std::ostream & stream) const {
   Parameter::printself(stream);
   stream << std::boolalpha << param << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void ParameterRegistry::registerParam(std::string name, T & variable,
                                       ParameterAccessType type,
                                       const std::string & description) {
-  std::map<std::string, Parameter *>::iterator it = params.find(name);
+  auto it = params.find(name);
   if (it != params.end())
     AKANTU_CUSTOM_EXCEPTION(debug::ParameterException(
         name, "Parameter named " + name + " already registered."));
-  ParameterTyped<T> * param =
-      new ParameterTyped<T>(name, description, type, variable);
+  auto * param = new ParameterTyped<T>(name, description, type, variable);
   params[name] = param;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void ParameterRegistry::registerParam(std::string name, T & variable,
                                       const T & default_value,
                                       ParameterAccessType type,
                                       const std::string & description) {
   variable = default_value;
   registerParam(name, variable, type, description);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename V>
 void ParameterRegistry::setMixed(const std::string & name, const V & value) {
-  std::map<std::string, Parameter *>::iterator it = params.find(name);
+  auto it = params.find(name);
   if (it == params.end()) {
     if (consisder_sub) {
-      for (SubRegisteries::iterator it = sub_registries.begin();
-           it != sub_registries.end(); ++it) {
+      for (auto it = sub_registries.begin(); it != sub_registries.end(); ++it) {
         it->second->setMixed<T>(name, value);
       }
     } else {
       AKANTU_CUSTOM_EXCEPTION(debug::ParameterUnexistingException(name, *this));
     }
   } else {
     Parameter & param = *(it->second);
     param.set<T>(value);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void ParameterRegistry::set(const std::string & name, const T & value) {
   this->template setMixed<T>(name, value);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> T & ParameterRegistry::get(const std::string & name) {
-  Parameters::iterator it = params.find(name);
+  auto it = params.find(name);
   if (it == params.end()) {
     if (consisder_sub) {
-      for (SubRegisteries::iterator it = sub_registries.begin();
-           it != sub_registries.end(); ++it) {
+      for (auto it = sub_registries.begin(); it != sub_registries.end(); ++it) {
         try {
           return it->second->get<T>(name);
         } catch (...) {
         }
       }
     }
 
     // nothing was found not even in sub registries
     AKANTU_CUSTOM_EXCEPTION(debug::ParameterUnexistingException(name, *this));
   }
 
   Parameter & param = *(it->second);
   return param.get<T>();
 }
 
 /* -------------------------------------------------------------------------- */
 const Parameter & ParameterRegistry::get(const std::string & name) const {
-  Parameters::const_iterator it = params.find(name);
+  auto it = params.find(name);
   if (it == params.end()) {
     if (consisder_sub) {
-      for (SubRegisteries::const_iterator it = sub_registries.begin();
-           it != sub_registries.end(); ++it) {
+      for (auto it = sub_registries.begin(); it != sub_registries.end(); ++it) {
         try {
           return it->second->get(name);
         } catch (...) {
         }
       }
     }
 
     // nothing was found not even in sub registries
     AKANTU_CUSTOM_EXCEPTION(debug::ParameterUnexistingException(name, *this));
   }
 
   Parameter & param = *(it->second);
   return param;
 }
 
 /* -------------------------------------------------------------------------- */
 namespace {
   namespace details {
     template <class T, class R, class Enable = void> struct CastHelper {
       static R convert(const T &) { throw std::bad_cast(); }
     };
 
     template <class T, class R>
     struct CastHelper<T, R,
                       std::enable_if_t<std::is_convertible<T, R>::value>> {
       static R convert(const T & val) { return val; }
     };
   } // namespace details
 } // namespace
 
 template <typename T> inline ParameterTyped<T>::operator Real() const {
   if (not isReadable())
     AKANTU_CUSTOM_EXCEPTION(
         debug::ParameterAccessRightException(name, "accessible"));
   return details::CastHelper<T, Real>::convert(param);
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_PARAMETER_REGISTRY_TMPL_HH__ */
diff --git a/src/io/parser/parsable.cc b/src/io/parser/parsable.cc
index 12021b1d6..52c178240 100644
--- a/src/io/parser/parsable.cc
+++ b/src/io/parser/parsable.cc
@@ -1,111 +1,110 @@
 /**
  * @file   parsable.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Thu Nov 19 2015
  *
  * @brief  Parsable implementation
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "parsable.hh"
 #include "aka_random_generator.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Parsable::Parsable(const SectionType & section_type, const ID & id)
     : section_type(section_type), pid(id) {
   this->consisder_sub = false;
 }
 
 /* -------------------------------------------------------------------------- */
-Parsable::~Parsable() {}
+Parsable::~Parsable() = default;
 
 /* -------------------------------------------------------------------------- */
 void Parsable::registerSubSection(const SectionType & type,
                                   const std::string & name,
                                   Parsable & sub_section) {
   SubSectionKey key(type, name);
   sub_sections[key] = &sub_section;
 
   this->registerSubRegistry(name, sub_section);
 }
 
 /* -------------------------------------------------------------------------- */
 void Parsable::parseParam(const ParserParameter & in_param) {
-  std::map<std::string, Parameter *>::iterator it =
-      params.find(in_param.getName());
+  auto it = params.find(in_param.getName());
   if (it == params.end()) {
     if (Parser::isPermissive()) {
       AKANTU_DEBUG_WARNING("No parameter named " << in_param.getName()
                                                  << " registered in " << pid
                                                  << ".");
       return;
     } else
       AKANTU_EXCEPTION("No parameter named " << in_param.getName()
                                              << " registered in " << pid
                                              << ".");
   }
   Parameter & param = *(it->second);
   param.setAuto(in_param);
 }
 
 /* -------------------------------------------------------------------------- */
 void Parsable::parseSection(const ParserSection & section) {
   if (section_type != section.getType())
     AKANTU_EXCEPTION("The object "
                      << pid << " is meant to parse section of type "
                      << section_type << ", so it cannot parse section of type "
                      << section.getType());
 
   std::pair<Parser::const_parameter_iterator, Parser::const_parameter_iterator>
       params = section.getParameters();
   Parser::const_parameter_iterator it = params.first;
   for (; it != params.second; ++it) {
     parseParam(*it);
   }
 
   Parser::const_section_iterator sit = section.getSubSections().first;
   for (; sit != section.getSubSections().second; ++sit) {
     parseSubSection(*sit);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Parsable::parseSubSection(const ParserSection & section) {
   SubSectionKey key(section.getType(), section.getName());
-  SubSections::iterator it = sub_sections.find(key);
+  auto it = sub_sections.find(key);
   if (it != sub_sections.end()) {
     it->second->parseSection(section);
   } else if (!Parser::isPermissive()) {
     AKANTU_EXCEPTION("No parsable defined for sub sections of type <"
                      << key.first << "," << key.second << "> in " << pid);
   } else
     AKANTU_DEBUG_WARNING("No parsable defined for sub sections of type <"
                          << key.first << "," << key.second << "> in " << pid);
 }
 
 } // akantu
diff --git a/src/io/parser/parser.cc b/src/io/parser/parser.cc
index 53c8eba19..58f32b5d1 100644
--- a/src/io/parser/parser.cc
+++ b/src/io/parser/parser.cc
@@ -1,98 +1,98 @@
 /**
  * @file   parser.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Wed Jan 13 2016
  *
  * @brief  implementation of the parser
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 // STL
 #include <fstream>
 #include <iomanip>
 #include <map>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "parser.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 ParserSection::~ParserSection() { this->clean(); }
 
 /* -------------------------------------------------------------------------- */
 ParserParameter & ParserSection::addParameter(const ParserParameter & param) {
   if (parameters.find(param.getName()) != parameters.end())
     AKANTU_EXCEPTION("The parameter \"" + param.getName() +
                      "\" is already defined in this section");
 
   return (parameters.insert(std::pair<std::string, ParserParameter>(
                                 param.getName(), param)).first->second);
 }
 
 /* -------------------------------------------------------------------------- */
 ParserSection & ParserSection::addSubSection(const ParserSection & section) {
   return ((sub_sections_by_type.insert(std::pair<SectionType, ParserSection>(
                section.getType(), section)))->second);
 }
 
 /* -------------------------------------------------------------------------- */
 std::string Parser::getLastParsedFile() const { return last_parsed_file; }
 
 /* -------------------------------------------------------------------------- */
 void ParserSection::printself(std::ostream & stream,
                               unsigned int indent) const {
   std::string space;
   std::string ind = AKANTU_INDENT;
   for (unsigned int i = 0; i < indent; i++, space += ind)
     ;
 
   stream << space << "Section(" << this->type << ") " << this->name
          << (option != "" ? (" " + option) : "") << " [" << std::endl;
   if (!this->parameters.empty()) {
     stream << space << ind << "Parameters [" << std::endl;
-    Parameters::const_iterator pit = this->parameters.begin();
+    auto pit = this->parameters.begin();
     for (; pit != this->parameters.end(); ++pit) {
       stream << space << ind << " + ";
       pit->second.printself(stream);
       stream << std::endl;
     }
     stream << space << ind << "]" << std::endl;
   }
 
   if (!this->sub_sections_by_type.empty()) {
     stream << space << ind << "Subsections [" << std::endl;
-    SubSections::const_iterator sit = this->sub_sections_by_type.begin();
+    auto sit = this->sub_sections_by_type.begin();
     for (; sit != this->sub_sections_by_type.end(); ++sit)
       sit->second.printself(stream, indent + 2);
     stream << std::endl;
     stream << space << ind << "]" << std::endl;
   }
   stream << space << "]" << std::endl;
 }
 
 } // akantu
diff --git a/src/io/parser/parser.hh b/src/io/parser/parser.hh
index ffe397dcc..d8ce259cb 100644
--- a/src/io/parser/parser.hh
+++ b/src/io/parser/parser.hh
@@ -1,515 +1,509 @@
 /**
  * @file   parser.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Wed Jan 13 2016
  *
  * @brief  File parser interface
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_random_generator.hh"
 /* -------------------------------------------------------------------------- */
 #include <map>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_PARSER_HH__
 #define __AKANTU_PARSER_HH__
 
 namespace akantu {
 
 // clang-format off
 #define AKANTU_SECTION_TYPES                                            \
   (global)                                                              \
   (material)                                                            \
   (model)                                                               \
   (mesh)                                                                \
   (heat)                                                                \
   (contact)                                                             \
   (friction)                                                            \
   (embedded_interface)                                                  \
   (rules)                                                               \
   (non_local)                                                           \
   (user)                                                                \
   (solver)                                                              \
   (neighborhoods)                                                       \
   (neighborhood)                                                        \
   (time_step_solver)                                                    \
   (non_linear_solver)                                                   \
   (model_solver)                                                        \
   (integration_scheme)                                                  \
   (weight_function)                                                     \
   (not_defined)
 // clang-format on
 
 #define AKANTU_SECTION_TYPES_PREFIX(elem) BOOST_PP_CAT(_st_, elem)
 
 #define AKANTU_SECT_PREFIX(s, data, elem) AKANTU_SECTION_TYPES_PREFIX(elem)
 /// Defines the possible section types
 enum SectionType {
   BOOST_PP_SEQ_ENUM(
       BOOST_PP_SEQ_TRANSFORM(AKANTU_SECT_PREFIX, _, AKANTU_SECTION_TYPES))
 };
 #undef AKANTU_SECT_PREFIX
 
 #define AKANTU_SECTION_TYPE_PRINT_CASE(r, data, elem)                          \
   case AKANTU_SECTION_TYPES_PREFIX(elem): {                                    \
     stream << BOOST_PP_STRINGIZE(AKANTU_SECTION_TYPES_PREFIX(elem));           \
     break;                                                                     \
   }
 
 inline std::ostream & operator<<(std::ostream & stream, SectionType type) {
   switch (type) {
     BOOST_PP_SEQ_FOR_EACH(AKANTU_SECTION_TYPE_PRINT_CASE, _,
                           AKANTU_SECTION_TYPES)
   default:
     stream << "not a SectionType";
     break;
   }
   return stream;
 }
 
 #undef AKANTU_SECTION_TYPE_PRINT_CASE
 /// Defines the possible search contexts/scopes (for parameter search)
 enum ParserParameterSearchCxt {
   _ppsc_current_scope = 0x1,
   _ppsc_parent_scope = 0x2,
   _ppsc_current_and_parent_scope = 0x3
 };
 
 /* ------------------------------------------------------------------------ */
 /* Parameters Class                                                         */
 /* ------------------------------------------------------------------------ */
 class ParserSection;
 
 /// @brief The ParserParameter objects represent the end of tree branches as
 /// they
 /// are the different informations contained in the input file.
 class ParserParameter {
 public:
   ParserParameter()
-      : parent_section(nullptr), name(std::string()), value(std::string()),
-        dbg_filename(std::string()) {}
+      : name(std::string()), value(std::string()), dbg_filename(std::string()) {
+  }
 
   ParserParameter(const std::string & name, const std::string & value,
                   const ParserSection & parent_section)
       : parent_section(&parent_section), name(name), value(value),
         dbg_filename(std::string()) {}
 
-  ParserParameter(const ParserParameter & param)
-      : parent_section(param.parent_section), name(param.name),
-        value(param.value), dbg_filename(param.dbg_filename),
-        dbg_line(param.dbg_line), dbg_column(param.dbg_column) {}
+  ParserParameter(const ParserParameter & param) = default;
 
-  virtual ~ParserParameter() {}
+  virtual ~ParserParameter() = default;
 
   /// Get parameter name
   const std::string & getName() const { return name; }
   /// Get parameter value
   const std::string & getValue() const { return value; }
 
   /// Set info for debug output
   void setDebugInfo(const std::string & filename, UInt line, UInt column) {
     dbg_filename = filename;
     dbg_line = line;
     dbg_column = column;
   }
 
   template <typename T> inline operator T() const;
 
   // template <typename T> inline operator Vector<T>() const;
   // template <typename T> inline operator Matrix<T>() const;
 
   /// Print parameter info in stream
   void printself(std::ostream & stream,
                  __attribute__((unused)) unsigned int indent = 0) const {
     stream << name << ": " << value << " (" << dbg_filename << ":" << dbg_line
            << ":" << dbg_column << ")";
   }
 
 private:
   void setParent(const ParserSection & sect) { parent_section = &sect; }
 
   friend class ParserSection;
 
 private:
   /// Pointer to the parent section
-  const ParserSection * parent_section;
+  const ParserSection * parent_section{nullptr};
   /// Name of the parameter
   std::string name;
   /// Value of the parameter
   std::string value;
   /// File for debug output
   std::string dbg_filename;
   /// Position of parameter in parsed file
   UInt dbg_line, dbg_column;
 };
 
 /* ------------------------------------------------------------------------ */
 /* Sections Class                                                           */
 /* ------------------------------------------------------------------------ */
 /// ParserSection represents a branch of the parsing tree.
 class ParserSection {
 public:
   typedef std::multimap<SectionType, ParserSection> SubSections;
   typedef std::map<std::string, ParserParameter> Parameters;
 
 private:
-  typedef SubSections::const_iterator const_section_iterator_;
+  using const_section_iterator_ = SubSections::const_iterator;
 
 public:
   /* ------------------------------------------------------------------------ */
   /* SubSection iterator                                                      */
   /* ------------------------------------------------------------------------ */
   /// Iterator on sections
   class const_section_iterator {
   public:
-    const_section_iterator() {}
-    const_section_iterator(const const_section_iterator & other)
-        : it(other.it) {}
+    const_section_iterator() = default;
+    const_section_iterator(const const_section_iterator & other) = default;
     const_section_iterator(const const_section_iterator_ & it) : it(it) {}
 
     const_section_iterator & operator=(const const_section_iterator & other) {
       if (this != &other) {
         it = other.it;
       }
       return *this;
     }
     const ParserSection & operator*() const { return it->second; }
     const ParserSection * operator->() const { return &(it->second); }
     bool operator==(const const_section_iterator & other) const {
       return it == other.it;
     }
     bool operator!=(const const_section_iterator & other) const {
       return it != other.it;
     }
 
     const_section_iterator & operator++() {
       ++it;
       return *this;
     }
     const_section_iterator operator++(int) {
       const_section_iterator tmp = *this;
       operator++();
       return tmp;
     }
 
   private:
     const_section_iterator_ it;
   };
 
   /* ------------------------------------------------------------------------ */
   /* Parameters iterator                                                      */
   /* ------------------------------------------------------------------------ */
   /// Iterator on parameters
   class const_parameter_iterator {
   public:
-    const_parameter_iterator(const const_parameter_iterator & other)
-        : it(other.it) {}
+    const_parameter_iterator(const const_parameter_iterator & other) = default;
     const_parameter_iterator(const Parameters::const_iterator & it) : it(it) {}
 
     const_parameter_iterator &
     operator=(const const_parameter_iterator & other) {
       if (this != &other) {
         it = other.it;
       }
       return *this;
     }
     const ParserParameter & operator*() const { return it->second; }
     const ParserParameter * operator->() { return &(it->second); };
     bool operator==(const const_parameter_iterator & other) const {
       return it == other.it;
     }
     bool operator!=(const const_parameter_iterator & other) const {
       return it != other.it;
     }
     const_parameter_iterator & operator++() {
       ++it;
       return *this;
     }
     const_parameter_iterator operator++(int) {
       const_parameter_iterator tmp = *this;
       operator++();
       return tmp;
     }
 
   private:
     Parameters::const_iterator it;
   };
 
   /* ---------------------------------------------------------------------- */
-  ParserSection()
-      : parent_section(nullptr), name(std::string()), type(_st_not_defined) {}
+  ParserSection() : name(std::string()) {}
 
   ParserSection(const std::string & name, SectionType type)
       : parent_section(nullptr), name(name), type(type) {}
 
   ParserSection(const std::string & name, SectionType type,
                 const std::string & option,
                 const ParserSection & parent_section)
       : parent_section(&parent_section), name(name), type(type),
         option(option) {}
 
   ParserSection(const ParserSection & section)
       : parent_section(section.parent_section), name(section.name),
         type(section.type), option(section.option),
         parameters(section.parameters),
         sub_sections_by_type(section.sub_sections_by_type) {
     setChldrenPointers();
   }
 
   ParserSection & operator=(const ParserSection & other) {
     if (&other != this) {
       parent_section = other.parent_section;
       name = other.name;
       type = other.type;
       option = other.option;
       parameters = other.parameters;
       sub_sections_by_type = other.sub_sections_by_type;
       setChldrenPointers();
     }
     return *this;
   }
 
   virtual ~ParserSection();
 
   virtual void printself(std::ostream & stream, unsigned int indent = 0) const;
 
   /* ---------------------------------------------------------------------- */
   /* Creation functions                                                     */
   /* ---------------------------------------------------------------------- */
 public:
   ParserParameter & addParameter(const ParserParameter & param);
   ParserSection & addSubSection(const ParserSection & section);
 
 protected:
   /// Clean ParserSection content
   void clean() {
     parameters.clear();
     sub_sections_by_type.clear();
   }
 
 private:
   void setChldrenPointers() {
-    Parameters::iterator pit = this->parameters.begin();
+    auto pit = this->parameters.begin();
     for (; pit != this->parameters.end(); ++pit)
       pit->second.setParent(*this);
 
-    SubSections::iterator sit = this->sub_sections_by_type.begin();
+    auto sit = this->sub_sections_by_type.begin();
     for (; sit != this->sub_sections_by_type.end(); ++sit)
       sit->second.setParent(*this);
   }
 
   /* ---------------------------------------------------------------------- */
   /* Accessors                                                              */
   /* ---------------------------------------------------------------------- */
 public:
   /// Get begin and end iterators on subsections of certain type
   std::pair<const_section_iterator, const_section_iterator>
   getSubSections(SectionType type = _st_not_defined) const {
     if (type != _st_not_defined) {
       std::pair<const_section_iterator_, const_section_iterator_> range =
           sub_sections_by_type.equal_range(type);
       return std::pair<const_section_iterator, const_section_iterator>(
           range.first, range.second);
     } else {
       return std::pair<const_section_iterator, const_section_iterator>(
           sub_sections_by_type.begin(), sub_sections_by_type.end());
     }
   }
 
   /// Get number of subsections of certain type
   UInt getNbSubSections(SectionType type = _st_not_defined) const {
     if (type != _st_not_defined) {
       return this->sub_sections_by_type.count(type);
     } else {
       return this->sub_sections_by_type.size();
     }
   }
 
   /// Get begin and end iterators on parameters
   std::pair<const_parameter_iterator, const_parameter_iterator>
   getParameters() const {
     return std::pair<const_parameter_iterator, const_parameter_iterator>(
         parameters.begin(), parameters.end());
   }
 
   /* ---------------------------------------------------------------------- */
   /// Get parameter within specified context
   const ParserParameter & getParameter(
       const std::string & name,
       ParserParameterSearchCxt search_ctx = _ppsc_current_scope) const {
     Parameters::const_iterator it;
     if (search_ctx & _ppsc_current_scope)
       it = parameters.find(name);
 
     if (it == parameters.end()) {
       if ((search_ctx & _ppsc_parent_scope) && parent_section)
         return parent_section->getParameter(name, search_ctx);
       else {
         AKANTU_SILENT_EXCEPTION(
             "The parameter " << name
                              << " has not been found in the specified context");
       }
     }
     return it->second;
   }
 
   /* ------------------------------------------------------------------------ */
   /// Get parameter within specified context, with a default value in case the
   /// parameter does not exists
   template <class T>
   const T getParameter(
       const std::string & name, const T & default_value,
       ParserParameterSearchCxt search_ctx = _ppsc_current_scope) const {
     try {
       T tmp = this->getParameter(name, search_ctx);
       return tmp;
     } catch (debug::Exception &) {
       return default_value;
     }
   }
 
   /* ------------------------------------------------------------------------ */
   /// Check if parameter exists within specified context
   bool hasParameter(
       const std::string & name,
       ParserParameterSearchCxt search_ctx = _ppsc_current_scope) const {
 
     Parameters::const_iterator it;
     if (search_ctx & _ppsc_current_scope)
       it = parameters.find(name);
 
     if (it == parameters.end()) {
       if ((search_ctx & _ppsc_parent_scope) && parent_section)
         return parent_section->hasParameter(name, search_ctx);
       else {
         return false;
       }
     }
     return true;
   }
 
   /* --------------------------------------------------------------------------
    */
   /// Get value of given parameter in context
   template <class T>
   T getParameterValue(
       const std::string & name,
       ParserParameterSearchCxt search_ctx = _ppsc_current_scope) const {
     const ParserParameter & tmp_param = getParameter(name, search_ctx);
     T t = tmp_param;
     return t;
   }
 
   /* --------------------------------------------------------------------------
    */
   /// Get section name
   const std::string getName() const { return name; }
   /// Get section type
   SectionType getType() const { return type; }
   /// Get section option
   const std::string getOption(const std::string & def = "") const {
     return option != "" ? option : def;
   }
 
 protected:
   void setParent(const ParserSection & sect) { parent_section = &sect; }
 
   /* ---------------------------------------------------------------------- */
   /* Members                                                                */
   /* ---------------------------------------------------------------------- */
 private:
   /// Pointer to the parent section
-  const ParserSection * parent_section;
+  const ParserSection * parent_section{nullptr};
   /// Name of section
   std::string name;
   /// Type of section, see AKANTU_SECTION_TYPES
-  SectionType type;
+  SectionType type{_st_not_defined};
   /// Section option
   std::string option;
   /// Map of parameters in section
   Parameters parameters;
   /// Multi-map of subsections
   SubSections sub_sections_by_type;
 };
 
 /* ------------------------------------------------------------------------ */
 /* Parser Class                                                             */
 /* ------------------------------------------------------------------------ */
 /// Root of parsing tree, represents the global ParserSection
 class Parser : public ParserSection {
 public:
   Parser() : ParserSection("global", _st_global) {}
 
   void parse(const std::string & filename);
 
   std::string getLastParsedFile() const;
 
   static bool isPermissive() { return permissive_parser; }
 
 public:
   /// Parse real scalar
   static Real parseReal(const std::string & value,
                         const ParserSection & section);
   /// Parse real vector
   static Vector<Real> parseVector(const std::string & value,
                                   const ParserSection & section);
   /// Parse real matrix
   static Matrix<Real> parseMatrix(const std::string & value,
                                   const ParserSection & section);
   /// Parse real random parameter
   static RandomParameter<Real>
   parseRandomParameter(const std::string & value,
                        const ParserSection & section);
 
 protected:
   /// General parse function
   template <class T, class Grammar>
   static T parseType(const std::string & value, Grammar & grammar);
 
 protected:
   //  friend class Parsable;
   static bool permissive_parser;
   std::string last_parsed_file;
 };
 
 inline std::ostream & operator<<(std::ostream & stream,
                                  const ParserParameter & _this) {
   _this.printself(stream);
   return stream;
 }
 
 inline std::ostream & operator<<(std::ostream & stream,
                                  const ParserSection & section) {
   section.printself(stream);
   return stream;
 }
 
 } // akantu
 
 #include "parser_tmpl.hh"
 
 #endif /* __AKANTU_PARSER_HH__ */
diff --git a/src/io/parser/parser_input_files.cc b/src/io/parser/parser_input_files.cc
index c777bef21..77a18ded7 100644
--- a/src/io/parser/parser_input_files.cc
+++ b/src/io/parser/parser_input_files.cc
@@ -1,117 +1,117 @@
 /**
  * @file   parser_input_files.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 11 2015
  * @date last modification: Wed Jan 13 2016
  *
  * @brief  implementation of the parser
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #if defined(__INTEL_COMPILER)
 //#pragma warning ( disable : 383 )
 #elif defined (__clang__) // test clang to be sure that when we test for gnu it is only gnu
 #elif (defined(__GNUC__) || defined(__GNUG__))
 #  define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
 #  if GCC_VERSION > 40600
 #    pragma GCC diagnostic push
 #  endif
 #  pragma GCC diagnostic ignored "-Wunused-local-typedefs"
 #endif
 
 /* -------------------------------------------------------------------------- */
 #include "parser.hh"
 #include "parser_grammar_tmpl.hh"
 /* -------------------------------------------------------------------------- */
 #include "input_file_parser.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 void Parser::parse(const std::string & filename) {
   this->clean();
   std::ifstream input(filename.c_str());
 
   if (!input.good()) {
     AKANTU_EXCEPTION("Could not open file " << filename << "!");
   }
 
   input.unsetf(std::ios::skipws);
 
   // wrap istream into iterator
   spirit::istream_iterator fwd_begin(input);
   spirit::istream_iterator fwd_end;
 
   // wrap forward iterator with position iterator, to record the position
-  typedef spirit::classic::position_iterator2<spirit::istream_iterator>
-      pos_iterator_type;
+  using pos_iterator_type =
+      spirit::classic::position_iterator2<spirit::istream_iterator>;
   pos_iterator_type position_begin(fwd_begin, fwd_end, filename);
   pos_iterator_type position_end;
 
   // parse
   parser::InputFileGrammar<pos_iterator_type> ag(this);
 
   bool result = qi::phrase_parse(position_begin, position_end, ag, ag.skipper);
 
   if (!result || position_begin != position_end) {
     spirit::classic::file_position pos = position_begin.get_position();
 
     AKANTU_EXCEPTION("Parse error [ "
                      << ag.getErrorMessage() << " ]"
                      << " in file " << filename << " line " << pos.line
                      << " column " << pos.column << std::endl
                      << "'" << position_begin.get_currentline() << "'"
                      << std::endl
                      << std::setw(pos.column) << " "
                      << "^- here");
   }
 
   try {
     bool permissive = getParameter("permissive_parser", _ppsc_current_scope);
 
     permissive_parser = permissive;
     AKANTU_DEBUG_INFO("Parser switched permissive mode to "
                       << std::boolalpha << permissive_parser);
   } catch (debug::Exception & e) {
   }
 
   last_parsed_file = filename;
   input.close();
 }
 
 } // akantu
 
 #if defined(__INTEL_COMPILER)
 //#pragma warning ( disable : 383 )
 #elif defined (__clang__) // test clang to be sure that when we test for gnu it is only gnu
 #elif defined(__GNUG__)
 #  if GCC_VERSION > 40600
 #    pragma GCC diagnostic pop
 #  else
 #    pragma GCC diagnostic warning "-Wunused-local-typedefs"
 #  endif
 #endif
 
diff --git a/src/mesh/element_group.hh b/src/mesh/element_group.hh
index 4c905dec4..fe47dc7d2 100644
--- a/src/mesh/element_group.hh
+++ b/src/mesh/element_group.hh
@@ -1,188 +1,190 @@
 /**
  * @file   element_group.hh
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri May 03 2013
  * @date last modification: Tue Aug 18 2015
  *
  * @brief  Stores information relevent to the notion of domain boundary and
  * surfaces.
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_memory.hh"
 #include "dumpable.hh"
 #include "element_type_map.hh"
 #include "node_group.hh"
 /* -------------------------------------------------------------------------- */
 #include <set>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_ELEMENT_GROUP_HH__
 #define __AKANTU_ELEMENT_GROUP_HH__
 
 namespace akantu {
 class Mesh;
 class Element;
 } // namespace akantu
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 class ElementGroup : private Memory, public Dumpable {
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   ElementGroup(const std::string & name, const Mesh & mesh,
                NodeGroup & node_group, UInt dimension = _all_dimensions,
                const std::string & id = "element_group",
                const MemoryID & memory_id = 0);
 
   /* ------------------------------------------------------------------------ */
   /* Type definitions                                                         */
   /* ------------------------------------------------------------------------ */
 public:
   using ElementList = ElementTypeMapArray<UInt>;
   using NodeList = Array<UInt>;
 
   /* ------------------------------------------------------------------------ */
   /* Element iterator                                                         */
   /* ------------------------------------------------------------------------ */
   using type_iterator = ElementList::type_iterator;
   inline type_iterator firstType(UInt dim = _all_dimensions,
                                  const GhostType & ghost_type = _not_ghost,
                                  const ElementKind & kind = _ek_regular) const;
 
   inline type_iterator lastType(UInt dim = _all_dimensions,
                                 const GhostType & ghost_type = _not_ghost,
                                 const ElementKind & kind = _ek_regular) const;
 
+#ifndef SWIG
   template <typename... pack>
   inline decltype(auto) elementTypes(pack &&... _pack) const {
     return elements.elementTypes(_pack...);
   }
+#endif
 
   using const_element_iterator = Array<UInt>::const_iterator<UInt>;
   inline const_element_iterator
   begin(const ElementType & type,
         const GhostType & ghost_type = _not_ghost) const;
   inline const_element_iterator
   end(const ElementType & type,
       const GhostType & ghost_type = _not_ghost) const;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// empty the element group
   void empty();
 
   /// append another group to this group
   /// BE CAREFUL: it doesn't conserve the element order
   void append(const ElementGroup & other_group);
 
   /// add an element to the group. By default the it does not add the nodes to
   /// the group
   inline void add(const Element & el, bool add_nodes = false,
                   bool check_for_duplicate = true);
 
   /// \todo fix the default for add_nodes : make it coherent with the other
   /// method
   inline void add(const ElementType & type, UInt element,
                   const GhostType & ghost_type = _not_ghost,
                   bool add_nodes = true, bool check_for_duplicate = true);
 
   inline void addNode(UInt node_id, bool check_for_duplicate = true);
 
   inline void removeNode(UInt node_id);
 
   /// function to print the contain of the class
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
   /// fill the elements based on the underlying node group.
   virtual void fillFromNodeGroup();
 
   // sort and remove duplicated values
   void optimize();
 
 private:
   inline void addElement(const ElementType & elem_type, UInt elem_id,
                          const GhostType & ghost_type);
 
   friend class GroupManager;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   const Array<UInt> &
   getElements(const ElementType & type,
               const GhostType & ghost_type = _not_ghost) const;
   AKANTU_GET_MACRO(Elements, elements, const ElementTypeMapArray<UInt> &);
   AKANTU_GET_MACRO(Nodes, node_group.getNodes(), const Array<UInt> &);
   AKANTU_GET_MACRO(NodeGroup, node_group, const NodeGroup &);
   AKANTU_GET_MACRO_NOT_CONST(NodeGroup, node_group, NodeGroup &);
   AKANTU_GET_MACRO(Dimension, dimension, UInt);
   AKANTU_GET_MACRO(Name, name, std::string);
   inline UInt getNbNodes() const;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// Mesh to which this group belongs
   const Mesh & mesh;
 
   /// name of the group
   std::string name;
 
   /// list of elements composing the group
   ElementList elements;
 
   /// sub list of nodes which are composing the elements
   NodeGroup & node_group;
 
   /// group dimension
   UInt dimension;
 
   /// empty arry for the iterator to work when an element type not present
   Array<UInt> empty_elements;
 };
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream,
                                  const ElementGroup & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #include "element.hh"
 #include "element_group_inline_impl.cc"
 
 #endif /* __AKANTU_ELEMENT_GROUP_HH__ */
diff --git a/src/mesh/element_type_map.hh b/src/mesh/element_type_map.hh
index 3a93260ad..653fc6281 100644
--- a/src/mesh/element_type_map.hh
+++ b/src/mesh/element_type_map.hh
@@ -1,437 +1,437 @@
 /**
  * @file   element_type_map.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Aug 31 2011
  * @date last modification: Fri Oct 02 2015
  *
  * @brief  storage class by element type
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "aka_memory.hh"
 #include "aka_named_argument.hh"
 #include "element.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_ELEMENT_TYPE_MAP_HH__
 #define __AKANTU_ELEMENT_TYPE_MAP_HH__
 
 namespace akantu {
 class FEEngine;
 } // namespace akantu
 
 namespace akantu {
 
 namespace {
   DECLARE_NAMED_ARGUMENT(all_ghost_types);
   DECLARE_NAMED_ARGUMENT(default_value);
   DECLARE_NAMED_ARGUMENT(element_kind);
   DECLARE_NAMED_ARGUMENT(ghost_type);
   DECLARE_NAMED_ARGUMENT(nb_component);
   DECLARE_NAMED_ARGUMENT(with_nb_element);
   DECLARE_NAMED_ARGUMENT(with_nb_nodes_per_element);
   DECLARE_NAMED_ARGUMENT(spatial_dimension);
   DECLARE_NAMED_ARGUMENT(_do_not_default);
 } // namespace
 
 template <class Stored, typename SupportType = ElementType>
 class ElementTypeMap;
 
 /* -------------------------------------------------------------------------- */
 /* ElementTypeMapBase */
 /* -------------------------------------------------------------------------- */
 /// Common non templated base class for the ElementTypeMap class
 class ElementTypeMapBase {
 public:
   virtual ~ElementTypeMapBase() = default;
 };
 
 /* -------------------------------------------------------------------------- */
 /* ElementTypeMap */
 /* -------------------------------------------------------------------------- */
 
 template <class Stored, typename SupportType>
 class ElementTypeMap : public ElementTypeMapBase {
 
 public:
   ElementTypeMap();
   ~ElementTypeMap() override;
 
   inline static std::string printType(const SupportType & type,
                                       const GhostType & ghost_type);
 
   /*! Tests whether a type is present in the object
    *  @param type the type to check for
    *  @param ghost_type optional: by default, the data map for non-ghost
    *         elements is searched
    *  @return true if the type is present. */
   inline bool exists(const SupportType & type,
                      const GhostType & ghost_type = _not_ghost) const;
 
   /*! get the stored data corresponding to a type
    *  @param type the type to check for
    *  @param ghost_type optional: by default, the data map for non-ghost
    *         elements is searched
    *  @return stored data corresponding to type. */
   inline const Stored &
   operator()(const SupportType & type,
              const GhostType & ghost_type = _not_ghost) const;
 
   /*! get the stored data corresponding to a type
    *  @param type the type to check for
    *  @param ghost_type optional: by default, the data map for non-ghost
    *         elements is searched
    *  @return stored data corresponding to type. */
   inline Stored & operator()(const SupportType & type,
                              const GhostType & ghost_type = _not_ghost);
 
   /*! insert data of a new type (not yet present) into the map. THIS METHOD IS
    *  NOT ARRAY SAFE, when using ElementTypeMapArray, use setArray instead
    *  @param data to insert
    *  @param type type of data (if this type is already present in the map,
    *         an exception is thrown).
    *  @param ghost_type optional: by default, the data map for non-ghost
    *         elements is searched
    *  @return stored data corresponding to type. */
   inline Stored & operator()(const Stored & insert, const SupportType & type,
                              const GhostType & ghost_type = _not_ghost);
 
   /// print helper
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
   /* ------------------------------------------------------------------------ */
   /* Element type Iterator                                                    */
   /* ------------------------------------------------------------------------ */
   /*! iterator allows to iterate over type-data pairs of the map. The interface
    *  expects the SupportType to be ElementType. */
   typedef std::map<SupportType, Stored> DataMap;
   class type_iterator
       : private std::iterator<std::forward_iterator_tag, const SupportType> {
   public:
     using value_type = const SupportType;
     using pointer = const SupportType *;
     using reference = const SupportType &;
 
   protected:
     using DataMapIterator =
         typename ElementTypeMap<Stored>::DataMap::const_iterator;
 
   public:
     type_iterator(DataMapIterator & list_begin, DataMapIterator & list_end,
                   UInt dim, ElementKind ek);
 
     type_iterator(const type_iterator & it);
-    type_iterator() {}
+    type_iterator() = default;
 
     inline reference operator*();
     inline reference operator*() const;
     inline type_iterator & operator++();
     type_iterator operator++(int);
     inline bool operator==(const type_iterator & other) const;
     inline bool operator!=(const type_iterator & other) const;
     type_iterator & operator=(const type_iterator & other);
 
   private:
     DataMapIterator list_begin;
     DataMapIterator list_end;
     UInt dim;
     ElementKind kind;
   };
 
   /// helper class to use in range for constructions
   class ElementTypesIteratorHelper {
   public:
     using Container = ElementTypeMap<Stored, SupportType>;
     using iterator = typename Container::type_iterator;
 
     ElementTypesIteratorHelper(const Container & container, UInt dim,
                                GhostType ghost_type, ElementKind kind)
         : container(std::cref(container)), dim(dim), ghost_type(ghost_type),
           kind(kind) {}
 
     template <typename... pack>
     ElementTypesIteratorHelper(const Container & container, use_named_args_t,
                                pack &&... _pack)
         : ElementTypesIteratorHelper(
               container, OPTIONAL_NAMED_ARG(spatial_dimension, _all_dimensions),
               OPTIONAL_NAMED_ARG(ghost_type, _not_ghost),
               OPTIONAL_NAMED_ARG(element_kind, _ek_regular)) {}
 
     ElementTypesIteratorHelper(const ElementTypesIteratorHelper &) = default;
     ElementTypesIteratorHelper &
     operator=(const ElementTypesIteratorHelper &) = default;
     ElementTypesIteratorHelper &
     operator=(ElementTypesIteratorHelper &&) = default;
 
     iterator begin() {
       return container.get().firstType(dim, ghost_type, kind);
     }
     iterator end() { return container.get().lastType(dim, ghost_type, kind); }
 
   private:
     std::reference_wrapper<const Container> container;
     UInt dim;
     GhostType ghost_type;
     ElementKind kind;
   };
 
 private:
   ElementTypesIteratorHelper
   elementTypesImpl(UInt dim = _all_dimensions,
                    GhostType ghost_type = _not_ghost,
                    ElementKind kind = _ek_regular) const;
 
   template <typename... pack>
   ElementTypesIteratorHelper
   elementTypesImpl(const use_named_args_t & /*unused*/, pack &&... _pack) const;
 
   template <typename... pack>
   using named_argument_test =
       aka::conjunction<aka::bool_constant<(sizeof...(pack) > 0)>,
                        is_named_argument<pack>...>;
 
 public:
   template <typename... pack>
   std::enable_if_t<named_argument_test<pack...>{}, ElementTypesIteratorHelper>
   elementTypes(pack &&... _pack) const {
     return elementTypesImpl(use_named_args,
                             std::forward<decltype(_pack)>(_pack)...);
   }
 
   template <typename... pack>
   std::enable_if_t<not named_argument_test<pack...>{},
                    ElementTypesIteratorHelper>
   elementTypes(pack &&... _pack) const {
     return elementTypesImpl(std::forward<decltype(_pack)>(_pack)...);
   }
 
 public:
   /*! Get an iterator to the beginning of a subset datamap. This method expects
    *  the SupportType to be ElementType.
    *  @param dim optional: iterate over data of dimension dim (e.g. when
    *         iterating over (surface) facets of a 3D mesh, dim would be 2).
    *         by default, all dimensions are considered.
    *  @param ghost_type optional: by default, the data map for non-ghost
    *         elements is iterated over.
    *  @param kind optional: the kind of element to search for (see
    *         aka_common.hh), by default all kinds are considered
    *  @return an iterator to the first stored data matching the filters
    *          or an iterator to the end of the map if none match*/
   inline type_iterator firstType(UInt dim = _all_dimensions,
                                  GhostType ghost_type = _not_ghost,
                                  ElementKind kind = _ek_not_defined) const;
   /*! Get an iterator to the end of a subset datamap. This method expects
    *  the SupportType to be ElementType.
    *  @param dim optional: iterate over data of dimension dim (e.g. when
    *         iterating over (surface) facets of a 3D mesh, dim would be 2).
    *         by default, all dimensions are considered.
    *  @param ghost_type optional: by default, the data map for non-ghost
    *         elements is iterated over.
    *  @param kind optional: the kind of element to search for (see
    *         aka_common.hh), by default all kinds are considered
    *  @return an iterator to the last stored data matching the filters
    *          or an iterator to the end of the map if none match */
   inline type_iterator lastType(UInt dim = _all_dimensions,
                                 GhostType ghost_type = _not_ghost,
                                 ElementKind kind = _ek_not_defined) const;
 
 protected:
   /*! Direct access to the underlying data map. for internal use by daughter
    *  classes only
    *  @param ghost_type whether to return the data map or the ghost_data map
    *  @return the raw map */
   inline DataMap & getData(GhostType ghost_type);
   /*! Direct access to the underlying data map. for internal use by daughter
    *  classes only
    *  @param ghost_type whether to return the data map or the ghost_data map
    *  @return the raw map */
   inline const DataMap & getData(GhostType ghost_type) const;
 
   /* ------------------------------------------------------------------------ */
 protected:
   DataMap data;
   DataMap ghost_data;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Some typedefs                                                              */
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 class ElementTypeMapArray : public ElementTypeMap<Array<T> *, SupportType>,
                             public Memory {
 public:
   using type = T;
   using array_type = Array<T>;
 
 protected:
   using parent = ElementTypeMap<Array<T> *, SupportType>;
   using DataMap = typename parent::DataMap;
 
 public:
   using type_iterator = typename parent::type_iterator;
 
   /// standard assigment (copy) operator
   void operator=(const ElementTypeMapArray &) = delete;
   ElementTypeMapArray(const ElementTypeMapArray &) = delete;
 
   /*! Constructor
    *  @param id optional: identifier (string)
    *  @param parent_id optional: parent identifier. for organizational purposes
    *         only
    *  @param memory_id optional: choose a specific memory, defaults to memory 0
    */
   ElementTypeMapArray(const ID & id = "by_element_type_array",
                       const ID & parent_id = "no_parent",
                       const MemoryID & memory_id = 0)
       : parent(), Memory(parent_id + ":" + id, memory_id), name(id){};
 
   /*! allocate memory for a new array
    *  @param size number of tuples of the new array
    *  @param nb_component tuple size
    *  @param type the type under which the array is indexed in the map
    *  @param ghost_type whether to add the field to the data map or the
    *         ghost_data map
    *  @return a reference to the allocated array */
   inline Array<T> & alloc(UInt size, UInt nb_component,
                           const SupportType & type,
                           const GhostType & ghost_type,
                           const T & default_value = T());
 
   /*! allocate memory for a new array in both the data and the ghost_data map
    *  @param size number of tuples of the new array
    *  @param nb_component tuple size
    *  @param type the type under which the array is indexed in the map*/
   inline void alloc(UInt size, UInt nb_component, const SupportType & type,
                     const T & default_value = T());
 
   /* get a reference to the array of certain type
    * @param type data filed under type is returned
    * @param ghost_type optional: by default the non-ghost map is searched
    * @return a reference to the array */
   inline const Array<T> &
   operator()(const SupportType & type,
              const GhostType & ghost_type = _not_ghost) const;
 
   /// access the data of an element, this combine the map and array accessor
   inline const T & operator()(const Element & element) const;
 
   /// access the data of an element, this combine the map and array accessor
   inline T & operator()(const Element & element);
 
   /* get a reference to the array of certain type
    * @param type data filed under type is returned
    * @param ghost_type optional: by default the non-ghost map is searched
    * @return a const reference to the array */
   inline Array<T> & operator()(const SupportType & type,
                                const GhostType & ghost_type = _not_ghost);
 
   /*! insert data of a new type (not yet present) into the map.
    *  @param type type of data (if this type is already present in the map,
    *         an exception is thrown).
    *  @param ghost_type optional: by default, the data map for non-ghost
    *         elements is searched
    *  @param vect the vector to include into the map
    *  @return stored data corresponding to type. */
   inline void setArray(const SupportType & type, const GhostType & ghost_type,
                        const Array<T> & vect);
   /*! frees all memory related to the data*/
   inline void free();
 
   /*! set all values in the ElementTypeMap to zero*/
   inline void clear();
 
   /*! deletes and reorders entries in the stored arrays
    *  @param new_numbering a ElementTypeMapArray of new indices. UInt(-1)
    * indicates
    *         deleted entries. */
   inline void
   onElementsRemoved(const ElementTypeMapArray<UInt> & new_numbering);
 
   /// text output helper
   void printself(std::ostream & stream, int indent = 0) const override;
 
   /*! set the id
    *  @param id the new name
    */
   inline void setID(const ID & id) { this->id = id; }
 
   ElementTypeMap<UInt>
   getNbComponents(UInt dim = _all_dimensions, GhostType ghost_type = _not_ghost,
                   ElementKind kind = _ek_not_defined) const {
 
     ElementTypeMap<UInt> nb_components;
 
     for (auto & type : this->elementTypes(dim, ghost_type, kind)) {
       UInt nb_comp = (*this)(type, ghost_type).getNbComponent();
       nb_components(type, ghost_type) = nb_comp;
     }
 
     return nb_components;
   }
 
   /* ------------------------------------------------------------------------ */
   /* more evolved allocators                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// initialize the arrays in accordance to a functor
   template <class Func>
   void initialize(const Func & f, const T & default_value, bool do_not_default);
 
   /// initialize with sizes and number of components in accordance of a mesh
   /// content
   template <typename... pack>
   void initialize(const Mesh & mesh, pack &&... _pack);
 
   /// initialize with sizes and number of components in accordance of a fe
   /// engine content (aka integration points)
   template <typename... pack>
   void initialize(const FEEngine & fe_engine, pack &&... _pack);
 
   /* ------------------------------------------------------------------------ */
   /* Accesssors                                                               */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the name of the internal field
   AKANTU_GET_MACRO(Name, name, ID);
 
   /// name of the elment type map: e.g. connectivity, grad_u
   ID name;
 };
 
 /// to store data Array<Real> by element type
 using ElementTypeMapReal = ElementTypeMapArray<Real>;
 /// to store data Array<Int> by element type
 using ElementTypeMapInt = ElementTypeMapArray<Int>;
 /// to store data Array<UInt> by element type
 using ElementTypeMapUInt = ElementTypeMapArray<UInt, ElementType>;
 
 /// Map of data of type UInt stored in a mesh
 using UIntDataMap = std::map<std::string, Array<UInt> *>;
 using ElementTypeMapUIntDataMap = ElementTypeMap<UIntDataMap, ElementType>;
 
 } // namespace akantu
 
 #endif /* __AKANTU_ELEMENT_TYPE_MAP_HH__ */
diff --git a/src/mesh/element_type_map_filter.hh b/src/mesh/element_type_map_filter.hh
index 4ec7b72b2..9b383ea09 100644
--- a/src/mesh/element_type_map_filter.hh
+++ b/src/mesh/element_type_map_filter.hh
@@ -1,335 +1,335 @@
 /**
  * @file   element_type_map_filter.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Fri Dec 18 2015
  *
  * @brief  Filtered version based on a an akantu::ElementGroup of a
  * akantu::ElementTypeMap
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_BY_ELEMENT_TYPE_FILTER_HH__
 #define __AKANTU_BY_ELEMENT_TYPE_FILTER_HH__
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* ArrayFilter                                                                */
 /* -------------------------------------------------------------------------- */
 
 template <typename T> class ArrayFilter {
 
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
   /// standard iterator
   template <typename R = T> class iterator {
     inline bool operator!=(__attribute__((unused)) iterator<R> & other) { throw; };
     inline bool operator==(__attribute__((unused)) iterator<R> & other) { throw; };
 
     inline iterator<R> & operator++() { throw; };
     inline T operator*() {
       throw;
       return T();
     };
   };
 
   /// const iterator
   template <template <class S> class original_iterator, typename Shape,
             typename filter_iterator>
   class const_iterator {
 
   public:
     UInt getCurrentIndex() {
       return (*this->filter_it * this->nb_item_per_elem +
               this->sub_element_counter);
     }
 
-    inline const_iterator(){};
+    inline const_iterator() = default;
     inline const_iterator(const original_iterator<Shape> & origin_it,
                           const filter_iterator & filter_it,
                           UInt nb_item_per_elem)
         : origin_it(origin_it), filter_it(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 Shape operator*() {
       return origin_it[nb_item_per_elem * (*filter_it) + sub_element_counter];
     };
 
   private:
     original_iterator<Shape> origin_it;
     filter_iterator filter_it;
 
     /// the number of item per element
     UInt nb_item_per_elem;
     /// counter for every sub element group
     UInt sub_element_counter;
   };
 
-  typedef iterator<Vector<T> > vector_iterator;
+  using vector_iterator = iterator<Vector<T>>;
 
-  typedef Array<T> array_type;
+  using array_type = Array<T>;
 
   typedef const_iterator<array_type::template const_iterator, Vector<T>,
                          Array<UInt>::const_iterator<UInt> >
       const_vector_iterator;
 
-  typedef typename array_type::value_type value_type;
+  using value_type = typename array_type::value_type;
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
   ArrayFilter(const Array<T> & array, const Array<UInt> & filter,
               UInt nb_item_per_elem)
       : array(array), filter(filter), nb_item_per_elem(nb_item_per_elem){};
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
   const_vector_iterator begin_reinterpret(UInt n, UInt new_size) const {
     AKANTU_DEBUG_ASSERT(
         n * new_size == this->getNbComponent() * this->size(),
         "The new values for size ("
             << new_size << ") and nb_component (" << n
             << ") are not compatible with the one of this array("
             << this->size() << "," << this->getNbComponent() << ")");
     UInt new_full_array_size =
         this->array.size() * array.getNbComponent() / n;
     UInt 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(
         this->array.begin_reinterpret(n, new_full_array_size),
         this->filter.begin(), new_nb_item_per_elem);
   };
 
   const_vector_iterator end_reinterpret(UInt n, UInt new_size) const {
     AKANTU_DEBUG_ASSERT(
         n * new_size == this->getNbComponent() * this->size(),
         "The new values for size ("
             << new_size << ") and nb_component (" << n
             << ") are not compatible with the one of this array("
             << this->size() << "," << this->getNbComponent() << ")");
     UInt new_full_array_size =
         this->array.size() * this->array.getNbComponent() / n;
     UInt 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(
         this->array.begin_reinterpret(n, new_full_array_size),
         this->filter.end(), new_nb_item_per_elem);
   };
 
   vector_iterator begin_reinterpret(UInt, UInt) { throw; };
 
   vector_iterator end_reinterpret(UInt, UInt) { throw; };
 
   /// return the size of the filtered array which is the filter size
   UInt size() const {
     return this->filter.size() * this->nb_item_per_elem;
   };
   /// the number of components of the filtered array
   UInt getNbComponent() const { return this->array.getNbComponent(); };
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 
 private:
   /// reference to array of data
   const Array<T> & array;
   /// reference to the filter used to select elements
   const Array<UInt> & filter;
   /// the number of item per element
   UInt nb_item_per_elem;
 };
 
 /* -------------------------------------------------------------------------- */
 /* ElementTypeMapFilter */
 /* -------------------------------------------------------------------------- */
 
 template <class T, typename SupportType = ElementType>
 class ElementTypeMapArrayFilter {
 
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
-  typedef T type;
-  typedef ArrayFilter<T> array_type;
-  typedef typename array_type::value_type value_type;
+  using type = T;
+  using array_type = ArrayFilter<T>;
+  using value_type = typename array_type::value_type;
 
   typedef typename ElementTypeMapArray<UInt, SupportType>::type_iterator
       type_iterator;
 
   // class type_iterator{
 
   // public:
 
   //    typedef typename ElementTypeMapArray<T,SupportType>::type_iterator
   //    type_it;
 
   //  public:
   //   type_iterator(){};
   //   //    type_iterator(const type_iterator & it){original_it =
   //   it.original_it;};
   //   type_iterator(const type_it & it){original_it = it;};
 
   //   inline ElementType & operator*(){throw;};
   //   inline ElementType & operator*() const{throw;};
   //   inline type_iterator & operator++(){throw;return *this;};
   //   type_iterator operator++(int){throw; return *this;};
   //   inline bool operator==(const type_iterator & other) const{throw;return
   //   false;};
   //   inline bool operator!=(const type_iterator & other) const{throw;return
   //   false;};
   //   //    type_iterator & operator=(const type_iterator & other){throw;return
   //   *this;};
 
   //   type_it original_it;
 
   // };
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
   ElementTypeMapArrayFilter(
       const ElementTypeMapArray<T, SupportType> & array,
       const ElementTypeMapArray<UInt, SupportType> & filter,
       const ElementTypeMap<UInt, SupportType> & nb_data_per_elem)
       : array(array), filter(filter), nb_data_per_elem(nb_data_per_elem) {}
 
   ElementTypeMapArrayFilter(
       const ElementTypeMapArray<T, SupportType> & array,
       const ElementTypeMapArray<UInt, SupportType> & filter)
       : array(array), filter(filter) {}
 
-  ~ElementTypeMapArrayFilter() {}
+  ~ElementTypeMapArrayFilter() = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 
   inline const ArrayFilter<T>
   operator()(const SupportType & type,
              const GhostType & ghost_type = _not_ghost) const {
     if (filter.exists(type, ghost_type)) {
       if (nb_data_per_elem.exists(type, ghost_type))
         return ArrayFilter<T>(array(type, ghost_type), filter(type, ghost_type),
                               nb_data_per_elem(type, ghost_type) /
                                   array(type, ghost_type).getNbComponent());
       else
         return ArrayFilter<T>(array(type, ghost_type), filter(type, ghost_type),
                               1);
     } else {
       return ArrayFilter<T>(empty_array, empty_filter, 1);
     }
   };
 
   inline type_iterator firstType(UInt dim = _all_dimensions,
                                  GhostType ghost_type = _not_ghost,
                                  ElementKind kind = _ek_not_defined) const {
     return filter.firstType(dim, ghost_type, kind);
   };
 
   inline type_iterator lastType(UInt dim = _all_dimensions,
                                 GhostType ghost_type = _not_ghost,
                                 ElementKind kind = _ek_not_defined) const {
     return filter.lastType(dim, ghost_type, kind);
   };
 
   ElementTypeMap<UInt>
   getNbComponents(UInt dim = _all_dimensions, GhostType ghost_type = _not_ghost,
                   ElementKind kind = _ek_not_defined) const {
     return this->array.getNbComponents(dim, ghost_type, kind);
   };
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 
   std::string getID() {
     return std::string("filtered:" + this->array().getID());
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 
 protected:
   const ElementTypeMapArray<T, SupportType> & array;
   const ElementTypeMapArray<UInt, SupportType> & filter;
   ElementTypeMap<UInt> nb_data_per_elem;
 
   /// Empty array to be able to return consistent filtered arrays
   Array<T> empty_array;
   Array<UInt> empty_filter;
 };
 
 } // akantu
 
 #endif /* __AKANTU_BY_ELEMENT_TYPE_FILTER_HH__ */
diff --git a/src/mesh/element_type_map_tmpl.hh b/src/mesh/element_type_map_tmpl.hh
index 92b4f3c06..02ba58287 100644
--- a/src/mesh/element_type_map_tmpl.hh
+++ b/src/mesh/element_type_map_tmpl.hh
@@ -1,646 +1,646 @@
 /**
  * @file   element_type_map_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Aug 31 2011
  * @date last modification: Fri Oct 02 2015
  *
  * @brief  implementation of template functions of the ElementTypeMap and
  * ElementTypeMapArray classes
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_static_if.hh"
 #include "element_type_map.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 #include "element_type_conversion.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_ELEMENT_TYPE_MAP_TMPL_HH__
 #define __AKANTU_ELEMENT_TYPE_MAP_TMPL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* ElementTypeMap                                                             */
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline std::string
 ElementTypeMap<Stored, SupportType>::printType(const SupportType & type,
                                                const GhostType & ghost_type) {
   std::stringstream sstr;
   sstr << "(" << ghost_type << ":" << type << ")";
   return sstr.str();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline bool ElementTypeMap<Stored, SupportType>::exists(
     const SupportType & type, const GhostType & ghost_type) const {
   return this->getData(ghost_type).find(type) !=
          this->getData(ghost_type).end();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline const Stored & ElementTypeMap<Stored, SupportType>::
 operator()(const SupportType & type, const GhostType & ghost_type) const {
   auto it = this->getData(ghost_type).find(type);
 
   if (it == this->getData(ghost_type).end())
     AKANTU_SILENT_EXCEPTION("No element of type "
                             << ElementTypeMap::printType(type, ghost_type)
                             << " in this ElementTypeMap<"
                             << debug::demangle(typeid(Stored).name())
                             << "> class");
   return it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline Stored & ElementTypeMap<Stored, SupportType>::
 operator()(const SupportType & type, const GhostType & ghost_type) {
   return this->getData(ghost_type)[type];
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline Stored & ElementTypeMap<Stored, SupportType>::
 operator()(const Stored & insert, const SupportType & type,
            const GhostType & ghost_type) {
   auto it = this->getData(ghost_type).find(type);
 
   if (it != this->getData(ghost_type).end()) {
     AKANTU_SILENT_EXCEPTION("Element of type "
                             << ElementTypeMap::printType(type, ghost_type)
                             << " already in this ElementTypeMap<"
                             << debug::demangle(typeid(Stored).name())
                             << "> class");
   } else {
     auto & data = this->getData(ghost_type);
     const auto & res =
         data.insert(std::pair<ElementType, Stored>(type, insert));
     it = res.first;
   }
 
   return it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline typename ElementTypeMap<Stored, SupportType>::DataMap &
 ElementTypeMap<Stored, SupportType>::getData(GhostType ghost_type) {
   if (ghost_type == _not_ghost)
     return data;
 
   return ghost_data;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline const typename ElementTypeMap<Stored, SupportType>::DataMap &
 ElementTypeMap<Stored, SupportType>::getData(GhostType ghost_type) const {
   if (ghost_type == _not_ghost)
     return data;
 
   return ghost_data;
 }
 
 /* -------------------------------------------------------------------------- */
 /// Works only if stored is a pointer to a class with a printself method
 template <class Stored, typename SupportType>
 void ElementTypeMap<Stored, SupportType>::printself(std::ostream & stream,
                                                     int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "ElementTypeMap<" << debug::demangle(typeid(Stored).name())
          << "> [" << std::endl;
   for (auto gt : ghost_types) {
     const DataMap & data = getData(gt);
     for (auto & pair : data) {
       stream << space << space << ElementTypeMap::printType(pair.first, gt)
              << std::endl;
     }
   }
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 ElementTypeMap<Stored, SupportType>::ElementTypeMap() = default;
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 ElementTypeMap<Stored, SupportType>::~ElementTypeMap() = default;
 
 /* -------------------------------------------------------------------------- */
 /* ElementTypeMapArray                                                        */
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline Array<T> & ElementTypeMapArray<T, SupportType>::alloc(
     UInt size, UInt nb_component, const SupportType & type,
     const GhostType & ghost_type, const T & default_value) {
   std::string ghost_id = "";
   if (ghost_type == _ghost)
     ghost_id = ":ghost";
 
   Array<T> * tmp;
 
   auto it = this->getData(ghost_type).find(type);
 
   if (it == this->getData(ghost_type).end()) {
     std::stringstream sstr;
     sstr << this->id << ":" << type << ghost_id;
     tmp = &(Memory::alloc<T>(sstr.str(), size, nb_component, default_value));
     std::stringstream sstrg;
     sstrg << ghost_type;
     // tmp->setTag(sstrg.str());
     this->getData(ghost_type)[type] = tmp;
   } else {
     AKANTU_DEBUG_INFO(
         "The vector "
         << this->id << this->printType(type, ghost_type)
         << " already exists, it is resized instead of allocated.");
     tmp = it->second;
     it->second->resize(size);
   }
 
   return *tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline void
 ElementTypeMapArray<T, SupportType>::alloc(UInt size, UInt nb_component,
                                            const SupportType & type,
                                            const T & default_value) {
   this->alloc(size, nb_component, type, _not_ghost, default_value);
   this->alloc(size, nb_component, type, _ghost, default_value);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline void ElementTypeMapArray<T, SupportType>::free() {
   AKANTU_DEBUG_IN();
 
   for (auto gt : ghost_types) {
     auto & data = this->getData(gt);
     for (auto & pair : data) {
       dealloc(pair.second->getID());
     }
     data.clear();
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline void ElementTypeMapArray<T, SupportType>::clear() {
   for (auto gt : ghost_types) {
     auto & data = this->getData(gt);
     for (auto & vect : data) {
       vect.second->clear();
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline const Array<T> & ElementTypeMapArray<T, SupportType>::
 operator()(const SupportType & type, const GhostType & ghost_type) const {
   auto it = this->getData(ghost_type).find(type);
 
   if (it == this->getData(ghost_type).end())
     AKANTU_SILENT_EXCEPTION("No element of type "
                             << ElementTypeMapArray::printType(type, ghost_type)
                             << " in this const ElementTypeMapArray<"
                             << debug::demangle(typeid(T).name()) << "> class(\""
                             << this->id << "\")");
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline Array<T> & ElementTypeMapArray<T, SupportType>::
 operator()(const SupportType & type, const GhostType & ghost_type) {
   auto it = this->getData(ghost_type).find(type);
 
   if (it == this->getData(ghost_type).end())
     AKANTU_SILENT_EXCEPTION("No element of type "
                             << ElementTypeMapArray::printType(type, ghost_type)
                             << " in this ElementTypeMapArray<"
                             << debug::demangle(typeid(T).name())
                             << "> class (\"" << this->id << "\")");
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline void
 ElementTypeMapArray<T, SupportType>::setArray(const SupportType & type,
                                               const GhostType & ghost_type,
                                               const Array<T> & vect) {
   auto it = this->getData(ghost_type).find(type);
 
   if (AKANTU_DEBUG_TEST(dblWarning) && it != this->getData(ghost_type).end() &&
       it->second != &vect) {
     AKANTU_DEBUG_WARNING(
         "The Array "
         << this->printType(type, ghost_type)
         << " is already registred, this call can lead to a memory leak.");
   }
 
   this->getData(ghost_type)[type] = &(const_cast<Array<T> &>(vect));
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline void ElementTypeMapArray<T, SupportType>::onElementsRemoved(
     const ElementTypeMapArray<UInt> & new_numbering) {
   for (auto gt : ghost_types) {
     for (auto & type :
          new_numbering.elementTypes(_all_dimensions, gt, _ek_not_defined)) {
-      SupportType support_type = convertType<ElementType, SupportType>(type);
+      auto support_type = convertType<ElementType, SupportType>(type);
       if (this->exists(support_type, gt)) {
         const auto & renumbering = new_numbering(type, gt);
         if (renumbering.size() == 0)
           continue;
 
         auto & vect = this->operator()(support_type, gt);
         auto nb_component = vect.getNbComponent();
         Array<T> tmp(renumbering.size(), nb_component);
         UInt new_size = 0;
 
         for (UInt i = 0; i < vect.size(); ++i) {
           UInt new_i = renumbering(i);
           if (new_i != UInt(-1)) {
             memcpy(tmp.storage() + new_i * nb_component,
                    vect.storage() + i * nb_component, nb_component * sizeof(T));
             ++new_size;
           }
         }
         tmp.resize(new_size);
         vect.copy(tmp);
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 void ElementTypeMapArray<T, SupportType>::printself(std::ostream & stream,
                                                     int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "ElementTypeMapArray<" << debug::demangle(typeid(T).name())
          << "> [" << std::endl;
   for (UInt g = _not_ghost; g <= _ghost; ++g) {
-    GhostType gt = (GhostType)g;
+    auto gt = (GhostType)g;
 
     const DataMap & data = this->getData(gt);
     typename DataMap::const_iterator it;
     for (it = data.begin(); it != data.end(); ++it) {
       stream << space << space << ElementTypeMapArray::printType(it->first, gt)
              << " [" << std::endl;
       it->second->printself(stream, indent + 3);
       stream << space << space << " ]" << std::endl;
     }
   }
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 /* SupportType Iterator                                                       */
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 ElementTypeMap<Stored, SupportType>::type_iterator::type_iterator(
     DataMapIterator & list_begin, DataMapIterator & list_end, UInt dim,
     ElementKind ek)
     : list_begin(list_begin), list_end(list_end), dim(dim), kind(ek) {}
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 ElementTypeMap<Stored, SupportType>::type_iterator::type_iterator(
     const type_iterator & it)
     : list_begin(it.list_begin), list_end(it.list_end), dim(it.dim),
       kind(it.kind) {}
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 typename ElementTypeMap<Stored, SupportType>::type_iterator &
 ElementTypeMap<Stored, SupportType>::type_iterator::
 operator=(const type_iterator & it) {
   if (this != &it) {
     list_begin = it.list_begin;
     list_end = it.list_end;
     dim = it.dim;
     kind = it.kind;
   }
   return *this;
 }
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline typename ElementTypeMap<Stored, SupportType>::type_iterator::reference
     ElementTypeMap<Stored, SupportType>::type_iterator::operator*() {
   return list_begin->first;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline typename ElementTypeMap<Stored, SupportType>::type_iterator::reference
     ElementTypeMap<Stored, SupportType>::type_iterator::operator*() const {
   return list_begin->first;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline typename ElementTypeMap<Stored, SupportType>::type_iterator &
     ElementTypeMap<Stored, SupportType>::type_iterator::operator++() {
   ++list_begin;
   while ((list_begin != list_end) &&
          (((dim != _all_dimensions) &&
            (dim != Mesh::getSpatialDimension(list_begin->first))) ||
           ((kind != _ek_not_defined) &&
            (kind != Mesh::getKind(list_begin->first)))))
     ++list_begin;
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 typename ElementTypeMap<Stored, SupportType>::type_iterator
     ElementTypeMap<Stored, SupportType>::type_iterator::operator++(int) {
   type_iterator tmp(*this);
   operator++();
   return tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline bool ElementTypeMap<Stored, SupportType>::type_iterator::
 operator==(const type_iterator & other) const {
   return this->list_begin == other.list_begin;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline bool ElementTypeMap<Stored, SupportType>::type_iterator::
 operator!=(const type_iterator & other) const {
   return this->list_begin != other.list_begin;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 typename ElementTypeMap<Stored, SupportType>::ElementTypesIteratorHelper
 ElementTypeMap<Stored, SupportType>::elementTypesImpl(UInt dim,
                                                       GhostType ghost_type,
                                                       ElementKind kind) const {
   return ElementTypesIteratorHelper(*this, dim, ghost_type, kind);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 template <typename... pack>
 typename ElementTypeMap<Stored, SupportType>::ElementTypesIteratorHelper
 ElementTypeMap<Stored, SupportType>::elementTypesImpl(
     const use_named_args_t & /*unused*/, pack &&... _pack) const {
   return ElementTypesIteratorHelper(*this, use_named_args, _pack...);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline typename ElementTypeMap<Stored, SupportType>::type_iterator
 ElementTypeMap<Stored, SupportType>::firstType(UInt dim, GhostType ghost_type,
                                                ElementKind kind) const {
   typename DataMap::const_iterator b, e;
   b = getData(ghost_type).begin();
   e = getData(ghost_type).end();
 
   // loop until the first valid type
   while ((b != e) &&
          (((dim != _all_dimensions) &&
            (dim != Mesh::getSpatialDimension(b->first))) ||
           ((kind != _ek_not_defined) && (kind != Mesh::getKind(b->first)))))
     ++b;
 
   return typename ElementTypeMap<Stored, SupportType>::type_iterator(b, e, dim,
                                                                      kind);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline typename ElementTypeMap<Stored, SupportType>::type_iterator
 ElementTypeMap<Stored, SupportType>::lastType(UInt dim, GhostType ghost_type,
                                               ElementKind kind) const {
   typename DataMap::const_iterator e;
   e = getData(ghost_type).end();
   return typename ElementTypeMap<Stored, SupportType>::type_iterator(e, e, dim,
                                                                      kind);
 }
 
 /* -------------------------------------------------------------------------- */
 
 /// standard output stream operator
 template <class Stored, typename SupportType>
 inline std::ostream &
 operator<<(std::ostream & stream,
            const ElementTypeMap<Stored, SupportType> & _this) {
   _this.printself(stream);
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 class ElementTypeMapArrayInializer {
 public:
   ElementTypeMapArrayInializer(UInt spatial_dimension = _all_dimensions,
                                UInt nb_component = 1,
                                const GhostType & ghost_type = _not_ghost,
                                const ElementKind & element_kind = _ek_regular)
       : spatial_dimension(spatial_dimension), nb_component(nb_component),
         ghost_type(ghost_type), element_kind(element_kind) {}
 
   const GhostType & ghostType() const { return ghost_type; }
 
 protected:
   UInt spatial_dimension;
   UInt nb_component;
   GhostType ghost_type;
   ElementKind element_kind;
 };
 
 /* -------------------------------------------------------------------------- */
 class MeshElementTypeMapArrayInializer : public ElementTypeMapArrayInializer {
 public:
   MeshElementTypeMapArrayInializer(
       const Mesh & mesh, UInt nb_component = 1,
       UInt spatial_dimension = _all_dimensions,
       const GhostType & ghost_type = _not_ghost,
       const ElementKind & element_kind = _ek_regular,
       bool with_nb_element = false, bool with_nb_nodes_per_element = false)
       : ElementTypeMapArrayInializer(spatial_dimension, nb_component,
                                      ghost_type, element_kind),
         mesh(mesh), with_nb_element(with_nb_element),
         with_nb_nodes_per_element(with_nb_nodes_per_element) {}
 
   decltype(auto) elementTypes() const {
     return mesh.elementTypes(this->spatial_dimension, this->ghost_type,
                              this->element_kind);
   }
 
   virtual UInt size(const ElementType & type) const {
     if (with_nb_element)
       return mesh.getNbElement(type, this->ghost_type);
 
     return 0;
   }
 
   UInt nbComponent(const ElementType & type) const {
     if (with_nb_nodes_per_element)
       return (this->nb_component * mesh.getNbNodesPerElement(type));
 
     return this->nb_component;
   }
 
 protected:
   const Mesh & mesh;
   bool with_nb_element;
   bool with_nb_nodes_per_element;
 };
 
 /* -------------------------------------------------------------------------- */
 class FEEngineElementTypeMapArrayInializer
     : public MeshElementTypeMapArrayInializer {
 public:
   FEEngineElementTypeMapArrayInializer(
       const FEEngine & fe_engine, UInt nb_component = 1,
       UInt spatial_dimension = _all_dimensions,
       const GhostType & ghost_type = _not_ghost,
       const ElementKind & element_kind = _ek_regular);
 
   UInt size(const ElementType & type) const override;
 
   using ElementTypesIteratorHelper =
       ElementTypeMapArray<Real, ElementType>::ElementTypesIteratorHelper;
 
   ElementTypesIteratorHelper elementTypes() const;
 
 protected:
   const FEEngine & fe_engine;
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 template <class Func>
 void ElementTypeMapArray<T, SupportType>::initialize(const Func & f,
                                                      const T & default_value,
                                                      bool do_not_default) {
   for (auto & type : f.elementTypes()) {
     if (not this->exists(type, f.ghostType()))
       if (do_not_default) {
         auto & array = this->alloc(0, f.nbComponent(type), type, f.ghostType());
         array.resize(f.size(type));
       } else {
         this->alloc(f.size(type), f.nbComponent(type), type, f.ghostType(),
                     default_value);
       }
     else {
       auto & array = this->operator()(type, f.ghostType());
       array.resize(f.size(type));
       if (not do_not_default)
         array.set(default_value);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 template <typename... pack>
 void ElementTypeMapArray<T, SupportType>::initialize(const Mesh & mesh,
                                                      pack &&... _pack) {
   GhostType requested_ghost_type = OPTIONAL_NAMED_ARG(ghost_type, _casper);
   bool all_ghost_types = requested_ghost_type == _casper;
 
   for (auto ghost_type : ghost_types) {
     if ((not(ghost_type == requested_ghost_type)) and (not all_ghost_types))
       continue;
 
     this->initialize(
         MeshElementTypeMapArrayInializer(
             mesh, OPTIONAL_NAMED_ARG(nb_component, 1),
             OPTIONAL_NAMED_ARG(spatial_dimension, mesh.getSpatialDimension()),
             ghost_type, OPTIONAL_NAMED_ARG(element_kind, _ek_regular),
             OPTIONAL_NAMED_ARG(with_nb_element, false),
             OPTIONAL_NAMED_ARG(with_nb_nodes_per_element, false)),
         OPTIONAL_NAMED_ARG(default_value, T()),
         OPTIONAL_NAMED_ARG(_do_not_default, false));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 template <typename... pack>
 void ElementTypeMapArray<T, SupportType>::initialize(const FEEngine & fe_engine,
                                                      pack &&... _pack) {
   bool all_ghost_types = OPTIONAL_NAMED_ARG(all_ghost_types, true);
   GhostType requested_ghost_type = OPTIONAL_NAMED_ARG(ghost_type, _not_ghost);
 
   for (auto ghost_type : ghost_types) {
     if ((not(ghost_type == requested_ghost_type)) and (not all_ghost_types))
       continue;
 
     this->initialize(FEEngineElementTypeMapArrayInializer(
                          fe_engine, OPTIONAL_NAMED_ARG(nb_component, 1),
                          OPTIONAL_NAMED_ARG(spatial_dimension, UInt(-2)),
                          ghost_type,
                          OPTIONAL_NAMED_ARG(element_kind, _ek_regular)),
                      OPTIONAL_NAMED_ARG(default_value, T()),
                      OPTIONAL_NAMED_ARG(_do_not_default, false));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, typename SupportType>
 inline T & ElementTypeMapArray<T, SupportType>::
 operator()(const Element & element) {
   return this->operator()(element.type, element.ghost_type)(element.element);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, typename SupportType>
 inline const T & ElementTypeMapArray<T, SupportType>::
 operator()(const Element & element) const {
   return this->operator()(element.type, element.ghost_type)(element.element);
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_ELEMENT_TYPE_MAP_TMPL_HH__ */
diff --git a/src/mesh/group_manager.cc b/src/mesh/group_manager.cc
index 9899e747d..80c078599 100644
--- a/src/mesh/group_manager.cc
+++ b/src/mesh/group_manager.cc
@@ -1,1040 +1,1042 @@
 /**
  * @file   group_manager.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@gmail.com>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Mon Aug 17 2015
  *
  * @brief  Stores information about ElementGroup and NodeGroup
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "group_manager.hh"
 #include "aka_csr.hh"
 #include "data_accessor.hh"
 #include "element_group.hh"
 #include "element_synchronizer.hh"
 #include "mesh.hh"
 #include "mesh_accessor.hh"
 #include "mesh_utils.hh"
 #include "node_group.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <iterator>
 #include <list>
 #include <numeric>
 #include <queue>
 #include <sstream>
+#include <utility>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 GroupManager::GroupManager(const Mesh & mesh, const ID & id,
                            const MemoryID & mem_id)
     : id(id), memory_id(mem_id), mesh(mesh) {
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 GroupManager::~GroupManager() {
   auto eit = element_groups.begin();
   auto eend = element_groups.end();
   for (; eit != eend; ++eit)
     delete (eit->second);
 
   auto nit = node_groups.begin();
   auto nend = node_groups.end();
   for (; nit != nend; ++nit)
     delete (nit->second);
 }
 
 /* -------------------------------------------------------------------------- */
 NodeGroup & GroupManager::createNodeGroup(const std::string & group_name,
                                           bool replace_group) {
   AKANTU_DEBUG_IN();
 
   auto it = node_groups.find(group_name);
 
   if (it != node_groups.end()) {
     if (replace_group) {
       it->second->empty();
       AKANTU_DEBUG_OUT();
       return *(it->second);
     } else
       AKANTU_EXCEPTION(
           "Trying to create a node group that already exists:" << group_name);
   }
 
   std::stringstream sstr;
   sstr << this->id << ":" << group_name << "_node_group";
 
   NodeGroup * node_group =
       new NodeGroup(group_name, mesh, sstr.str(), memory_id);
 
   node_groups[group_name] = node_group;
 
   AKANTU_DEBUG_OUT();
 
   return *node_group;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 NodeGroup &
 GroupManager::createFilteredNodeGroup(const std::string & group_name,
                                       const NodeGroup & source_node_group,
                                       T & filter) {
   AKANTU_DEBUG_IN();
 
   NodeGroup & node_group = this->createNodeGroup(group_name);
   node_group.append(source_node_group);
   if (T::type == FilterFunctor::_node_filter_functor) {
     node_group.applyNodeFilter(filter);
   } else {
     AKANTU_DEBUG_ERROR("ElementFilter cannot be applied to NodeGroup yet."
                        << " Needs to be implemented.");
   }
 
   AKANTU_DEBUG_OUT();
   return node_group;
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::destroyNodeGroup(const std::string & group_name) {
   AKANTU_DEBUG_IN();
 
-  NodeGroups::iterator nit = node_groups.find(group_name);
-  NodeGroups::iterator nend = node_groups.end();
+  auto nit = node_groups.find(group_name);
+  auto nend = node_groups.end();
   if (nit != nend) {
     delete (nit->second);
     node_groups.erase(nit);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 ElementGroup & GroupManager::createElementGroup(const std::string & group_name,
                                                 UInt dimension,
                                                 bool replace_group) {
   AKANTU_DEBUG_IN();
 
   NodeGroup & new_node_group =
       createNodeGroup(group_name + "_nodes", replace_group);
 
   auto it = element_groups.find(group_name);
 
   if (it != element_groups.end()) {
     if (replace_group) {
       it->second->empty();
       AKANTU_DEBUG_OUT();
       return *(it->second);
     } else
       AKANTU_EXCEPTION("Trying to create a element group that already exists:"
                        << group_name);
   }
 
   std::stringstream sstr;
   sstr << this->id << ":" << group_name << "_element_group";
 
   ElementGroup * element_group = new ElementGroup(
       group_name, mesh, new_node_group, dimension, sstr.str(), memory_id);
 
   std::stringstream sstr_nodes;
   sstr_nodes << group_name << "_nodes";
 
   node_groups[sstr_nodes.str()] = &new_node_group;
   element_groups[group_name] = element_group;
 
   AKANTU_DEBUG_OUT();
 
   return *element_group;
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::destroyElementGroup(const std::string & group_name,
                                        bool destroy_node_group) {
   AKANTU_DEBUG_IN();
 
   auto eit = element_groups.find(group_name);
   auto eend = element_groups.end();
   if (eit != eend) {
     if (destroy_node_group)
       destroyNodeGroup(eit->second->getNodeGroup().getName());
     delete (eit->second);
     element_groups.erase(eit);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::destroyAllElementGroups(bool destroy_node_groups) {
   AKANTU_DEBUG_IN();
 
   auto eit = element_groups.begin();
   auto eend = element_groups.end();
   for (; eit != eend; ++eit) {
     if (destroy_node_groups)
       destroyNodeGroup(eit->second->getNodeGroup().getName());
     delete (eit->second);
   }
   element_groups.clear();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 ElementGroup & GroupManager::createElementGroup(const std::string & group_name,
                                                 UInt dimension,
                                                 NodeGroup & node_group) {
   AKANTU_DEBUG_IN();
 
   if (element_groups.find(group_name) != element_groups.end())
     AKANTU_EXCEPTION(
         "Trying to create a element group that already exists:" << group_name);
 
   ElementGroup * element_group =
       new ElementGroup(group_name, mesh, node_group, dimension,
                        id + ":" + group_name + "_element_group", memory_id);
 
   element_groups[group_name] = element_group;
 
   AKANTU_DEBUG_OUT();
 
   return *element_group;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 ElementGroup & GroupManager::createFilteredElementGroup(
     const std::string & group_name, UInt dimension,
     const NodeGroup & node_group, T & filter) {
   AKANTU_DEBUG_IN();
 
   ElementGroup * element_group = nullptr;
 
   if (T::type == FilterFunctor::_node_filter_functor) {
     NodeGroup & filtered_node_group = this->createFilteredNodeGroup(
         group_name + "_nodes", node_group, filter);
     element_group =
         &(this->createElementGroup(group_name, dimension, filtered_node_group));
   } else if (T::type == FilterFunctor::_element_filter_functor) {
     AKANTU_DEBUG_ERROR(
         "Cannot handle an ElementFilter yet. Needs to be implemented.");
   }
 
   AKANTU_DEBUG_OUT();
 
   return *element_group;
 }
 
 /* -------------------------------------------------------------------------- */
 class ClusterSynchronizer : public DataAccessor<Element> {
   using DistantIDs = std::set<std::pair<UInt, UInt>>;
 
 public:
   ClusterSynchronizer(GroupManager & group_manager, UInt element_dimension,
                       std::string cluster_name_prefix,
                       ElementTypeMapArray<UInt> & element_to_fragment,
                       const ElementSynchronizer & element_synchronizer,
                       UInt nb_cluster)
       : group_manager(group_manager), element_dimension(element_dimension),
-        cluster_name_prefix(cluster_name_prefix),
+        cluster_name_prefix(std::move(cluster_name_prefix)),
         element_to_fragment(element_to_fragment),
         element_synchronizer(element_synchronizer), nb_cluster(nb_cluster) {}
 
   UInt synchronize() {
     Communicator & comm = Communicator::getStaticCommunicator();
     UInt rank = comm.whoAmI();
     UInt nb_proc = comm.getNbProc();
 
     /// find starting index to renumber local clusters
     Array<UInt> nb_cluster_per_proc(nb_proc);
     nb_cluster_per_proc(rank) = nb_cluster;
     comm.allGather(nb_cluster_per_proc);
 
     starting_index = std::accumulate(nb_cluster_per_proc.begin(),
                                      nb_cluster_per_proc.begin() + rank, 0);
 
     UInt global_nb_fragment =
         std::accumulate(nb_cluster_per_proc.begin() + rank,
                         nb_cluster_per_proc.end(), starting_index);
 
     /// create the local to distant cluster pairs with neighbors
     element_synchronizer.synchronizeOnce(*this, _gst_gm_clusters);
 
     /// count total number of pairs
     Array<int> nb_pairs(nb_proc); // This is potentially a bug for more than
     // 2**31 pairs, but due to a all gatherv after
     // it must be int to match MPI interfaces
     nb_pairs(rank) = distant_ids.size();
     comm.allGather(nb_pairs);
 
     UInt total_nb_pairs = std::accumulate(nb_pairs.begin(), nb_pairs.end(), 0);
 
     /// generate pairs global array
     UInt local_pair_index =
         std::accumulate(nb_pairs.storage(), nb_pairs.storage() + rank, 0);
 
     Array<UInt> total_pairs(total_nb_pairs, 2);
 
     for (auto & ids : distant_ids) {
       total_pairs(local_pair_index, 0) = ids.first;
       total_pairs(local_pair_index, 1) = ids.second;
       ++local_pair_index;
     }
 
     /// communicate pairs to all processors
     nb_pairs *= 2;
     comm.allGatherV(total_pairs, nb_pairs);
 
     /// renumber clusters
 
     /// generate fragment list
     std::vector<std::set<UInt>> global_clusters;
     UInt total_nb_cluster = 0;
 
     Array<bool> is_fragment_in_cluster(global_nb_fragment, 1, false);
     std::queue<UInt> fragment_check_list;
 
     while (total_pairs.size() != 0) {
       /// create a new cluster
       ++total_nb_cluster;
       global_clusters.resize(total_nb_cluster);
       std::set<UInt> & current_cluster = global_clusters[total_nb_cluster - 1];
 
       UInt first_fragment = total_pairs(0, 0);
       UInt second_fragment = total_pairs(0, 1);
       total_pairs.erase(0);
 
       fragment_check_list.push(first_fragment);
       fragment_check_list.push(second_fragment);
 
       while (!fragment_check_list.empty()) {
         UInt current_fragment = fragment_check_list.front();
 
         UInt * total_pairs_end =
             total_pairs.storage() + total_pairs.size() * 2;
 
         UInt * fragment_found =
             std::find(total_pairs.storage(), total_pairs_end, current_fragment);
 
         if (fragment_found != total_pairs_end) {
           UInt position = fragment_found - total_pairs.storage();
           UInt pair = position / 2;
           UInt other_index = (position + 1) % 2;
           fragment_check_list.push(total_pairs(pair, other_index));
           total_pairs.erase(pair);
         } else {
           fragment_check_list.pop();
           current_cluster.insert(current_fragment);
           is_fragment_in_cluster(current_fragment) = true;
         }
       }
     }
 
     /// add to FragmentToCluster all local fragments
     for (UInt c = 0; c < global_nb_fragment; ++c) {
       if (!is_fragment_in_cluster(c)) {
         ++total_nb_cluster;
         global_clusters.resize(total_nb_cluster);
         std::set<UInt> & current_cluster =
             global_clusters[total_nb_cluster - 1];
 
         current_cluster.insert(c);
       }
     }
 
     /// reorganize element groups to match global clusters
     for (UInt c = 0; c < global_clusters.size(); ++c) {
 
       /// create new element group corresponding to current cluster
       std::stringstream sstr;
       sstr << cluster_name_prefix << "_" << c;
       ElementGroup & cluster =
           group_manager.createElementGroup(sstr.str(), element_dimension, true);
 
-      std::set<UInt>::iterator it = global_clusters[c].begin();
-      std::set<UInt>::iterator end = global_clusters[c].end();
+      auto it = global_clusters[c].begin();
+      auto end = global_clusters[c].end();
 
       /// append to current element group all fragments that belong to
       /// the same cluster if they exist
       for (; it != end; ++it) {
         Int local_index = *it - starting_index;
 
         if (local_index < 0 || local_index >= Int(nb_cluster))
           continue;
 
         std::stringstream tmp_sstr;
         tmp_sstr << "tmp_" << cluster_name_prefix << "_" << local_index;
         auto eg_it = group_manager.element_group_find(tmp_sstr.str());
 
         AKANTU_DEBUG_ASSERT(eg_it != group_manager.element_group_end(),
                             "Temporary fragment \"" << tmp_sstr.str()
                                                     << "\" not found");
 
         cluster.append(*(eg_it->second));
         group_manager.destroyElementGroup(tmp_sstr.str(), true);
       }
     }
 
     return total_nb_cluster;
   }
 
 private:
   /// functions for parallel communications
   inline UInt getNbData(const Array<Element> & elements,
                         const SynchronizationTag & tag) const override {
     if (tag == _gst_gm_clusters)
       return elements.size() * sizeof(UInt);
 
     return 0;
   }
 
   inline void packData(CommunicationBuffer & buffer,
                        const Array<Element> & elements,
                        const SynchronizationTag & tag) const override {
     if (tag != _gst_gm_clusters)
       return;
 
     Array<Element>::const_iterator<> el_it = elements.begin();
     Array<Element>::const_iterator<> el_end = elements.end();
 
     for (; el_it != el_end; ++el_it) {
 
       const Element & el = *el_it;
 
       /// for each element pack its global cluster index
       buffer << element_to_fragment(el.type, el.ghost_type)(el.element) +
                     starting_index;
     }
   }
 
   inline void unpackData(CommunicationBuffer & buffer,
                          const Array<Element> & elements,
                          const SynchronizationTag & tag) override {
     if (tag != _gst_gm_clusters)
       return;
 
     Array<Element>::const_iterator<> el_it = elements.begin();
     Array<Element>::const_iterator<> el_end = elements.end();
 
     for (; el_it != el_end; ++el_it) {
       UInt distant_cluster;
 
       buffer >> distant_cluster;
 
       const Element & el = *el_it;
       UInt local_cluster =
           element_to_fragment(el.type, el.ghost_type)(el.element) +
           starting_index;
 
       distant_ids.insert(std::make_pair(local_cluster, distant_cluster));
     }
   }
 
 private:
   GroupManager & group_manager;
   UInt element_dimension;
   std::string cluster_name_prefix;
   ElementTypeMapArray<UInt> & element_to_fragment;
   const ElementSynchronizer & element_synchronizer;
 
   UInt nb_cluster;
   DistantIDs distant_ids;
 
   UInt starting_index;
 };
 
 /* -------------------------------------------------------------------------- */
 /// \todo this function doesn't work in 1D
 UInt GroupManager::createBoundaryGroupFromGeometry() {
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   return createClusters(spatial_dimension - 1, "boundary");
 }
 
 /* -------------------------------------------------------------------------- */
 UInt GroupManager::createClusters(
     UInt element_dimension, Mesh & mesh_facets, std::string cluster_name_prefix,
     const GroupManager::ClusteringFilter & filter) {
-  return createClusters(element_dimension, cluster_name_prefix, filter, mesh_facets);
+  return createClusters(element_dimension, std::move(cluster_name_prefix),
+                        filter, mesh_facets);
 }
 
 /* -------------------------------------------------------------------------- */
 UInt GroupManager::createClusters(
     UInt element_dimension, std::string cluster_name_prefix,
     const GroupManager::ClusteringFilter & filter) {
   std::unique_ptr<Mesh> mesh_facets;
   if (!mesh_facets && element_dimension > 0) {
     MeshAccessor mesh_accessor(const_cast<Mesh &>(mesh));
     mesh_facets = std::make_unique<Mesh>(mesh.getSpatialDimension(),
                                          mesh_accessor.getNodesSharedPtr(),
                                          "mesh_facets_for_clusters");
 
     mesh_facets->defineMeshParent(mesh);
 
     MeshUtils::buildAllFacets(mesh, *mesh_facets, element_dimension,
                               element_dimension - 1);
   }
 
-  return createClusters(element_dimension, cluster_name_prefix, filter, *mesh_facets);
+  return createClusters(element_dimension, std::move(cluster_name_prefix),
+                        filter, *mesh_facets);
 }
 
 /* -------------------------------------------------------------------------- */
 //// \todo if needed element list construction can be optimized by
 //// templating the filter class
 UInt GroupManager::createClusters(UInt element_dimension,
-                                  std::string cluster_name_prefix,
+                                  const std::string & cluster_name_prefix,
                                   const GroupManager::ClusteringFilter & filter,
                                   Mesh & mesh_facets) {
   AKANTU_DEBUG_IN();
 
   UInt nb_proc = mesh.getCommunicator().getNbProc();
   std::string tmp_cluster_name_prefix = cluster_name_prefix;
 
   ElementTypeMapArray<UInt> * element_to_fragment = nullptr;
 
   if (nb_proc > 1 && mesh.isDistributed()) {
     element_to_fragment =
         new ElementTypeMapArray<UInt>("element_to_fragment", id, memory_id);
 
     element_to_fragment->initialize(
         mesh, _nb_component = 1, _spatial_dimension = element_dimension,
         _element_kind = _ek_not_defined, _with_nb_element = true);
     // mesh.initElementTypeMapArray(*element_to_fragment, 1, element_dimension,
     //                              false, _ek_not_defined, true);
     tmp_cluster_name_prefix = "tmp_" + tmp_cluster_name_prefix;
   }
 
   ElementTypeMapArray<bool> seen_elements("seen_elements", id, memory_id);
   seen_elements.initialize(mesh, _spatial_dimension = element_dimension,
                            _element_kind = _ek_not_defined,
                            _with_nb_element = true);
   // mesh.initElementTypeMapArray(seen_elements, 1, element_dimension, false,
   //                              _ek_not_defined, true);
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType ghost_type = *gt;
     Element el;
     el.ghost_type = ghost_type;
 
     Mesh::type_iterator type_it =
         mesh.firstType(element_dimension, ghost_type, _ek_not_defined);
     Mesh::type_iterator type_end =
         mesh.lastType(element_dimension, ghost_type, _ek_not_defined);
 
     for (; type_it != type_end; ++type_it) {
       el.type = *type_it;
       UInt nb_element = mesh.getNbElement(*type_it, ghost_type);
       Array<bool> & seen_elements_array = seen_elements(el.type, ghost_type);
 
       for (UInt e = 0; e < nb_element; ++e) {
         el.element = e;
         if (!filter(el))
           seen_elements_array(e) = true;
       }
     }
   }
 
   Array<bool> checked_node(mesh.getNbNodes(), 1, false);
 
   UInt nb_cluster = 0;
 
   /// keep looping until all elements are seen
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType ghost_type = *gt;
     Element uns_el;
     uns_el.ghost_type = ghost_type;
 
     Mesh::type_iterator type_it =
         mesh.firstType(element_dimension, ghost_type, _ek_not_defined);
     Mesh::type_iterator type_end =
         mesh.lastType(element_dimension, ghost_type, _ek_not_defined);
 
     for (; type_it != type_end; ++type_it) {
       uns_el.type = *type_it;
       Array<bool> & seen_elements_vec =
           seen_elements(uns_el.type, uns_el.ghost_type);
 
       for (UInt e = 0; e < seen_elements_vec.size(); ++e) {
         // skip elements that have been already seen
         if (seen_elements_vec(e) == true)
           continue;
 
         // set current element
         uns_el.element = e;
         seen_elements_vec(e) = true;
 
         /// create a new cluster
         std::stringstream sstr;
         sstr << tmp_cluster_name_prefix << "_" << nb_cluster;
         ElementGroup & cluster =
             createElementGroup(sstr.str(), element_dimension, true);
         ++nb_cluster;
 
         // point element are cluster by themself
         if (element_dimension == 0) {
           cluster.add(uns_el);
 
           UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(uns_el.type);
           Vector<UInt> connect =
               mesh.getConnectivity(uns_el.type, uns_el.ghost_type)
                   .begin(nb_nodes_per_element)[uns_el.element];
           for (UInt n = 0; n < nb_nodes_per_element; ++n) {
             /// add element's nodes to the cluster
             UInt node = connect[n];
             if (!checked_node(node)) {
               cluster.addNode(node);
               checked_node(node) = true;
             }
           }
 
           continue;
         }
 
         std::queue<Element> element_to_add;
         element_to_add.push(uns_el);
 
         /// keep looping until current cluster is complete (no more
         /// connected elements)
         while (!element_to_add.empty()) {
 
           /// take first element and erase it in the queue
           Element el = element_to_add.front();
           element_to_add.pop();
 
           /// if parallel, store cluster index per element
           if (nb_proc > 1 && mesh.isDistributed())
             (*element_to_fragment)(el.type, el.ghost_type)(el.element) =
                 nb_cluster - 1;
 
           /// add current element to the cluster
           cluster.add(el);
 
           const Array<Element> & element_to_facet =
               mesh_facets.getSubelementToElement(el.type, el.ghost_type);
 
           UInt nb_facet_per_element = element_to_facet.getNbComponent();
 
           for (UInt f = 0; f < nb_facet_per_element; ++f) {
             const Element & facet = element_to_facet(el.element, f);
 
             if (facet == ElementNull)
               continue;
 
             const std::vector<Element> & connected_elements =
                 mesh_facets.getElementToSubelement(
                     facet.type, facet.ghost_type)(facet.element);
 
             for (UInt elem = 0; elem < connected_elements.size(); ++elem) {
               const Element & check_el = connected_elements[elem];
 
               // check if this element has to be skipped
               if (check_el == ElementNull || check_el == el)
                 continue;
 
               Array<bool> & seen_elements_vec_current =
                   seen_elements(check_el.type, check_el.ghost_type);
 
               if (seen_elements_vec_current(check_el.element) == false) {
                 seen_elements_vec_current(check_el.element) = true;
                 element_to_add.push(check_el);
               }
             }
           }
 
           UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(el.type);
           Vector<UInt> connect = mesh.getConnectivity(el.type, el.ghost_type)
                                      .begin(nb_nodes_per_element)[el.element];
           for (UInt n = 0; n < nb_nodes_per_element; ++n) {
             /// add element's nodes to the cluster
             UInt node = connect[n];
             if (!checked_node(node)) {
               cluster.addNode(node, false);
               checked_node(node) = true;
             }
           }
         }
       }
     }
   }
 
   if (nb_proc > 1 && mesh.isDistributed()) {
     ClusterSynchronizer cluster_synchronizer(
         *this, element_dimension, cluster_name_prefix, *element_to_fragment,
         this->mesh.getElementSynchronizer(), nb_cluster);
     nb_cluster = cluster_synchronizer.synchronize();
     delete element_to_fragment;
   }
 
   if (mesh.isDistributed())
     this->synchronizeGroupNames();
 
   AKANTU_DEBUG_OUT();
   return nb_cluster;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void GroupManager::createGroupsFromMeshData(const std::string & dataset_name) {
   std::set<std::string> group_names;
   const ElementTypeMapArray<T> & datas = mesh.getData<T>(dataset_name);
-  typedef typename ElementTypeMapArray<T>::type_iterator type_iterator;
+  using type_iterator =
+      typename ElementTypeMapArray<T>::type_iterator;
 
   std::map<std::string, UInt> group_dim;
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     type_iterator type_it = datas.firstType(_all_dimensions, *gt);
     type_iterator type_end = datas.lastType(_all_dimensions, *gt);
     for (; type_it != type_end; ++type_it) {
       const Array<T> & dataset = datas(*type_it, *gt);
       UInt nb_element = mesh.getNbElement(*type_it, *gt);
       AKANTU_DEBUG_ASSERT(dataset.size() == nb_element,
                           "Not the same number of elements ("
                               << *type_it << ":" << *gt
                               << ") in the map from MeshData ("
                               << dataset.size() << ") " << dataset_name
                               << " and in the mesh (" << nb_element << ")!");
       for (UInt e(0); e < nb_element; ++e) {
         std::stringstream sstr;
         sstr << dataset(e);
         std::string gname = sstr.str();
         group_names.insert(gname);
 
-        std::map<std::string, UInt>::iterator it = group_dim.find(gname);
+        auto it = group_dim.find(gname);
         if (it == group_dim.end()) {
           group_dim[gname] = mesh.getSpatialDimension(*type_it);
         } else {
           it->second = std::max(it->second, mesh.getSpatialDimension(*type_it));
         }
       }
     }
   }
 
-  std::set<std::string>::iterator git = group_names.begin();
-  std::set<std::string>::iterator gend = group_names.end();
+  auto git = group_names.begin();
+  auto gend = group_names.end();
   for (; git != gend; ++git)
     createElementGroup(*git, group_dim[*git]);
 
   if (mesh.isDistributed())
     this->synchronizeGroupNames();
 
   Element el;
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     el.ghost_type = *gt;
 
     type_iterator type_it = datas.firstType(_all_dimensions, *gt);
     type_iterator type_end = datas.lastType(_all_dimensions, *gt);
     for (; type_it != type_end; ++type_it) {
       el.type = *type_it;
 
       const Array<T> & dataset = datas(*type_it, *gt);
       UInt nb_element = mesh.getNbElement(*type_it, *gt);
       AKANTU_DEBUG_ASSERT(dataset.size() == nb_element,
                           "Not the same number of elements in the map from "
                           "MeshData and in the mesh!");
 
       UInt nb_nodes_per_element = mesh.getNbNodesPerElement(el.type);
 
       Array<UInt>::const_iterator<Vector<UInt>> cit =
           mesh.getConnectivity(*type_it, *gt).begin(nb_nodes_per_element);
 
       for (UInt e(0); e < nb_element; ++e, ++cit) {
         el.element = e;
         std::stringstream sstr;
         sstr << dataset(e);
         ElementGroup & group = getElementGroup(sstr.str());
         group.add(el, false, false);
 
         const Vector<UInt> & connect = *cit;
         for (UInt n = 0; n < nb_nodes_per_element; ++n) {
           UInt node = connect[n];
           group.addNode(node, false);
         }
       }
     }
   }
 
   git = group_names.begin();
   for (; git != gend; ++git) {
     getElementGroup(*git).optimize();
   }
 }
 
 template void GroupManager::createGroupsFromMeshData<std::string>(
     const std::string & dataset_name);
 template void
 GroupManager::createGroupsFromMeshData<UInt>(const std::string & dataset_name);
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::createElementGroupFromNodeGroup(
     const std::string & name, const std::string & node_group_name,
     UInt dimension) {
   NodeGroup & node_group = getNodeGroup(node_group_name);
   ElementGroup & group = createElementGroup(name, dimension, node_group);
 
   group.fillFromNodeGroup();
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "GroupManager [" << std::endl;
 
   std::set<std::string> node_group_seen;
-  for (const_element_group_iterator it(element_group_begin());
-       it != element_group_end(); ++it) {
+  for (auto it(element_group_begin()); it != element_group_end(); ++it) {
     it->second->printself(stream, indent + 1);
     node_group_seen.insert(it->second->getNodeGroup().getName());
   }
 
-  for (const_node_group_iterator it(node_group_begin()); it != node_group_end();
-       ++it) {
+  for (auto it(node_group_begin()); it != node_group_end(); ++it) {
     if (node_group_seen.find(it->second->getName()) == node_group_seen.end())
       it->second->printself(stream, indent + 1);
   }
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 UInt GroupManager::getNbElementGroups(UInt dimension) const {
   if (dimension == _all_dimensions)
     return element_groups.size();
 
-  ElementGroups::const_iterator it = element_groups.begin();
-  ElementGroups::const_iterator end = element_groups.end();
+  auto it = element_groups.begin();
+  auto end = element_groups.end();
   UInt count = 0;
   for (; it != end; ++it)
     count += (it->second->getDimension() == dimension);
   return count;
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::checkAndAddGroups(CommunicationBuffer & buffer) {
   AKANTU_DEBUG_IN();
 
   UInt nb_node_group;
   buffer >> nb_node_group;
   AKANTU_DEBUG_INFO("Received " << nb_node_group << " node group names");
 
   for (UInt ng = 0; ng < nb_node_group; ++ng) {
     std::string node_group_name;
     buffer >> node_group_name;
 
     if (node_groups.find(node_group_name) == node_groups.end()) {
       this->createNodeGroup(node_group_name);
     }
 
     AKANTU_DEBUG_INFO("Received node goup name: " << node_group_name);
   }
 
   UInt nb_element_group;
   buffer >> nb_element_group;
   AKANTU_DEBUG_INFO("Received " << nb_element_group << " element group names");
   for (UInt eg = 0; eg < nb_element_group; ++eg) {
     std::string element_group_name;
     buffer >> element_group_name;
     std::string node_group_name;
     buffer >> node_group_name;
     UInt dim;
     buffer >> dim;
 
     AKANTU_DEBUG_INFO("Received element group name: "
                       << element_group_name << " corresponding to a "
                       << Int(dim) << "D group with node group "
                       << node_group_name);
 
     NodeGroup & node_group = *node_groups[node_group_name];
 
     if (element_groups.find(element_group_name) == element_groups.end()) {
       this->createElementGroup(element_group_name, dim, node_group);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::fillBufferWithGroupNames(
     DynamicCommunicationBuffer & comm_buffer) const {
   AKANTU_DEBUG_IN();
 
   // packing node group names;
   UInt nb_groups = this->node_groups.size();
   comm_buffer << nb_groups;
   AKANTU_DEBUG_INFO("Sending " << nb_groups << " node group names");
 
-  NodeGroups::const_iterator nnames_it = node_groups.begin();
-  NodeGroups::const_iterator nnames_end = node_groups.end();
+  auto nnames_it = node_groups.begin();
+  auto nnames_end = node_groups.end();
   for (; nnames_it != nnames_end; ++nnames_it) {
     std::string node_group_name = nnames_it->first;
     comm_buffer << node_group_name;
     AKANTU_DEBUG_INFO("Sending node goupe name: " << node_group_name);
   }
 
   // packing element group names with there associated node group name
   nb_groups = this->element_groups.size();
   comm_buffer << nb_groups;
   AKANTU_DEBUG_INFO("Sending " << nb_groups << " element group names");
-  ElementGroups::const_iterator gnames_it = this->element_groups.begin();
-  ElementGroups::const_iterator gnames_end = this->element_groups.end();
+  auto gnames_it = this->element_groups.begin();
+  auto gnames_end = this->element_groups.end();
   for (; gnames_it != gnames_end; ++gnames_it) {
     ElementGroup & element_group = *(gnames_it->second);
     std::string element_group_name = gnames_it->first;
     std::string node_group_name = element_group.getNodeGroup().getName();
     UInt dim = element_group.getDimension();
 
     comm_buffer << element_group_name;
     comm_buffer << node_group_name;
     comm_buffer << dim;
 
     AKANTU_DEBUG_INFO("Sending element group name: "
                       << element_group_name << " corresponding to a "
                       << Int(dim) << "D group with the node group "
                       << node_group_name);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::synchronizeGroupNames() {
   AKANTU_DEBUG_IN();
 
   const Communicator & comm = mesh.getCommunicator();
   Int nb_proc = comm.getNbProc();
   Int my_rank = comm.whoAmI();
 
   if (nb_proc == 1)
     return;
 
   if (my_rank == 0) {
     for (Int p = 1; p < nb_proc; ++p) {
       CommunicationStatus status;
       comm.probe<char>(p, p, status);
       AKANTU_DEBUG_INFO("Got " << printMemorySize<char>(status.size())
                                << " from proc " << p);
 
       CommunicationBuffer recv_buffer(status.size());
       comm.receive(recv_buffer, p, p);
 
       this->checkAndAddGroups(recv_buffer);
     }
 
     DynamicCommunicationBuffer comm_buffer;
     this->fillBufferWithGroupNames(comm_buffer);
 
     UInt buffer_size = comm_buffer.size();
 
     comm.broadcast(buffer_size, 0);
 
     AKANTU_DEBUG_INFO("Initiating broadcast with "
                       << printMemorySize<char>(comm_buffer.size()));
     comm.broadcast(comm_buffer, 0);
 
   } else {
     DynamicCommunicationBuffer comm_buffer;
     this->fillBufferWithGroupNames(comm_buffer);
 
     AKANTU_DEBUG_INFO("Sending " << printMemorySize<char>(comm_buffer.size())
                                  << " to proc " << 0);
     comm.send(comm_buffer, 0, my_rank);
 
     UInt buffer_size = 0;
     comm.broadcast(buffer_size, 0);
 
     AKANTU_DEBUG_INFO("Receiving broadcast with "
                       << printMemorySize<char>(comm_buffer.size()));
     CommunicationBuffer recv_buffer(buffer_size);
     comm.broadcast(recv_buffer, 0);
 
     this->checkAndAddGroups(recv_buffer);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 const ElementGroup &
 GroupManager::getElementGroup(const std::string & name) const {
-  const_element_group_iterator it = element_group_find(name);
+  auto it = element_group_find(name);
   if (it == element_group_end()) {
     AKANTU_EXCEPTION("There are no element groups named "
                      << name << " associated to the group manager: " << id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 ElementGroup & GroupManager::getElementGroup(const std::string & name) {
-  element_group_iterator it = element_group_find(name);
+  auto it = element_group_find(name);
   if (it == element_group_end()) {
     AKANTU_EXCEPTION("There are no element groups named "
                      << name << " associated to the group manager: " << id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 const NodeGroup & GroupManager::getNodeGroup(const std::string & name) const {
-  const_node_group_iterator it = node_group_find(name);
+  auto it = node_group_find(name);
   if (it == node_group_end()) {
     AKANTU_EXCEPTION("There are no node groups named "
                      << name << " associated to the group manager: " << id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 NodeGroup & GroupManager::getNodeGroup(const std::string & name) {
-  node_group_iterator it = node_group_find(name);
+  auto it = node_group_find(name);
   if (it == node_group_end()) {
     AKANTU_EXCEPTION("There are no node groups named "
                      << name << " associated to the group manager: " << id);
   }
 
   return *(it->second);
 }
 
 } // namespace akantu
diff --git a/src/mesh/group_manager.hh b/src/mesh/group_manager.hh
index caba3d89e..f3586c7ed 100644
--- a/src/mesh/group_manager.hh
+++ b/src/mesh/group_manager.hh
@@ -1,305 +1,306 @@
 /**
  * @file   group_manager.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@gmail.com>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Mon Nov 16 2015
  *
  * @brief  Stores information relevent to the notion of element and nodes
  *groups.
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_GROUP_MANAGER_HH__
 #define __AKANTU_GROUP_MANAGER_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "element_type_map.hh"
 /* -------------------------------------------------------------------------- */
 #include <set>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 class ElementGroup;
 class NodeGroup;
 class Mesh;
 class Element;
 class ElementSynchronizer;
 template <bool> class CommunicationBufferTemplated;
 namespace dumper {
   class Field;
 }
 } // namespace akantu
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 class GroupManager {
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 private:
   using ElementGroups = std::map<std::string, ElementGroup *>;
   using NodeGroups = std::map<std::string, NodeGroup *>;
 
 public:
-  typedef std::set<ElementType> GroupManagerTypeSet;
+  using GroupManagerTypeSet = std::set<ElementType>;
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   GroupManager(const Mesh & mesh, const ID & id = "group_manager",
                const MemoryID & memory_id = 0);
   virtual ~GroupManager();
 
   /* ------------------------------------------------------------------------ */
   /* Groups iterators                                                         */
   /* ------------------------------------------------------------------------ */
 public:
-  typedef NodeGroups::iterator node_group_iterator;
-  typedef ElementGroups::iterator element_group_iterator;
+  using node_group_iterator = NodeGroups::iterator;
+  using element_group_iterator = ElementGroups::iterator;
 
-  typedef NodeGroups::const_iterator const_node_group_iterator;
-  typedef ElementGroups::const_iterator const_element_group_iterator;
+  using const_node_group_iterator = NodeGroups::const_iterator;
+  using const_element_group_iterator = ElementGroups::const_iterator;
 
 #ifndef SWIG
 #define AKANTU_GROUP_MANAGER_DEFINE_ITERATOR_FUNCTION(group_type, function,    \
                                                       param_in, param_out)     \
   inline BOOST_PP_CAT(BOOST_PP_CAT(const_, group_type), _iterator)             \
       BOOST_PP_CAT(BOOST_PP_CAT(group_type, _), function)(param_in) const {    \
     return BOOST_PP_CAT(group_type, s).function(param_out);                    \
   };                                                                           \
                                                                                \
   inline BOOST_PP_CAT(group_type, _iterator)                                   \
       BOOST_PP_CAT(BOOST_PP_CAT(group_type, _), function)(param_in) {          \
     return BOOST_PP_CAT(group_type, s).function(param_out);                    \
   }
 
 #define AKANTU_GROUP_MANAGER_DEFINE_ITERATOR_FUNCTION_NP(group_type, function) \
   AKANTU_GROUP_MANAGER_DEFINE_ITERATOR_FUNCTION(                               \
       group_type, function, BOOST_PP_EMPTY(), BOOST_PP_EMPTY())
 
   AKANTU_GROUP_MANAGER_DEFINE_ITERATOR_FUNCTION_NP(node_group, begin);
   AKANTU_GROUP_MANAGER_DEFINE_ITERATOR_FUNCTION_NP(node_group, end);
   AKANTU_GROUP_MANAGER_DEFINE_ITERATOR_FUNCTION_NP(element_group, begin);
   AKANTU_GROUP_MANAGER_DEFINE_ITERATOR_FUNCTION_NP(element_group, end);
   AKANTU_GROUP_MANAGER_DEFINE_ITERATOR_FUNCTION(element_group, find,
                                                 const std::string & name, name);
   AKANTU_GROUP_MANAGER_DEFINE_ITERATOR_FUNCTION(node_group, find,
                                                 const std::string & name, name);
 #endif
 
   /* ------------------------------------------------------------------------ */
   /* Clustering filter                                                        */
   /* ------------------------------------------------------------------------ */
 public:
   class ClusteringFilter {
   public:
     virtual bool operator()(const Element &) const { return true; }
   };
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// create an empty node group
   NodeGroup & createNodeGroup(const std::string & group_name,
                               bool replace_group = false);
 
   /// create a node group from another node group but filtered
   template <typename T>
   NodeGroup & createFilteredNodeGroup(const std::string & group_name,
                                       const NodeGroup & node_group, T & filter);
 
   /// destroy a node group
   void destroyNodeGroup(const std::string & group_name);
 
   /// create an element group and the associated node group
   ElementGroup & createElementGroup(const std::string & group_name,
                                     UInt dimension = _all_dimensions,
                                     bool replace_group = false);
 
   /// create an element group from another element group but filtered
   template <typename T>
   ElementGroup &
   createFilteredElementGroup(const std::string & group_name, UInt dimension,
                              const NodeGroup & node_group, T & filter);
 
   /// destroy an element group and the associated node group
   void destroyElementGroup(const std::string & group_name,
                            bool destroy_node_group = false);
 
   /// destroy all element groups and the associated node groups
   void destroyAllElementGroups(bool destroy_node_groups = false);
 
   /// create a element group using an existing node group
   ElementGroup & createElementGroup(const std::string & group_name,
                                     UInt dimension, NodeGroup & node_group);
 
   /// create groups based on values stored in a given mesh data
   template <typename T>
   void createGroupsFromMeshData(const std::string & dataset_name);
 
   /// create boundaries group by a clustering algorithm \todo extend to parallel
   UInt createBoundaryGroupFromGeometry();
 
   /// create element clusters for a given dimension
   UInt createClusters(UInt element_dimension, Mesh & mesh_facets,
                       std::string cluster_name_prefix = "cluster",
                       const ClusteringFilter & filter = ClusteringFilter());
 
   /// create element clusters for a given dimension
   UInt createClusters(UInt element_dimension,
                       std::string cluster_name_prefix = "cluster",
                       const ClusteringFilter & filter = ClusteringFilter());
 
 private:
   /// create element clusters for a given dimension
-  UInt createClusters(UInt element_dimension, std::string cluster_name_prefix,
+  UInt createClusters(UInt element_dimension,
+                      const std::string & cluster_name_prefix,
                       const ClusteringFilter & filter, Mesh & mesh_facets);
 
 public:
   /// Create an ElementGroup based on a NodeGroup
   void createElementGroupFromNodeGroup(const std::string & name,
                                        const std::string & node_group,
                                        UInt dimension = _all_dimensions);
 
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
   /// this function insure that the group names are present on all processors
   /// /!\ it is a SMP call
   void synchronizeGroupNames();
 
 /// register an elemental field to the given group name (overloading for
 /// ElementalPartionField)
 #ifndef SWIG
   template <typename T, template <bool> class dump_type>
   dumper::Field * createElementalField(
       const ElementTypeMapArray<T> & field, const std::string & group_name,
       UInt spatial_dimension, const ElementKind & kind,
       ElementTypeMap<UInt> nb_data_per_elem = ElementTypeMap<UInt>());
 
   /// register an elemental field to the given group name (overloading for
   /// ElementalField)
   template <typename T, template <class> class ret_type,
             template <class, template <class> class, bool> class dump_type>
   dumper::Field * createElementalField(
       const ElementTypeMapArray<T> & field, const std::string & group_name,
       UInt spatial_dimension, const ElementKind & kind,
       ElementTypeMap<UInt> nb_data_per_elem = ElementTypeMap<UInt>());
 
   /// register an elemental field to the given group name (overloading for
   /// MaterialInternalField)
   template <typename T,
             /// type of InternalMaterialField
             template <typename, bool filtered> class dump_type>
   dumper::Field * createElementalField(const ElementTypeMapArray<T> & field,
                                        const std::string & group_name,
                                        UInt spatial_dimension,
                                        const ElementKind & kind,
                                        ElementTypeMap<UInt> nb_data_per_elem);
 
   template <typename type, bool flag, template <class, bool> class ftype>
   dumper::Field * createNodalField(const ftype<type, flag> * field,
                                    const std::string & group_name,
                                    UInt padding_size = 0);
 
   template <typename type, bool flag, template <class, bool> class ftype>
   dumper::Field * createStridedNodalField(const ftype<type, flag> * field,
                                           const std::string & group_name,
                                           UInt size, UInt stride,
                                           UInt padding_size);
 
 protected:
   /// fill a buffer with all the group names
   void fillBufferWithGroupNames(
       CommunicationBufferTemplated<false> & comm_buffer) const;
 
   /// take a buffer and create the missing groups localy
   void checkAndAddGroups(CommunicationBufferTemplated<true> & buffer);
 
   /// register an elemental field to the given group name
   template <class dump_type, typename field_type>
   inline dumper::Field *
   createElementalField(const field_type & field, const std::string & group_name,
                        UInt spatial_dimension, const ElementKind & kind,
-                       ElementTypeMap<UInt> nb_data_per_elem);
+                       const ElementTypeMap<UInt> & nb_data_per_elem);
 
   /// register an elemental field to the given group name
   template <class dump_type, typename field_type>
   inline dumper::Field *
   createElementalFilteredField(const field_type & field,
                                const std::string & group_name,
                                UInt spatial_dimension, const ElementKind & kind,
                                ElementTypeMap<UInt> nb_data_per_elem);
 #endif
 
   /* ------------------------------------------------------------------------ */
   /* Accessor                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   const ElementGroup & getElementGroup(const std::string & name) const;
   const NodeGroup & getNodeGroup(const std::string & name) const;
 
   ElementGroup & getElementGroup(const std::string & name);
   NodeGroup & getNodeGroup(const std::string & name);
 
   UInt getNbElementGroups(UInt dimension = _all_dimensions) const;
   UInt getNbNodeGroups() { return node_groups.size(); };
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// id to create element and node groups
   ID id;
   /// memory_id to create element and node groups
   MemoryID memory_id;
 
   /// list of the node groups managed
   NodeGroups node_groups;
 
   /// list of the element groups managed
   ElementGroups element_groups;
 
   /// Mesh to which the element belongs
   const Mesh & mesh;
 };
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream,
                                  const GroupManager & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_GROUP_MANAGER_HH__ */
diff --git a/src/mesh/group_manager_inline_impl.cc b/src/mesh/group_manager_inline_impl.cc
index 72f4946ff..ad0170672 100644
--- a/src/mesh/group_manager_inline_impl.cc
+++ b/src/mesh/group_manager_inline_impl.cc
@@ -1,207 +1,207 @@
 /**
  * @file   group_manager_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Stores information relevent to the notion of domain boundary and
  * surfaces.
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dumper_field.hh"
 #include "element_group.hh"
 #include "element_type_map_filter.hh"
 #ifdef AKANTU_USE_IOHELPER
 #include "dumper_nodal_field.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T, template <bool> class dump_type>
 dumper::Field * GroupManager::createElementalField(
     const ElementTypeMapArray<T> & field, const std::string & group_name,
     UInt spatial_dimension, const ElementKind & kind,
     ElementTypeMap<UInt> nb_data_per_elem) {
 
   const ElementTypeMapArray<T> * field_ptr = &field;
   if (field_ptr == nullptr)
     return nullptr;
   if (group_name == "all")
     return this->createElementalField<dump_type<false> >(
         field, group_name, spatial_dimension, kind, nb_data_per_elem);
   else
     return this->createElementalFilteredField<dump_type<true> >(
         field, group_name, spatial_dimension, kind, nb_data_per_elem);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, template <class> class T2,
           template <class, template <class> class, bool> class dump_type>
 dumper::Field * GroupManager::createElementalField(
     const ElementTypeMapArray<T> & field, const std::string & group_name,
     UInt spatial_dimension, const ElementKind & kind,
     ElementTypeMap<UInt> nb_data_per_elem) {
 
   const ElementTypeMapArray<T> * field_ptr = &field;
   if (field_ptr == nullptr)
     return nullptr;
   if (group_name == "all")
     return this->createElementalField<dump_type<T, T2, false> >(
         field, group_name, spatial_dimension, kind, nb_data_per_elem);
   else
     return this->createElementalFilteredField<dump_type<T, T2, true> >(
         field, group_name, spatial_dimension, kind, nb_data_per_elem);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, template <typename T2, bool filtered>
                       class dump_type> ///< type of InternalMaterialField
 dumper::Field *
 GroupManager::createElementalField(const ElementTypeMapArray<T> & field,
                                    const std::string & group_name,
                                    UInt spatial_dimension,
                                    const ElementKind & kind,
                                    ElementTypeMap<UInt> nb_data_per_elem) {
   const ElementTypeMapArray<T> * field_ptr = &field;
 
   if (field_ptr == nullptr)
     return nullptr;
   if (group_name == "all")
     return this->createElementalField<dump_type<T, false> >(
         field, group_name, spatial_dimension, kind, nb_data_per_elem);
   else
     return this->createElementalFilteredField<dump_type<T, true> >(
         field, group_name, spatial_dimension, kind, nb_data_per_elem);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename dump_type, typename field_type>
 dumper::Field * GroupManager::createElementalField(
     const field_type & field, const std::string & group_name,
     UInt spatial_dimension, const ElementKind & kind,
-    ElementTypeMap<UInt> nb_data_per_elem) {
+    const ElementTypeMap<UInt> & nb_data_per_elem) {
   const field_type * field_ptr = &field;
   if (field_ptr == nullptr)
     return nullptr;
   if (group_name != "all")
     throw;
 
   dumper::Field * dumper =
       new dump_type(field, spatial_dimension, _not_ghost, kind);
   dumper->setNbDataPerElem(nb_data_per_elem);
   return dumper;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename dump_type, typename field_type>
 dumper::Field * GroupManager::createElementalFilteredField(
     const field_type & field, const std::string & group_name,
     UInt spatial_dimension, const ElementKind & kind,
     ElementTypeMap<UInt> nb_data_per_elem) {
 
   const field_type * field_ptr = &field;
   if (field_ptr == nullptr)
     return nullptr;
   if (group_name == "all")
     throw;
 
-  typedef typename field_type::type T;
+  using T = typename field_type::type;
   ElementGroup & group = this->getElementGroup(group_name);
   UInt dim = group.getDimension();
   if (dim != spatial_dimension)
     throw;
   const ElementTypeMapArray<UInt> & elemental_filter = group.getElements();
 
-  ElementTypeMapArrayFilter<T> * filtered = new ElementTypeMapArrayFilter<T>(
-      field, elemental_filter, nb_data_per_elem);
+  auto * filtered = new ElementTypeMapArrayFilter<T>(field, elemental_filter,
+                                                     nb_data_per_elem);
 
   dumper::Field * dumper = new dump_type(*filtered, dim, _not_ghost, kind);
   dumper->setNbDataPerElem(nb_data_per_elem);
 
   return dumper;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename type, bool flag, template <class, bool> class ftype>
 dumper::Field * GroupManager::createNodalField(const ftype<type, flag> * field,
                                                const std::string & group_name,
                                                UInt padding_size) {
 
   if (field == nullptr)
     return nullptr;
   if (group_name == "all") {
     typedef typename dumper::NodalField<type, false> DumpType;
-    DumpType * dumper = new DumpType(*field, 0, 0, nullptr);
+    auto * dumper = new DumpType(*field, 0, 0, nullptr);
     dumper->setPadding(padding_size);
     return dumper;
   } else {
     ElementGroup & group = this->getElementGroup(group_name);
     const Array<UInt> * nodal_filter = &(group.getNodes());
     typedef typename dumper::NodalField<type, true> DumpType;
-    DumpType * dumper = new DumpType(*field, 0, 0, nodal_filter);
+    auto * dumper = new DumpType(*field, 0, 0, nodal_filter);
     dumper->setPadding(padding_size);
     return dumper;
   }
   return nullptr;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename type, bool flag, template <class, bool> class ftype>
 dumper::Field *
 GroupManager::createStridedNodalField(const ftype<type, flag> * field,
                                       const std::string & group_name, UInt size,
                                       UInt stride, UInt padding_size) {
 
   if (field == NULL)
     return nullptr;
   if (group_name == "all") {
     typedef typename dumper::NodalField<type, false> DumpType;
-    DumpType * dumper = new DumpType(*field, size, stride, NULL);
+    auto * dumper = new DumpType(*field, size, stride, NULL);
     dumper->setPadding(padding_size);
     return dumper;
   } else {
     ElementGroup & group = this->getElementGroup(group_name);
     const Array<UInt> * nodal_filter = &(group.getNodes());
     typedef typename dumper::NodalField<type, true> DumpType;
-    DumpType * dumper = new DumpType(*field, size, stride, nodal_filter);
+    auto * dumper = new DumpType(*field, size, stride, nodal_filter);
     dumper->setPadding(padding_size);
     return dumper;
   }
   return nullptr;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
 
 #endif
diff --git a/src/mesh/mesh.cc b/src/mesh/mesh.cc
index a1c460a24..e72a74112 100644
--- a/src/mesh/mesh.cc
+++ b/src/mesh/mesh.cc
@@ -1,476 +1,476 @@
 /**
  * @file   mesh.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  class handling meshes
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_config.hh"
 /* -------------------------------------------------------------------------- */
 #include "element_class.hh"
 #include "group_manager_inline_impl.cc"
 #include "mesh.hh"
 #include "mesh_io.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 #include "element_synchronizer.hh"
 #include "facet_synchronizer.hh"
 #include "mesh_utils_distribution.hh"
 #include "node_synchronizer.hh"
 #include "communicator.hh"
 /* -------------------------------------------------------------------------- */
 #ifdef AKANTU_USE_IOHELPER
 #include "dumper_field.hh"
 #include "dumper_internal_material_field.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 #include <sstream>
 /* -------------------------------------------------------------------------- */
 
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Mesh::Mesh(UInt spatial_dimension, const ID & id, const MemoryID & memory_id,
            Communicator & communicator)
     : Memory(id, memory_id),
       GroupManager(*this, id + ":group_manager", memory_id),
       nodes_type(0, 1, id + ":nodes_type"),
       connectivities("connectivities", id, memory_id),
       ghosts_counters("ghosts_counters", id, memory_id),
       normals("normals", id, memory_id), spatial_dimension(spatial_dimension),
       lower_bounds(spatial_dimension, 0.), upper_bounds(spatial_dimension, 0.),
       size(spatial_dimension, 0.), local_lower_bounds(spatial_dimension, 0.),
       local_upper_bounds(spatial_dimension, 0.),
       mesh_data("mesh_data", id, memory_id), communicator(&communicator) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Mesh::Mesh(UInt spatial_dimension, Communicator & communicator,
            const ID & id, const MemoryID & memory_id)
     : Mesh(spatial_dimension, id, memory_id, communicator) {
   AKANTU_DEBUG_IN();
 
   this->nodes =
       std::make_shared<Array<Real>>(0, spatial_dimension, id + ":coordinates");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Mesh::Mesh(UInt spatial_dimension, const ID & id, const MemoryID & memory_id)
     : Mesh(spatial_dimension, Communicator::getStaticCommunicator(), id,
            memory_id) {}
 
 /* -------------------------------------------------------------------------- */
-Mesh::Mesh(UInt spatial_dimension, std::shared_ptr<Array<Real>> nodes,
+Mesh::Mesh(UInt spatial_dimension, const std::shared_ptr<Array<Real>> & nodes,
            const ID & id, const MemoryID & memory_id)
     : Mesh(spatial_dimension, id, memory_id,
            Communicator::getStaticCommunicator()) {
   this->nodes = nodes;
 
   this->nb_global_nodes = this->nodes->size();
 
   this->nodes_to_elements.resize(nodes->size());
   for (auto & node_set : nodes_to_elements) {
     node_set = std::make_unique<std::set<Element>>();
   }
 
   this->computeBoundingBox();
 }
 
 /* -------------------------------------------------------------------------- */
 Mesh & Mesh::initMeshFacets(const ID & id) {
   AKANTU_DEBUG_IN();
 
   if (!mesh_facets) {
     mesh_facets = std::make_unique<Mesh>(spatial_dimension, this->nodes,
                                          getID() + ":" + id, getMemoryID());
 
     mesh_facets->mesh_parent = this;
     mesh_facets->is_mesh_facets = true;
 
     MeshUtils::buildAllFacets(*this, *mesh_facets, 0);
 
     if (mesh.isDistributed()) {
       mesh_facets->is_distributed = true;
       mesh_facets->element_synchronizer = std::make_unique<FacetSynchronizer>(
           *mesh_facets, mesh.getElementSynchronizer());
     }
   }
 
   AKANTU_DEBUG_OUT();
   return *mesh_facets;
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::defineMeshParent(const Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   this->mesh_parent = &mesh;
   this->is_mesh_facets = true;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Mesh::~Mesh() = default;
 
 /* -------------------------------------------------------------------------- */
 void Mesh::read(const std::string & filename, const MeshIOType & mesh_io_type) {
   MeshIO mesh_io;
   mesh_io.read(filename, *this, mesh_io_type);
 
   type_iterator it =
       this->firstType(spatial_dimension, _not_ghost, _ek_not_defined);
   type_iterator last =
       this->lastType(spatial_dimension, _not_ghost, _ek_not_defined);
   if (it == last)
     AKANTU_EXCEPTION(
         "The mesh contained in the file "
         << filename << " does not seem to be of the good dimension."
         << " No element of dimension " << spatial_dimension << " where read.");
 
   this->nb_global_nodes = this->nodes->size();
 
   this->computeBoundingBox();
 
   this->nodes_to_elements.resize(nodes->size());
   for (auto & node_set : nodes_to_elements) {
     node_set = std::make_unique<std::set<Element>>();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::write(const std::string & filename,
                  const MeshIOType & mesh_io_type) {
   MeshIO mesh_io;
   mesh_io.write(filename, *this, mesh_io_type);
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "Mesh [" << std::endl;
   stream << space << " + id                : " << getID() << std::endl;
   stream << space << " + spatial dimension : " << this->spatial_dimension
          << std::endl;
   stream << space << " + nodes [" << std::endl;
   nodes->printself(stream, indent + 2);
   stream << space << " + connectivities [" << std::endl;
   connectivities.printself(stream, indent + 2);
   stream << space << " ]" << std::endl;
 
   GroupManager::printself(stream, indent + 1);
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::computeBoundingBox() {
   AKANTU_DEBUG_IN();
   for (UInt k = 0; k < spatial_dimension; ++k) {
     local_lower_bounds(k) = std::numeric_limits<double>::max();
     local_upper_bounds(k) = -std::numeric_limits<double>::max();
   }
 
   for (UInt i = 0; i < nodes->size(); ++i) {
     //    if(!isPureGhostNode(i))
     for (UInt k = 0; k < spatial_dimension; ++k) {
       local_lower_bounds(k) = std::min(local_lower_bounds[k], (*nodes)(i, k));
       local_upper_bounds(k) = std::max(local_upper_bounds[k], (*nodes)(i, k));
     }
   }
 
   if (this->is_distributed) {
     Matrix<Real> reduce_bounds(spatial_dimension, 2);
     for (UInt k = 0; k < spatial_dimension; ++k) {
       reduce_bounds(k, 0) = local_lower_bounds(k);
       reduce_bounds(k, 1) = -local_upper_bounds(k);
     }
 
     communicator->allReduce(reduce_bounds, SynchronizerOperation::_min);
 
     for (UInt k = 0; k < spatial_dimension; ++k) {
       lower_bounds(k) = reduce_bounds(k, 0);
       upper_bounds(k) = -reduce_bounds(k, 1);
     }
   } else {
     this->lower_bounds = this->local_lower_bounds;
     this->upper_bounds = this->local_upper_bounds;
   }
 
   size = upper_bounds - lower_bounds;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::initNormals() {
   normals.initialize(*this, _nb_component = spatial_dimension,
                      _spatial_dimension = spatial_dimension,
                      _element_kind = _ek_not_defined);
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::getGlobalConnectivity(
     ElementTypeMapArray<UInt> & global_connectivity) {
   AKANTU_DEBUG_IN();
 
   for (auto && ghost_type : ghost_types) {
     for (auto type :
          global_connectivity.elementTypes(_ghost_type = ghost_type)) {
       if (not connectivities.exists(type, ghost_type))
         continue;
 
       auto & local_conn = connectivities(type, ghost_type);
       auto & g_connectivity = global_connectivity(type, ghost_type);
 
       UInt nb_nodes = local_conn.size() * local_conn.getNbComponent();
 
       if (not nodes_global_ids && is_mesh_facets) {
         std::transform(
             local_conn.begin_reinterpret(nb_nodes),
             local_conn.end_reinterpret(nb_nodes),
             g_connectivity.begin_reinterpret(nb_nodes),
             [& node_ids = *mesh_parent->nodes_global_ids](UInt l)->UInt {
               return node_ids(l);
             });
       } else {
         std::transform(local_conn.begin_reinterpret(nb_nodes),
                        local_conn.end_reinterpret(nb_nodes),
                        g_connectivity.begin_reinterpret(nb_nodes),
                        [& node_ids = *nodes_global_ids](UInt l)->UInt {
                          return node_ids(l);
                        });
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 DumperIOHelper & Mesh::getGroupDumper(const std::string & dumper_name,
                                       const std::string & group_name) {
   if (group_name == "all")
     return this->getDumper(dumper_name);
   else
     return element_groups[group_name]->getDumper(dumper_name);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 ElementTypeMap<UInt> Mesh::getNbDataPerElem(ElementTypeMapArray<T> & arrays,
                                             const ElementKind & element_kind) {
   ElementTypeMap<UInt> nb_data_per_elem;
 
   for (auto type : elementTypes(spatial_dimension, _not_ghost, element_kind)) {
     UInt nb_elements = this->getNbElement(type);
     auto & array = arrays(type);
 
     nb_data_per_elem(type) = array.getNbComponent() * array.size();
     nb_data_per_elem(type) /= nb_elements;
   }
 
   return nb_data_per_elem;
 }
 
 /* -------------------------------------------------------------------------- */
 template ElementTypeMap<UInt>
 Mesh::getNbDataPerElem(ElementTypeMapArray<Real> & array,
                        const ElementKind & element_kind);
 
 template ElementTypeMap<UInt>
 Mesh::getNbDataPerElem(ElementTypeMapArray<UInt> & array,
                        const ElementKind & element_kind);
 
 /* -------------------------------------------------------------------------- */
 #ifdef AKANTU_USE_IOHELPER
 template <typename T>
 dumper::Field *
 Mesh::createFieldFromAttachedData(const std::string & field_id,
                                   const std::string & group_name,
                                   const ElementKind & element_kind) {
 
   dumper::Field * field = nullptr;
   ElementTypeMapArray<T> * internal = nullptr;
   try {
     internal = &(this->getData<T>(field_id));
   } catch (...) {
     return nullptr;
   }
 
   ElementTypeMap<UInt> nb_data_per_elem =
       this->getNbDataPerElem(*internal, element_kind);
 
   field = this->createElementalField<T, dumper::InternalMaterialField>(
       *internal, group_name, this->spatial_dimension, element_kind,
       nb_data_per_elem);
 
   return field;
 }
 
 template dumper::Field *
 Mesh::createFieldFromAttachedData<Real>(const std::string & field_id,
                                         const std::string & group_name,
                                         const ElementKind & element_kind);
 
 template dumper::Field *
 Mesh::createFieldFromAttachedData<UInt>(const std::string & field_id,
                                         const std::string & group_name,
                                         const ElementKind & element_kind);
 #endif
 
 /* -------------------------------------------------------------------------- */
 void Mesh::distribute() {
   this->distribute(Communicator::getStaticCommunicator());
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::distribute(Communicator & communicator) {
   AKANTU_DEBUG_ASSERT(is_distributed == false,
                       "This mesh is already distribute");
   this->communicator = &communicator;
 
   this->element_synchronizer = std::make_unique<ElementSynchronizer>(
       *this, this->getID() + ":element_synchronizer", this->getMemoryID(),
       true);
 
   this->node_synchronizer = std::make_unique<NodeSynchronizer>(
       *this, this->getID() + ":node_synchronizer", this->getMemoryID(), true);
 
   Int psize = this->communicator->getNbProc();
 #ifdef AKANTU_USE_SCOTCH
   Int prank = this->communicator->whoAmI();
   if (prank == 0) {
     MeshPartitionScotch partition(*this, spatial_dimension);
     partition.partitionate(psize);
 
     MeshUtilsDistribution::distributeMeshCentralized(*this, 0, partition);
   } else {
     MeshUtilsDistribution::distributeMeshCentralized(*this, 0);
   }
 #else
   if (!(psize == 1)) {
     AKANTU_DEBUG_ERROR("Cannot distribute a mesh without a partitioning tool");
   }
 #endif
 
   this->is_distributed = true;
   this->computeBoundingBox();
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::getAssociatedElements(const Array<UInt> & node_list,
                                  Array<Element> & elements) {
   for (const auto & node : node_list)
     for (const auto & element : *nodes_to_elements[node])
       elements.push_back(element);
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::fillNodesToElements() {
   Element e;
 
   UInt nb_nodes = nodes->size();
   for (UInt n = 0; n < nb_nodes; ++n) {
     if (this->nodes_to_elements[n])
       this->nodes_to_elements[n]->clear();
     else
       this->nodes_to_elements[n] = std::make_unique<std::set<Element>>();
   }
 
   for (auto ghost_type : ghost_types) {
     e.ghost_type = ghost_type;
     for (const auto & type :
          elementTypes(spatial_dimension, ghost_type, _ek_not_defined)) {
       e.type = type;
 
       UInt nb_element = this->getNbElement(type, ghost_type);
       Array<UInt>::const_iterator<Vector<UInt>> conn_it =
           connectivities(type, ghost_type)
               .begin(Mesh::getNbNodesPerElement(type));
 
       for (UInt el = 0; el < nb_element; ++el, ++conn_it) {
         e.element = el;
         const Vector<UInt> & conn = *conn_it;
         for (UInt n = 0; n < conn.size(); ++n)
           nodes_to_elements[conn(n)]->insert(e);
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::eraseElements(const Array<Element> & elements) {
   ElementTypeMap<UInt> last_element;
 
   RemovedElementsEvent event(*this);
   auto & remove_list = event.getList();
   auto & new_numbering = event.getNewNumbering();
 
   for (auto && el : elements) {
     if (el.ghost_type != _not_ghost) {
       auto & count = ghosts_counters(el);
       --count;
       if (count > 0)
         continue;
     }
 
     remove_list.push_back(el);
     if (not last_element.exists(el.type, el.ghost_type)) {
       UInt nb_element = mesh.getNbElement(el.type, el.ghost_type);
       last_element(nb_element - 1, el.type, el.ghost_type);
       auto & numbering =
           new_numbering.alloc(nb_element, 1, el.type, el.ghost_type);
       for (auto && pair : enumerate(numbering)) {
         std::get<1>(pair) = std::get<0>(pair);
       }
     }
 
     UInt & pos = last_element(el.type, el.ghost_type);
     auto & numbering = new_numbering(el.type, el.ghost_type);
 
     numbering(el.element) = UInt(-1);
     numbering(pos) = el.element;
     --pos;
   }
 
   this->sendEvent(event);
 }
 
 } // namespace akantu
diff --git a/src/mesh/mesh.hh b/src/mesh/mesh.hh
index a22dea521..d12844d07 100644
--- a/src/mesh/mesh.hh
+++ b/src/mesh/mesh.hh
@@ -1,602 +1,604 @@
 /**
  * @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 Jan 14 2016
  *
  * @brief  the class representing the meshes
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __AKANTU_MESH_HH__
 #define __AKANTU_MESH_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "aka_event_handler_manager.hh"
 #include "aka_memory.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 <set>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 class Communicator;
 class ElementSynchronizer;
 class NodeSynchronizer;
 } // namespace akantu
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* Mesh                                                                       */
 /* -------------------------------------------------------------------------- */
 
 /**
  * @class  Mesh this  contain the  coordinates of  the nodes  in  the Mesh.nodes
  * 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}
  Mesh::type_iterator it = mesh.firstType(dim, ghost_type);
  Mesh::type_iterator end = mesh.lastType(dim, ghost_type);
  for(; it != end; ++it) {
    UInt nb_element  = mesh.getNbElement(*it);
    const Array<UInt> & conn = mesh.getConnectivity(*it);
    for(UInt e = 0; e < nb_element; ++e) {
      ...
    }
  }
  @endcode
 */
 class Mesh : protected Memory,
              public EventHandlerManager<MeshEventHandler>,
              public GroupManager,
              public Dumpable {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 private:
   /// default constructor used for chaining, the last parameter is just to
   /// differentiate constructors
   Mesh(UInt spatial_dimension, const ID & id, const MemoryID & memory_id,
        Communicator & communicator);
 
 public:
   /// constructor that create nodes coordinates array
   Mesh(UInt spatial_dimension, const ID & id = "mesh",
        const MemoryID & memory_id = 0);
 
   /// mesh not distributed and not using the default communicator
   Mesh(UInt spatial_dimension, Communicator & communicator,
        const ID & id = "mesh", const MemoryID & memory_id = 0);
 
   /// constructor that use an existing nodes coordinates array, by knowing its
   /// ID
   // Mesh(UInt spatial_dimension, const ID & nodes_id, const ID & id,
   //      const MemoryID & memory_id = 0);
 
   /**
    * constructor that use an existing nodes coordinates
    * array, by getting the vector of coordinates
    */
-  Mesh(UInt spatial_dimension, std::shared_ptr<Array<Real>> nodes,
+  Mesh(UInt spatial_dimension, const std::shared_ptr<Array<Real>> & nodes,
        const ID & id = "mesh", const MemoryID & memory_id = 0);
 
   ~Mesh() override;
 
   /// @typedef ConnectivityTypeList list of the types present in a Mesh
-  typedef std::set<ElementType> ConnectivityTypeList;
+  using ConnectivityTypeList = std::set<ElementType>;
 
   /// 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);
 
 private:
   /// initialize the connectivity to NULL and other stuff
   void init();
 
   /// function that computes the bounding box (fills xmin, xmax)
   void computeBoundingBox();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// patitionate the mesh among the processors involved in their computation
   virtual void distribute(Communicator & communicator);
   virtual void distribute();
 
   /// 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,
                                             UInt * connectivity, UInt n_nodes,
                                             UInt nb_degree_of_freedom) const;
 
   // /// extract coordinates of nodes from a reversed element
   // inline void extractNodalCoordinatesFromPBCElement(Real * local_coords,
   //                                                   UInt * connectivity,
   //                                                   UInt n_nodes);
 
   /// convert a element to a linearized element
   inline UInt elementToLinearized(const Element & elem) const;
 
   /// convert a linearized element to an element
   inline Element linearizedToElement(UInt linearized_element) const;
 
   /// update the types offsets array for the conversions
   // inline void updateTypesOffsets(const GhostType & ghost_type);
 
   /// add a Array of connectivity for the type <type>.
   inline void addConnectivityType(const ElementType & type,
                                   const 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<UInt> & new_numbering);
 
   /// initialize normals
   void initNormals();
 
   /// 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<UInt> & global_connectivity);
 
 public:
   void getAssociatedElements(const Array<UInt> & node_list,
                              Array<Element> & elements);
 
 private:
   /// fills the nodes_to_elements structure
   void fillNodesToElements();
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the id of the mesh
   AKANTU_GET_MACRO(ID, Memory::id, const ID &);
 
   /// get the id of the mesh
   AKANTU_GET_MACRO(MemoryID, Memory::memory_id, const MemoryID &);
 
   /// get the spatial dimension of the mesh = number of component of the
   /// coordinates
   AKANTU_GET_MACRO(SpatialDimension, spatial_dimension, UInt);
 
   /// 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 normals for the elements
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(Normals, normals, Real);
 
   /// get the number of nodes
   AKANTU_GET_MACRO(NbNodes, nodes->size(), UInt);
 
   /// get the Array of global ids of the nodes (only used in parallel)
   AKANTU_GET_MACRO(GlobalNodesIds, *nodes_global_ids, const Array<UInt> &);
   AKANTU_GET_MACRO_NOT_CONST(GlobalNodesIds, *nodes_global_ids, Array<UInt> &);
 
   /// get the global id of a node
   inline UInt getNodeGlobalId(UInt local_id) const;
 
   /// get the global id of a node
   inline UInt getNodeLocalId(UInt global_id) const;
 
   /// get the global number of nodes
   inline UInt getNbGlobalNodes() const;
 
   /// get the nodes type Array
   AKANTU_GET_MACRO(NodesType, nodes_type, const Array<NodeType> &);
 
 protected:
   AKANTU_GET_MACRO_NOT_CONST(NodesType, nodes_type, Array<NodeType> &);
 
 public:
   inline NodeType getNodeType(UInt local_id) const;
 
   /// say if a node is a pure ghost node
   inline bool isPureGhostNode(UInt n) const;
 
   /// say if a node is pur local or master node
   inline bool isLocalOrMasterNode(UInt n) const;
 
   inline bool isLocalNode(UInt n) const;
   inline bool isMasterNode(UInt n) const;
   inline bool isSlaveNode(UInt n) const;
 
   AKANTU_GET_MACRO(LowerBounds, lower_bounds, const Vector<Real> &);
   AKANTU_GET_MACRO(UpperBounds, upper_bounds, const Vector<Real> &);
   AKANTU_GET_MACRO(LocalLowerBounds, local_lower_bounds, const Vector<Real> &);
   AKANTU_GET_MACRO(LocalUpperBounds, local_upper_bounds, const Vector<Real> &);
 
   /// get the connectivity Array for a given type
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Connectivity, connectivities, UInt);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(Connectivity, connectivities, UInt);
   AKANTU_GET_MACRO(Connectivities, connectivities,
                    const ElementTypeMapArray<UInt> &);
 
   /// get the number of element of a type in the mesh
   inline UInt getNbElement(const ElementType & type,
                            const GhostType & ghost_type = _not_ghost) const;
 
   /// get the number of element for a given ghost_type and a given dimension
   inline UInt getNbElement(const UInt spatial_dimension = _all_dimensions,
                            const GhostType & ghost_type = _not_ghost,
                            const ElementKind & kind = _ek_not_defined) const;
 
   // /// get the connectivity list either for the elements or the ghost elements
   // inline const ConnectivityTypeList &
   // getConnectivityTypeList(const GhostType & ghost_type = _not_ghost) const;
 
   /// compute the barycenter of a given element
   inline void getBarycenter(UInt element, const ElementType & type,
                             Real * barycenter,
                             GhostType ghost_type = _not_ghost) const;
   inline void getBarycenter(const Element & element,
                             Vector<Real> & barycenter) const;
 
   /// get the element connected to a subelement
   const Array<std::vector<Element>> &
   getElementToSubelement(const ElementType & el_type,
                          const GhostType & ghost_type = _not_ghost) const;
   /// get the element connected to a subelement
   Array<std::vector<Element>> &
   getElementToSubelement(const ElementType & el_type,
                          const GhostType & ghost_type = _not_ghost);
 
   /// get the subelement connected to an element
   const Array<Element> &
   getSubelementToElement(const ElementType & el_type,
                          const GhostType & ghost_type = _not_ghost) const;
   /// get the subelement connected to an element
   Array<Element> &
   getSubelementToElement(const ElementType & el_type,
                          const GhostType & ghost_type = _not_ghost);
 
   /// register a new ElementalTypeMap in the MeshData
   template <typename T>
   inline ElementTypeMapArray<T> & registerData(const std::string & data_name);
 
   template <typename T>
   inline bool hasData(const ID & data_name, const ElementType & el_type,
                       const GhostType & ghost_type = _not_ghost) const;
 
   /// get a name field associated to the mesh
   template <typename T>
   inline const Array<T> &
   getData(const ID & data_name, const ElementType & el_type,
           const GhostType & ghost_type = _not_ghost) const;
 
   /// get a name field associated to the mesh
   template <typename T>
   inline Array<T> & getData(const ID & data_name, const ElementType & el_type,
                             const GhostType & ghost_type = _not_ghost);
 
   /// get a name field associated to the mesh
   template <typename T>
   inline const ElementTypeMapArray<T> & getData(const ID & data_name) const;
 
   /// get a name field associated to the mesh
   template <typename T>
   inline ElementTypeMapArray<T> & getData(const ID & data_name);
 
   template <typename T>
   ElementTypeMap<UInt> getNbDataPerElem(ElementTypeMapArray<T> & array,
                                         const ElementKind & element_kind);
 
   template <typename T>
   dumper::Field * createFieldFromAttachedData(const std::string & field_id,
                                               const std::string & group_name,
                                               const ElementKind & element_kind);
 
   /// templated getter returning the pointer to data in MeshData (modifiable)
   template <typename T>
   inline Array<T> &
   getDataPointer(const std::string & data_name, const ElementType & el_type,
                  const GhostType & ghost_type = _not_ghost,
                  UInt nb_component = 1, bool size_to_nb_element = true,
                  bool resize_with_parent = false);
 
   /// Facets mesh accessor
   inline const Mesh & getMeshFacets() const;
   inline Mesh & getMeshFacets();
 
   /// Parent mesh accessor
   inline const Mesh & getMeshParent() const;
 
   inline bool isMeshFacets() const { return this->is_mesh_facets; }
 
   /// defines is the mesh is distributed or not
   inline bool isDistributed() const { return this->is_distributed; }
 
 #ifndef SWIG
   /// return the dumper from a group and and a dumper name
   DumperIOHelper & getGroupDumper(const std::string & dumper_name,
                                   const std::string & group_name);
 #endif
   /* ------------------------------------------------------------------------ */
   /* Wrappers on ElementClass functions                                       */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the number of nodes per element for a given element type
   static inline UInt getNbNodesPerElement(const ElementType & type);
 
   /// get the number of nodes per element for a given element type considered as
   /// a first order element
   static inline ElementType getP1ElementType(const ElementType & type);
 
   /// get the kind of the element type
   static inline ElementKind getKind(const ElementType & type);
 
   /// get spatial dimension of a type of element
   static inline UInt getSpatialDimension(const ElementType & type);
 
   /// get number of facets of a given element type
   static inline UInt getNbFacetsPerElement(const ElementType & type);
 
   /// get number of facets of a given element type
   static inline UInt getNbFacetsPerElement(const ElementType & type, UInt t);
 
   /// get local connectivity of a facet for a given facet type
   static inline MatrixProxy<UInt>
   getFacetLocalConnectivity(const ElementType & type, UInt t = 0);
 
   /// get connectivity of facets for a given element
   inline Matrix<UInt> getFacetConnectivity(const Element & element,
                                            UInt t = 0) const;
 
   /// get the number of type of the surface element associated to a given
   /// element type
   static inline UInt getNbFacetTypes(const ElementType & type, UInt t = 0);
 
   /// get the type of the surface element associated to a given element
   static inline ElementType getFacetType(const ElementType & type, UInt t = 0);
 
   /// get all the type of the surface element associated to a given element
   static inline VectorProxy<ElementType>
   getAllFacetTypes(const ElementType & type);
 
   /// get the number of nodes in the given element list
   static inline UInt getNbNodesPerElementList(const Array<Element> & elements);
 
   /* ------------------------------------------------------------------------ */
   /* Element type Iterator                                                    */
   /* ------------------------------------------------------------------------ */
   using type_iterator = ElementTypeMapArray<UInt, ElementType>::type_iterator;
   using ElementTypesIteratorHelper =
       ElementTypeMapArray<UInt, ElementType>::ElementTypesIteratorHelper;
 
   template <typename... pack>
   ElementTypesIteratorHelper elementTypes(pack &&... _pack) const;
 
   inline type_iterator firstType(UInt dim = _all_dimensions,
                                  GhostType ghost_type = _not_ghost,
                                  ElementKind kind = _ek_regular) const {
     return connectivities.firstType(dim, ghost_type, kind);
   }
 
   inline type_iterator lastType(UInt dim = _all_dimensions,
                                 GhostType ghost_type = _not_ghost,
                                 ElementKind kind = _ek_regular) const {
     return connectivities.lastType(dim, ghost_type, kind);
   }
 
   AKANTU_GET_MACRO(ElementSynchronizer, *element_synchronizer,
                    const ElementSynchronizer &);
   AKANTU_GET_MACRO_NOT_CONST(ElementSynchronizer, *element_synchronizer,
                              ElementSynchronizer &);
   AKANTU_GET_MACRO(NodeSynchronizer, *node_synchronizer,
                    const NodeSynchronizer &);
   AKANTU_GET_MACRO_NOT_CONST(NodeSynchronizer, *node_synchronizer,
                              NodeSynchronizer &);
 
   // AKANTU_GET_MACRO_NOT_CONST(Communicator, *communicator, StaticCommunicator
   // &);
+#ifndef SWIG
   AKANTU_GET_MACRO(Communicator, *communicator, const auto &);
+#endif
   /* ------------------------------------------------------------------------ */
   /* Private methods for friends                                              */
   /* ------------------------------------------------------------------------ */
 private:
   friend class MeshAccessor;
 
   //#if defined(AKANTU_COHESIVE_ELEMENT)
   //  friend class CohesiveElementInserter;
   //#endif
 
   //#if defined(AKANTU_IGFEM)
   //  template <UInt dim> friend class MeshIgfemSphericalGrowingGel;
   //#endif
 
   AKANTU_GET_MACRO(NodesPointer, *nodes, Array<Real> &);
 
   /// get a pointer to the nodes_global_ids Array<UInt> and create it if
   /// necessary
   inline Array<UInt> & getNodesGlobalIdsPointer();
 
   /// get a pointer to the nodes_type Array<Int> and create it if necessary
   inline Array<NodeType> & getNodesTypePointer();
 
   /// get a pointer to the connectivity Array for the given type and create it
   /// if necessary
   inline Array<UInt> &
   getConnectivityPointer(const ElementType & type,
                          const GhostType & ghost_type = _not_ghost);
 
   /// get the ghost element counter
   inline Array<UInt> &
   getGhostsCounters(const ElementType & type,
                     const GhostType & ghost_type = _ghost) {
     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 Array<std::vector<Element>> &
   getElementToSubelementPointer(const ElementType & type,
                                 const GhostType & ghost_type = _not_ghost);
 
   /// get a pointer to the subelement_to_element Array for the given type and
   /// create it if necessary
   inline Array<Element> &
   getSubelementToElementPointer(const ElementType & type,
                                 const GhostType & ghost_type = _not_ghost);
 
   AKANTU_GET_MACRO_NOT_CONST(MeshData, mesh_data, MeshData &);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// array of the nodes coordinates
   std::shared_ptr<Array<Real>> nodes;
 
   /// global node ids
   std::unique_ptr<Array<UInt>> nodes_global_ids;
 
   /// node type,  -3 pure ghost, -2  master for the  node, -1 normal node,  i in
   /// [0-N] slave node and master is proc i
   Array<NodeType> nodes_type;
 
   /// global number of nodes;
   UInt nb_global_nodes{0};
 
   /// all class of elements present in this mesh (for heterogenous meshes)
   ElementTypeMapArray<UInt> connectivities;
 
   /// count the references on ghost elements
   ElementTypeMapArray<UInt> ghosts_counters;
 
   /// map to normals for all class of elements present in this mesh
   ElementTypeMapArray<Real> normals;
 
   /// list of all existing types in the mesh
   // ConnectivityTypeList type_set;
 
   /// the spatial dimension of this mesh
   UInt spatial_dimension{0};
 
   /// types offsets
   // Array<UInt> types_offsets;
 
   // /// list of all existing types in the mesh
   // ConnectivityTypeList ghost_type_set;
   // /// ghost types offsets
   // Array<UInt> ghost_types_offsets;
 
   /// min of coordinates
   Vector<Real> lower_bounds;
   /// max of coordinates
   Vector<Real> upper_bounds;
   /// size covered by the mesh on each direction
   Vector<Real> size;
 
   /// local min of coordinates
   Vector<Real> local_lower_bounds;
   /// local max of coordinates
   Vector<Real> local_upper_bounds;
 
   /// 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};
 
   /// Communicator on which mesh is distributed
   const Communicator * communicator;
 
   /// Element synchronizer
   std::unique_ptr<ElementSynchronizer> element_synchronizer;
 
   /// Node synchronizer
   std::unique_ptr<NodeSynchronizer> node_synchronizer;
 
   using NodesToElements = std::vector<std::unique_ptr<std::set<Element>>>;
 
   /// This info is stored to simplify the dynamic changes
   NodesToElements nodes_to_elements;
 };
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream, const Mesh & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 /* Inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 #include "element_type_map_tmpl.hh"
 #include "mesh_inline_impl.cc"
 
 #endif /* __AKANTU_MESH_HH__ */
diff --git a/src/mesh/mesh_data.hh b/src/mesh/mesh_data.hh
index 41f2e445c..873808c18 100644
--- a/src/mesh/mesh_data.hh
+++ b/src/mesh/mesh_data.hh
@@ -1,150 +1,150 @@
 /**
  * @file   mesh_data.hh
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri May 03 2013
  * @date last modification: Thu Nov 05 2015
  *
  * @brief  Stores generic data loaded from the mesh file
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MESH_DATA_HH__
 #define __AKANTU_MESH_DATA_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "aka_memory.hh"
 #include "element_type_map.hh"
 #include <map>
 #include <string>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 #define AKANTU_MESH_DATA_TYPES                                                 \
   ((_tc_int, Int))((_tc_uint, UInt))((_tc_real, Real))(                        \
       (_tc_element, Element))((_tc_std_string, std::string))(                  \
       (_tc_std_vector_element, std::vector<Element>))
 
 #define AKANTU_MESH_DATA_TUPLE_FIRST_ELEM(s, data, elem)                       \
   BOOST_PP_TUPLE_ELEM(2, 0, elem)
 enum MeshDataTypeCode : int {
   BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(AKANTU_MESH_DATA_TUPLE_FIRST_ELEM, ,
                                            AKANTU_MESH_DATA_TYPES)),
   _tc_unknown
 };
 
 class MeshData : public Memory {
 
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 private:
-  typedef MeshDataTypeCode TypeCode;
+  using TypeCode = MeshDataTypeCode;
   typedef std::map<std::string, ElementTypeMapBase *> ElementalDataMap;
-  typedef std::vector<std::string> StringVector;
+  using StringVector = std::vector<std::string>;
   typedef std::map<std::string, TypeCode> TypeCodeMap;
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   MeshData(const ID & id = "mesh_data", const ID & parent_id = "",
            const MemoryID & memory_id = 0);
   ~MeshData() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods and accessors                                                    */
   /* ------------------------------------------------------------------------ */
 public:
   ///  Register new elemental data (and alloc data) with check if the name is
   ///  new
   template <typename T> void registerElementalData(const ID & name);
   inline void registerElementalData(const ID & name, TypeCode type);
 
   /// Get an existing elemental data array
   template <typename T>
   bool hasDataArray(const ID & data_name, const ElementType & el_type,
                     const GhostType & ghost_type = _not_ghost) const;
 
   /// Get an existing elemental data array
   template <typename T>
   const Array<T> &
   getElementalDataArray(const ID & data_name, const ElementType & el_type,
                         const GhostType & ghost_type = _not_ghost) const;
   template <typename T>
   Array<T> & getElementalDataArray(const ID & data_name,
                                    const ElementType & el_type,
                                    const GhostType & ghost_type = _not_ghost);
 
   /// Get an elemental data array, if it does not exist: allocate it
   template <typename T>
   Array<T> &
   getElementalDataArrayAlloc(const ID & data_name, const ElementType & el_type,
                              const GhostType & ghost_type = _not_ghost,
                              UInt nb_component = 1);
 
   /// get the names of the data stored in elemental_data
   inline void getTagNames(StringVector & tags, const ElementType & type,
                           const GhostType & ghost_type = _not_ghost) const;
 
   /// get the type of the data stored in elemental_data
   template <typename T> TypeCode getTypeCode() const;
   inline TypeCode getTypeCode(const ID & name) const;
 
   template <typename T>
   inline UInt getNbComponentTemplated(const ID & name,
                                       const ElementType & el_type,
                                       const GhostType & ghost_type) const;
   inline UInt getNbComponent(const ID & name, const ElementType & el_type,
                              const GhostType & ghost_type = _not_ghost) const;
 
   /// Get an existing elemental data
   template <typename T>
   const ElementTypeMapArray<T> & getElementalData(const ID & name) const;
   template <typename T>
   ElementTypeMapArray<T> & getElementalData(const ID & name);
 
 private:
   ///  Register new elemental data (add alloc data)
   template <typename T>
   ElementTypeMapArray<T> * allocElementalData(const ID & name);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// Map when elemental data is stored as ElementTypeMap
   ElementalDataMap elemental_data;
   /// Map when elementalType of the data stored in elemental_data
   TypeCodeMap typecode_map;
 };
 
 } // akantu
 
 #include "mesh_data_tmpl.hh"
 #undef AKANTU_MESH_DATA_TUPLE_FIRST_ELEM
 
 #endif /* __AKANTU_MESH_DATA_HH__ */
diff --git a/src/mesh/mesh_data_tmpl.hh b/src/mesh/mesh_data_tmpl.hh
index 887e3f680..d915f1b07 100644
--- a/src/mesh/mesh_data_tmpl.hh
+++ b/src/mesh/mesh_data_tmpl.hh
@@ -1,273 +1,272 @@
 /**
  * @file   mesh_data_tmpl.hh
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri May 03 2013
  * @date last modification: Thu Nov 05 2015
  *
  * @brief  Stores generic data loaded from the mesh file
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "mesh_data.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MESH_DATA_TMPL_HH__
 #define __AKANTU_MESH_DATA_TMPL_HH__
 
 namespace akantu {
 
 #define MESH_DATA_GET_TYPE(r, data, type)                                      \
   template <>                                                                  \
   inline MeshDataTypeCode                                                      \
   MeshData::getTypeCode<BOOST_PP_TUPLE_ELEM(2, 1, type)>() const {             \
     return BOOST_PP_TUPLE_ELEM(2, 0, type);                                    \
   }
 
 /* -------------------------------------------------------------------------- */
 // get the type of the data stored in elemental_data
 template <typename T> inline MeshDataTypeCode MeshData::getTypeCode() const {
   AKANTU_DEBUG_ERROR("Type " << debug::demangle(typeid(T).name())
                              << "not implemented by MeshData.");
 }
 
 /* -------------------------------------------------------------------------- */
 BOOST_PP_SEQ_FOR_EACH(MESH_DATA_GET_TYPE, void, AKANTU_MESH_DATA_TYPES)
 #undef MESH_DATA_GET_TYPE
 
 inline MeshDataTypeCode MeshData::getTypeCode(const ID & name) const {
-  TypeCodeMap::const_iterator it = typecode_map.find(name);
+  auto it = typecode_map.find(name);
   if (it == typecode_map.end())
     AKANTU_EXCEPTION("No dataset named " << name << " found.");
   return it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 //  Register new elemental data templated (and alloc data) with check if the
 //  name is new
 template <typename T> void MeshData::registerElementalData(const ID & name) {
-  ElementalDataMap::iterator it = elemental_data.find(name);
+  auto it = elemental_data.find(name);
   if (it == elemental_data.end()) {
     allocElementalData<T>(name);
   } else {
     AKANTU_DEBUG_INFO("Data named " << name << " already registered.");
   }
 }
 
 /* -------------------------------------------------------------------------- */
   //  Register new elemental data of a given MeshDataTypeCode with check if the
   //  name is new
 #define AKANTU_MESH_DATA_CASE_MACRO(r, name, elem)                             \
   case BOOST_PP_TUPLE_ELEM(2, 0, elem): {                                      \
     registerElementalData<BOOST_PP_TUPLE_ELEM(2, 1, elem)>(name);              \
     break;                                                                     \
   }
 
 inline void MeshData::registerElementalData(const ID & name,
                                             MeshDataTypeCode type) {
   switch (type) {
     BOOST_PP_SEQ_FOR_EACH(AKANTU_MESH_DATA_CASE_MACRO, name,
                           AKANTU_MESH_DATA_TYPES)
   default:
     AKANTU_DEBUG_ERROR("Type " << type << "not implemented by MeshData.");
   }
 }
 #undef AKANTU_MESH_DATA_CASE_MACRO
 
 /* -------------------------------------------------------------------------- */
 /// Register new elemental data (and alloc data)
 template <typename T>
 ElementTypeMapArray<T> * MeshData::allocElementalData(const ID & name) {
-  ElementTypeMapArray<T> * dataset =
-      new ElementTypeMapArray<T>(name, id, memory_id);
+  auto * dataset = new ElementTypeMapArray<T>(name, id, memory_id);
   elemental_data[name] = dataset;
   typecode_map[name] = getTypeCode<T>();
   return dataset;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 const ElementTypeMapArray<T> &
 MeshData::getElementalData(const ID & name) const {
-  ElementalDataMap::const_iterator it = elemental_data.find(name);
+  auto it = elemental_data.find(name);
   if (it == elemental_data.end())
     AKANTU_EXCEPTION("No dataset named " << name << " found.");
   return dynamic_cast<const ElementTypeMapArray<T> &>(*(it->second));
 }
 
 /* -------------------------------------------------------------------------- */
 // Get an existing elemental data
 template <typename T>
 ElementTypeMapArray<T> & MeshData::getElementalData(const ID & name) {
-  ElementalDataMap::iterator it = elemental_data.find(name);
+  auto it = elemental_data.find(name);
   if (it == elemental_data.end())
     AKANTU_EXCEPTION("No dataset named " << name << " found.");
   return dynamic_cast<ElementTypeMapArray<T> &>(*(it->second));
 }
 
 /* -------------------------------------------------------------------------- */
 // Get an existing elemental data array for an element type
 template <typename T>
 bool MeshData::hasDataArray(const ID & name, const ElementType & elem_type,
                             const GhostType & ghost_type) const {
   auto it = elemental_data.find(name);
   if (it == elemental_data.end())
     return false;
 
   auto & elem_map = dynamic_cast<const ElementTypeMapArray<T> &>(*(it->second));
   return elem_map.exists(elem_type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 // Get an existing elemental data array for an element type
 template <typename T>
 const Array<T> &
 MeshData::getElementalDataArray(const ID & name, const ElementType & elem_type,
                                 const GhostType & ghost_type) const {
-  ElementalDataMap::const_iterator it = elemental_data.find(name);
+  auto it = elemental_data.find(name);
   if (it == elemental_data.end()) {
     AKANTU_EXCEPTION("Data named " << name
                                    << " not registered for type: " << elem_type
                                    << " - ghost_type:" << ghost_type << "!");
   }
   return dynamic_cast<const ElementTypeMapArray<T> &>(*(it->second))(
       elem_type, ghost_type);
 }
 
 template <typename T>
 Array<T> & MeshData::getElementalDataArray(const ID & name,
                                            const ElementType & elem_type,
                                            const GhostType & ghost_type) {
-  ElementalDataMap::iterator it = elemental_data.find(name);
+  auto it = elemental_data.find(name);
   if (it == elemental_data.end()) {
     AKANTU_EXCEPTION("Data named " << name
                                    << " not registered for type: " << elem_type
                                    << " - ghost_type:" << ghost_type << "!");
   }
   return dynamic_cast<ElementTypeMapArray<T> &>(*(it->second))(elem_type,
                                                                ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 // Get an elemental data array, if it does not exist: allocate it
 template <typename T>
 Array<T> & MeshData::getElementalDataArrayAlloc(const ID & name,
                                                 const ElementType & elem_type,
                                                 const GhostType & ghost_type,
                                                 UInt nb_component) {
-  ElementalDataMap::iterator it = elemental_data.find(name);
+  auto it = elemental_data.find(name);
   ElementTypeMapArray<T> * dataset;
   if (it == elemental_data.end()) {
     dataset = allocElementalData<T>(name);
   } else {
     dataset = dynamic_cast<ElementTypeMapArray<T> *>(it->second);
   }
   AKANTU_DEBUG_ASSERT(
       getTypeCode<T>() == typecode_map.find(name)->second,
       "Function getElementalDataArrayAlloc called with the wrong type!");
   if (!(dataset->exists(elem_type, ghost_type))) {
     dataset->alloc(0, nb_component, elem_type, ghost_type);
   }
   return (*dataset)(elem_type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 #define AKANTU_MESH_DATA_CASE_MACRO(r, name, elem)                             \
   case BOOST_PP_TUPLE_ELEM(2, 0, elem): {                                      \
     nb_comp = getNbComponentTemplated<BOOST_PP_TUPLE_ELEM(2, 1, elem)>(        \
         name, el_type, ghost_type);                                            \
     break;                                                                     \
   }
 
 inline UInt MeshData::getNbComponent(const ID & name,
                                      const ElementType & el_type,
                                      const GhostType & ghost_type) const {
-  TypeCodeMap::const_iterator it = typecode_map.find(name);
+  auto it = typecode_map.find(name);
   UInt nb_comp(0);
   if (it == typecode_map.end()) {
     AKANTU_EXCEPTION("Could not determine the type held in dataset "
                      << name << " for type: " << el_type
                      << " - ghost_type:" << ghost_type << ".");
   }
   MeshDataTypeCode type = it->second;
   switch (type) {
     BOOST_PP_SEQ_FOR_EACH(AKANTU_MESH_DATA_CASE_MACRO, name,
                           AKANTU_MESH_DATA_TYPES)
   default:
     AKANTU_DEBUG_ERROR(
         "Could not call the correct instance of getNbComponentTemplated.");
     break;
   }
   return nb_comp;
 }
 #undef AKANTU_MESH_DATA_CASE_MACRO
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline UInt
 MeshData::getNbComponentTemplated(const ID & name, const ElementType & el_type,
                                   const GhostType & ghost_type) const {
   return getElementalDataArray<T>(name, el_type, ghost_type).getNbComponent();
 }
 
 /* -------------------------------------------------------------------------- */
 // get the names of the data stored in elemental_data
 #define AKANTU_MESH_DATA_CASE_MACRO(r, name, elem)                             \
   case BOOST_PP_TUPLE_ELEM(2, 0, elem): {                                      \
     ElementTypeMapArray<BOOST_PP_TUPLE_ELEM(2, 1, elem)> * dataset;            \
     dataset =                                                                  \
         dynamic_cast<ElementTypeMapArray<BOOST_PP_TUPLE_ELEM(2, 1, elem)> *>(  \
             it->second);                                                       \
     exists = dataset->exists(el_type, ghost_type);                             \
     break;                                                                     \
   }
 
 inline void MeshData::getTagNames(StringVector & tags,
                                   const ElementType & el_type,
                                   const GhostType & ghost_type) const {
   tags.clear();
   bool exists(false);
 
-  ElementalDataMap::const_iterator it = elemental_data.begin();
-  ElementalDataMap::const_iterator it_end = elemental_data.end();
+  auto it = elemental_data.begin();
+  auto it_end = elemental_data.end();
   for (; it != it_end; ++it) {
     MeshDataTypeCode type = getTypeCode(it->first);
     switch (type) {
       BOOST_PP_SEQ_FOR_EACH(AKANTU_MESH_DATA_CASE_MACRO, ,
                             AKANTU_MESH_DATA_TYPES)
     default:
       AKANTU_DEBUG_ERROR(
           "Could not determine the proper type to (dynamic-)cast.");
       break;
     }
     if (exists) {
       tags.push_back(it->first);
     }
   }
 }
 #undef AKANTU_MESH_DATA_CASE_MACRO
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
 
 #endif /* __AKANTU_MESH_DATA_TMPL_HH__ */
diff --git a/src/mesh/mesh_events.hh b/src/mesh/mesh_events.hh
index 77dc78da3..2bbdb58b9 100644
--- a/src/mesh/mesh_events.hh
+++ b/src/mesh/mesh_events.hh
@@ -1,187 +1,189 @@
 /**
  * @file   mesh_events.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Feb 20 2015
  * @date last modification: Mon Dec 07 2015
  *
  * @brief  Classes corresponding to mesh events type
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
+#include <utility>
+
 #include "aka_array.hh"
 #include "element.hh"
 #include "element_type_map.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MESH_EVENTS_HH__
 #define __AKANTU_MESH_EVENTS_HH__
 
 
 namespace akantu {
 
 /// akantu::MeshEvent is the base event for meshes
 template <class Entity> class MeshEvent {
 public:
-  virtual ~MeshEvent() {}
+  virtual ~MeshEvent() = default;
   /// Get the list of entity modified by the event nodes or elements
   const Array<Entity> & getList() const { return list; }
   /// Get the list of entity modified by the event nodes or elements
   Array<Entity> & getList() { return list; }
 
 protected:
   Array<Entity> list;
 };
 
 class Mesh;
 
 /// akantu::MeshEvent related to new nodes in the mesh
 class NewNodesEvent : public MeshEvent<UInt> {
 public:
-  ~NewNodesEvent() override{};
+  ~NewNodesEvent() override = default;
 };
 
 /// akantu::MeshEvent related to nodes removed from the mesh
 class RemovedNodesEvent : public MeshEvent<UInt> {
 public:
-  ~RemovedNodesEvent() override{};
+  ~RemovedNodesEvent() override = default;
   inline RemovedNodesEvent(const Mesh & mesh);
   /// Get the new numbering following suppression of nodes from nodes arrays
   AKANTU_GET_MACRO_NOT_CONST(NewNumbering, new_numbering, Array<UInt> &);
   /// Get the new numbering following suppression of nodes from nodes arrays
   AKANTU_GET_MACRO(NewNumbering, new_numbering, const Array<UInt> &);
 
 private:
   Array<UInt> new_numbering;
 };
 
 /// akantu::MeshEvent related to new elements in the mesh
 class NewElementsEvent : public MeshEvent<Element> {
 public:
-  ~NewElementsEvent() override{};
+  ~NewElementsEvent() override = default;
 };
 
 /// akantu::MeshEvent related to elements removed from the mesh
 class RemovedElementsEvent : public MeshEvent<Element> {
 public:
-  ~RemovedElementsEvent() override{};
+  ~RemovedElementsEvent() override = default;
   inline RemovedElementsEvent(const Mesh & mesh,
-                              ID new_numbering_id = "new_numbering");
+                              const ID & new_numbering_id = "new_numbering");
   /// Get the new numbering following suppression of elements from elements
   /// arrays
   AKANTU_GET_MACRO(NewNumbering, new_numbering,
                    const ElementTypeMapArray<UInt> &);
   /// Get the new numbering following suppression of elements from elements
   /// arrays
   AKANTU_GET_MACRO_NOT_CONST(NewNumbering, new_numbering,
                              ElementTypeMapArray<UInt> &);
   /// Get the new numbering following suppression of elements from elements
   /// arrays
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(NewNumbering, new_numbering, UInt);
   /// Get the new numbering following suppression of elements from elements
   /// arrays
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(NewNumbering, new_numbering, UInt);
 
 protected:
   ElementTypeMapArray<UInt> new_numbering;
 };
 
 /// akantu::MeshEvent for element that changed in some sort, can be seen as a
 /// combination of removed and added elements
 class ChangedElementsEvent : public RemovedElementsEvent {
 public:
-  ~ChangedElementsEvent() override{};
+  ~ChangedElementsEvent() override = default;
   inline ChangedElementsEvent(
       const Mesh & mesh, ID new_numbering_id = "changed_event:new_numbering")
-      : RemovedElementsEvent(mesh, new_numbering_id){};
+      : RemovedElementsEvent(mesh, std::move(new_numbering_id)){};
   AKANTU_GET_MACRO(ListOld, list, const Array<Element> &);
   AKANTU_GET_MACRO_NOT_CONST(ListOld, list, Array<Element> &);
   AKANTU_GET_MACRO(ListNew, new_list, const Array<Element> &);
   AKANTU_GET_MACRO_NOT_CONST(ListNew, new_list, Array<Element> &);
 
 protected:
   Array<Element> new_list;
 };
 
 /* -------------------------------------------------------------------------- */
 
 class MeshEventHandler {
 public:
-  virtual ~MeshEventHandler(){};
+  virtual ~MeshEventHandler() = default;
   /* ------------------------------------------------------------------------ */
   /* Internal code                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// send a akantu::NewNodesEvent
   inline void sendEvent(const NewNodesEvent & event) {
     onNodesAdded(event.getList(), event);
   }
   /// send a akantu::RemovedNodesEvent
   inline void sendEvent(const RemovedNodesEvent & event) {
     onNodesRemoved(event.getList(), event.getNewNumbering(), event);
   }
   /// send a akantu::NewElementsEvent
   inline void sendEvent(const NewElementsEvent & event) {
     onElementsAdded(event.getList(), event);
   }
   /// send a akantu::RemovedElementsEvent
   inline void sendEvent(const RemovedElementsEvent & event) {
     onElementsRemoved(event.getList(), event.getNewNumbering(), event);
   }
   /// send a akantu::ChangedElementsEvent
   inline void sendEvent(const ChangedElementsEvent & event) {
     onElementsChanged(event.getListOld(), event.getListNew(),
                       event.getNewNumbering(), event);
   }
   template <class EventHandler> friend class EventHandlerManager;
 
   /* ------------------------------------------------------------------------ */
   /* Interface                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// function to implement to react on  akantu::NewNodesEvent
   virtual void onNodesAdded(const Array<UInt> & nodes_list,
                             const NewNodesEvent & event) = 0;
   /// function to implement to react on  akantu::RemovedNodesEvent
   virtual void onNodesRemoved(const Array<UInt> & nodes_list,
                               const Array<UInt> & new_numbering,
                               const RemovedNodesEvent & event) = 0;
   /// function to implement to react on  akantu::NewElementsEvent
   virtual void onElementsAdded(const Array<Element> & elements_list,
                                const NewElementsEvent & event) = 0;
   /// function to implement to react on  akantu::RemovedElementsEvent
   virtual void
   onElementsRemoved(const Array<Element> & elements_list,
                     const ElementTypeMapArray<UInt> & new_numbering,
                     const RemovedElementsEvent & event) = 0;
   /// function to implement to react on  akantu::ChangedElementsEvent
   virtual void
   onElementsChanged(const Array<Element> & old_elements_list,
                     const Array<Element> & new_elements_list,
                     const ElementTypeMapArray<UInt> & new_numbering,
                     const ChangedElementsEvent & event) = 0;
 };
 
 } // akantu
 
 #endif /* __AKANTU_MESH_EVENTS_HH__ */
diff --git a/src/mesh/mesh_inline_impl.cc b/src/mesh/mesh_inline_impl.cc
index df8fe3c66..a8bc5554f 100644
--- a/src/mesh/mesh_inline_impl.cc
+++ b/src/mesh/mesh_inline_impl.cc
@@ -1,636 +1,636 @@
 /**
  * @file   mesh_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@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: Thu Jan 21 2016
  *
  * @brief  Implementation of the inline functions of the mesh class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_iterators.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_COHESIVE_ELEMENT)
 #include "cohesive_element.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MESH_INLINE_IMPL_CC__
 #define __AKANTU_MESH_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 inline ElementKind Element::kind() const { return Mesh::getKind(type); }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 template <typename... pack>
 Mesh::ElementTypesIteratorHelper Mesh::elementTypes(pack &&... _pack) const {
   return connectivities.elementTypes(_pack...);
 }
 
 /* -------------------------------------------------------------------------- */
 inline RemovedNodesEvent::RemovedNodesEvent(const Mesh & mesh)
     : new_numbering(mesh.getNbNodes(), 1, "new_numbering") {}
 
 /* -------------------------------------------------------------------------- */
 inline RemovedElementsEvent::RemovedElementsEvent(const Mesh & mesh,
-                                                  ID new_numbering_id)
+                                                  const ID & new_numbering_id)
     : new_numbering(new_numbering_id, mesh.getID(), mesh.getMemoryID()) {}
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void Mesh::sendEvent<NewElementsEvent>(NewElementsEvent & event) {
   this->nodes_to_elements.resize(nodes->size());
   for (const auto & elem : event.getList()) {
     const Array<UInt> & conn = connectivities(elem.type, elem.ghost_type);
 
     UInt nb_nodes_per_elem = this->getNbNodesPerElement(elem.type);
 
     for (UInt n = 0; n < nb_nodes_per_elem; ++n) {
       UInt node = conn(elem.element, n);
       if (not nodes_to_elements[node])
         nodes_to_elements[node] = std::make_unique<std::set<Element>>();
       nodes_to_elements[node]->insert(elem);
     }
   }
 
   EventHandlerManager<MeshEventHandler>::sendEvent(event);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> inline void Mesh::sendEvent<NewNodesEvent>(NewNodesEvent & event) {
   this->computeBoundingBox();
 
   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)
     this->removeNodesFromArray(*nodes_global_ids, new_numbering);
   if (nodes_type.size() != 0)
     this->removeNodesFromArray(nodes_type, 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();
 
     UInt new_nb_nodes = 0;
     for (auto new_i : new_numbering) {
       if (new_i != UInt(-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<UInt> & new_numbering) {
   Array<T> tmp(vect.size(), vect.getNbComponent());
   UInt nb_component = vect.getNbComponent();
   UInt new_nb_nodes = 0;
   for (UInt i = 0; i < new_numbering.size(); ++i) {
     UInt new_i = new_numbering(i);
     if (new_i != UInt(-1)) {
       T * to_copy = vect.storage() + i * nb_component;
       std::uninitialized_copy(to_copy, to_copy + nb_component,
                               tmp.storage() + new_i * nb_component);
       ++new_nb_nodes;
     }
   }
 
   tmp.resize(new_nb_nodes);
   vect.copy(tmp);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<UInt> & Mesh::getNodesGlobalIdsPointer() {
   AKANTU_DEBUG_IN();
   if (not nodes_global_ids) {
     nodes_global_ids = std::make_unique<Array<UInt>>(
         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;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<NodeType> & Mesh::getNodesTypePointer() {
   AKANTU_DEBUG_IN();
   if (nodes_type.size() == 0) {
     nodes_type.resize(nodes->size());
     nodes_type.set(_nt_normal);
   }
 
   AKANTU_DEBUG_OUT();
   return nodes_type;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<UInt> &
 Mesh::getConnectivityPointer(const ElementType & type,
                              const GhostType & ghost_type) {
   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 Array<std::vector<Element>> &
 Mesh::getElementToSubelementPointer(const ElementType & type,
                                     const GhostType & ghost_type) {
   return getDataPointer<std::vector<Element>>("element_to_subelement", type,
                                               ghost_type, 1, true);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<Element> &
 Mesh::getSubelementToElementPointer(const ElementType & type,
                                     const GhostType & ghost_type) {
   auto & array = getDataPointer<Element>("subelement_to_element", type, ghost_type,
                                  getNbFacetsPerElement(type), true,
                                  is_mesh_facets);
   array.set(ElementNull);
   return array;
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Array<std::vector<Element>> &
 Mesh::getElementToSubelement(const ElementType & type,
                              const GhostType & ghost_type) const {
   return getData<std::vector<Element>>("element_to_subelement", type,
                                        ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<std::vector<Element>> &
 Mesh::getElementToSubelement(const ElementType & type,
                              const GhostType & ghost_type) {
   return getData<std::vector<Element>>("element_to_subelement", type,
                                        ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Array<Element> &
 Mesh::getSubelementToElement(const ElementType & type,
                              const GhostType & ghost_type) const {
   return getData<Element>("subelement_to_element", type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<Element> &
 Mesh::getSubelementToElement(const ElementType & type,
                              const GhostType & ghost_type) {
   return getData<Element>("subelement_to_element", type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline Array<T> &
 Mesh::getDataPointer(const ID & data_name, const ElementType & el_type,
                      const GhostType & ghost_type, UInt nb_component,
                      bool size_to_nb_element, bool resize_with_parent) {
   Array<T> & tmp = mesh_data.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));
   } else {
     tmp.resize(0);
   }
 
   return tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline bool Mesh::hasData(const ID & data_name, const ElementType & el_type,
                           const GhostType & ghost_type) const {
   return mesh_data.hasDataArray<T>(data_name, el_type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline const Array<T> & Mesh::getData(const ID & data_name,
                                       const ElementType & el_type,
                                       const GhostType & ghost_type) const {
   return mesh_data.getElementalDataArray<T>(data_name, el_type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline Array<T> & Mesh::getData(const ID & data_name,
                                 const ElementType & el_type,
                                 const GhostType & ghost_type) {
   return mesh_data.getElementalDataArray<T>(data_name, el_type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline const ElementTypeMapArray<T> &
 Mesh::getData(const ID & data_name) const {
   return mesh_data.getElementalData<T>(data_name);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline ElementTypeMapArray<T> & Mesh::getData(const ID & data_name) {
   return mesh_data.getElementalData<T>(data_name);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline ElementTypeMapArray<T> & Mesh::registerData(const ID & data_name) {
   this->mesh_data.registerElementalData<T>(data_name);
   return this->getData<T>(data_name);
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbElement(const ElementType & type,
                                const GhostType & ghost_type) const {
   try {
 
     const Array<UInt> & conn = connectivities(type, ghost_type);
     return conn.size();
   } catch (...) {
     return 0;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbElement(const UInt spatial_dimension,
                                const GhostType & ghost_type,
                                const ElementKind & kind) const {
   AKANTU_DEBUG_ASSERT(spatial_dimension <= 3 || spatial_dimension == UInt(-1),
                       "spatial_dimension is " << spatial_dimension
                                               << " and is greater than 3 !");
   UInt nb_element = 0;
 
   for (auto type : elementTypes(spatial_dimension, ghost_type, kind))
     nb_element += getNbElement(type, ghost_type);
 
   return nb_element;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Mesh::getBarycenter(UInt element, const ElementType & type,
                                 Real * barycenter, GhostType ghost_type) const {
   UInt * conn_val = getConnectivity(type, ghost_type).storage();
   UInt nb_nodes_per_element = getNbNodesPerElement(type);
 
-  Real * local_coord = new Real[spatial_dimension * nb_nodes_per_element];
+  auto * local_coord = new Real[spatial_dimension * nb_nodes_per_element];
 
   UInt offset = element * nb_nodes_per_element;
   for (UInt n = 0; n < nb_nodes_per_element; ++n) {
     memcpy(local_coord + n * spatial_dimension,
            nodes->storage() + conn_val[offset + n] * spatial_dimension,
            spatial_dimension * sizeof(Real));
   }
 
   Math::barycenter(local_coord, nb_nodes_per_element, spatial_dimension,
                    barycenter);
 
   delete[] local_coord;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Mesh::getBarycenter(const Element & element,
                                 Vector<Real> & barycenter) const {
   getBarycenter(element.element, element.type, barycenter.storage(),
                 element.ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbNodesPerElement(const ElementType & type) {
   UInt nb_nodes_per_element = 0;
 #define GET_NB_NODES_PER_ELEMENT(type)                                         \
   nb_nodes_per_element = ElementClass<type>::getNbNodesPerElement()
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_NB_NODES_PER_ELEMENT);
 #undef GET_NB_NODES_PER_ELEMENT
   return nb_nodes_per_element;
 }
 
 /* -------------------------------------------------------------------------- */
 inline ElementType Mesh::getP1ElementType(const ElementType & type) {
   ElementType p1_type = _not_defined;
 #define GET_P1_TYPE(type) p1_type = ElementClass<type>::getP1ElementType()
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_P1_TYPE);
 #undef GET_P1_TYPE
   return p1_type;
 }
 
 /* -------------------------------------------------------------------------- */
 inline ElementKind Mesh::getKind(const ElementType & type) {
   ElementKind kind = _ek_not_defined;
 #define GET_KIND(type) kind = ElementClass<type>::getKind()
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_KIND);
 #undef GET_KIND
   return kind;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getSpatialDimension(const ElementType & type) {
   UInt spatial_dimension = 0;
 #define GET_SPATIAL_DIMENSION(type)                                            \
   spatial_dimension = ElementClass<type>::getSpatialDimension()
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_SPATIAL_DIMENSION);
 #undef GET_SPATIAL_DIMENSION
 
   return spatial_dimension;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbFacetTypes(const ElementType & type,
                                   __attribute__((unused)) UInt t) {
   UInt nb = 0;
 #define GET_NB_FACET_TYPE(type) nb = ElementClass<type>::getNbFacetTypes()
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_NB_FACET_TYPE);
 #undef GET_NB_FACET_TYPE
   return nb;
 }
 
 /* -------------------------------------------------------------------------- */
 inline ElementType Mesh::getFacetType(const ElementType & type, UInt t) {
   ElementType surface_type = _not_defined;
 #define GET_FACET_TYPE(type) surface_type = ElementClass<type>::getFacetType(t)
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_FACET_TYPE);
 #undef GET_FACET_TYPE
 
   return surface_type;
 }
 
 /* -------------------------------------------------------------------------- */
 inline VectorProxy<ElementType>
 Mesh::getAllFacetTypes(const ElementType & type) {
 #define GET_FACET_TYPE(type)                                                   \
   UInt nb = ElementClass<type>::getNbFacetTypes();                             \
   ElementType * elt_ptr =                                                      \
       const_cast<ElementType *>(ElementClass<type>::getFacetTypeInternal());   \
   return VectorProxy<ElementType>(elt_ptr, nb);
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_FACET_TYPE);
 #undef GET_FACET_TYPE
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbFacetsPerElement(const ElementType & type) {
   AKANTU_DEBUG_IN();
 
   UInt n_facet = 0;
 #define GET_NB_FACET(type) n_facet = ElementClass<type>::getNbFacetsPerElement()
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_NB_FACET);
 #undef GET_NB_FACET
 
   AKANTU_DEBUG_OUT();
   return n_facet;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbFacetsPerElement(const ElementType & type, UInt t) {
   AKANTU_DEBUG_IN();
 
   UInt n_facet = 0;
 #define GET_NB_FACET(type)                                                     \
   n_facet = ElementClass<type>::getNbFacetsPerElement(t)
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_NB_FACET);
 #undef GET_NB_FACET
 
   AKANTU_DEBUG_OUT();
   return n_facet;
 }
 
 /* -------------------------------------------------------------------------- */
 inline MatrixProxy<UInt>
 Mesh::getFacetLocalConnectivity(const ElementType & type, UInt t) {
   AKANTU_DEBUG_IN();
 
 #define GET_FACET_CON(type)                                                    \
   AKANTU_DEBUG_OUT();                                                          \
   return ElementClass<type>::getFacetLocalConnectivityPerElement(t)
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_FACET_CON);
 #undef GET_FACET_CON
 
   AKANTU_DEBUG_OUT();
   return MatrixProxy<UInt>(
       nullptr, 0, 0); // This avoid a compilation warning but will certainly
   // also cause a segfault if reached
 }
 
 /* -------------------------------------------------------------------------- */
 inline Matrix<UInt> Mesh::getFacetConnectivity(const Element & element,
                                                UInt t) const {
   AKANTU_DEBUG_IN();
 
   Matrix<UInt> local_facets(getFacetLocalConnectivity(element.type, t), false);
   Matrix<UInt> facets(local_facets.rows(), local_facets.cols());
 
   const Array<UInt> & conn = connectivities(element.type, element.ghost_type);
 
   for (UInt f = 0; f < facets.rows(); ++f) {
     for (UInt n = 0; n < facets.cols(); ++n) {
       facets(f, n) = conn(element.element, local_facets(f, n));
     }
   }
 
   AKANTU_DEBUG_OUT();
   return facets;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Mesh::extractNodalValuesFromElement(
     const Array<T> & nodal_values, T * local_coord, UInt * connectivity,
     UInt n_nodes, UInt nb_degree_of_freedom) const {
   for (UInt n = 0; n < n_nodes; ++n) {
     memcpy(local_coord + n * nb_degree_of_freedom,
            nodal_values.storage() + connectivity[n] * nb_degree_of_freedom,
            nb_degree_of_freedom * sizeof(T));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Mesh::addConnectivityType(const ElementType & type,
                                       const GhostType & ghost_type) {
   getConnectivityPointer(type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isPureGhostNode(UInt n) const {
   return nodes_type.size() ? (nodes_type(n) == _nt_pure_gost) : false;
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isLocalOrMasterNode(UInt n) const {
   return nodes_type.size()
              ? (nodes_type(n) == _nt_master) || (nodes_type(n) == _nt_normal)
              : true;
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isLocalNode(UInt n) const {
   return nodes_type.size() ? nodes_type(n) == _nt_normal : true;
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isMasterNode(UInt n) const {
   return nodes_type.size() ? nodes_type(n) == _nt_master : false;
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isSlaveNode(UInt n) const {
   return nodes_type.size() ? nodes_type(n) >= 0 : false;
 }
 
 /* -------------------------------------------------------------------------- */
 inline NodeType Mesh::getNodeType(UInt local_id) const {
   return nodes_type.size() ? nodes_type(local_id) : _nt_normal;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNodeGlobalId(UInt local_id) const {
   return nodes_global_ids ? (*nodes_global_ids)(local_id) : local_id;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNodeLocalId(UInt global_id) const {
   AKANTU_DEBUG_ASSERT(nodes_global_ids != nullptr,
                       "The global ids are note set.");
   return nodes_global_ids->find(global_id);
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbGlobalNodes() const {
   return nodes_global_ids ? nb_global_nodes : nodes->size();
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbNodesPerElementList(const Array<Element> & elements) {
   UInt nb_nodes_per_element = 0;
   UInt nb_nodes = 0;
   ElementType current_element_type = _not_defined;
 
   Array<Element>::const_iterator<Element> el_it = elements.begin();
   Array<Element>::const_iterator<Element> el_end = elements.end();
 
   for (; el_it != el_end; ++el_it) {
     const Element & el = *el_it;
 
     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)
     AKANTU_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)
     AKANTU_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)
     AKANTU_EXCEPTION(
         "No parent mesh is defined! This is only valid in a mesh_facets");
 
   return *this->mesh_parent;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
 
 #endif /* __AKANTU_MESH_INLINE_IMPL_CC__ */
diff --git a/src/mesh/node_group.cc b/src/mesh/node_group.cc
index 839472e41..377b0cce4 100644
--- a/src/mesh/node_group.cc
+++ b/src/mesh/node_group.cc
@@ -1,111 +1,111 @@
 /**
  * @file   node_group.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Implementation of the node group
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "node_group.hh"
 #include "dumpable.hh"
 #include "dumpable_inline_impl.hh"
 #include "mesh.hh"
 
 #if defined(AKANTU_USE_IOHELPER)
 #  include "dumper_paraview.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NodeGroup::NodeGroup(const std::string & name,
 		     const Mesh & mesh,
 		     const std::string & id,
                      const MemoryID & memory_id) :
   Memory(id, memory_id),
   name(name),
   node_group(alloc<UInt>(std::string(this->id + ":nodes"), 0, 1))//,
   // mesh(mesh)
 {
 
 #if defined(AKANTU_USE_IOHELPER)
   this->registerDumper<DumperParaview>("paraview_"  + name, name, true);
   this->getDumper().registerField("positions",new dumper::NodalField<Real,true>(
                                                                     mesh.getNodes(),
                                                                     0,
                                                                     0,
                                                                     &this->getNodes()));
 #endif
 
 }
 
 /* -------------------------------------------------------------------------- */
-NodeGroup::~NodeGroup() {}
+NodeGroup::~NodeGroup() = default;
 
 /* -------------------------------------------------------------------------- */
 void NodeGroup::empty() {
   node_group.resize(0);
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeGroup::optimize() {
   std::sort(node_group.begin(), node_group.end());
   Array<UInt>::iterator<> end = std::unique(node_group.begin(), node_group.end());
   node_group.resize(end - node_group.begin());
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeGroup::append(const NodeGroup & other_group) {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes = node_group.size();
 
   /// append new nodes to current list
   node_group.resize(nb_nodes + other_group.node_group.size());
   std::copy(other_group.node_group.begin(),
 	    other_group.node_group.end(),
 	    node_group.begin() + nb_nodes);
 
   optimize();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeGroup::printself(std::ostream & stream, int indent) const {
   std::string space;
   for(Int i = 0; i < indent; i++, space += AKANTU_INDENT);
 
   stream << space << "NodeGroup [" << std::endl;
   stream << space << " + name: " << name << std::endl;
   node_group.printself(stream, indent + 1);
   stream << space << "]" << std::endl;
 }
 
 
 } // akantu
diff --git a/src/mesh/node_group.hh b/src/mesh/node_group.hh
index b8362db4f..40a2361b2 100644
--- a/src/mesh/node_group.hh
+++ b/src/mesh/node_group.hh
@@ -1,141 +1,142 @@
 /**
  * @file   node_group.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Node group definition
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_array.hh"
 #include "aka_memory.hh"
 #include "mesh_filter.hh"
 #include "dumpable.hh"
 /* -------------------------------------------------------------------------- */
 
 
 
 #ifndef __AKANTU_NODE_GROUP_HH__
 #define __AKANTU_NODE_GROUP_HH__
 
 namespace akantu {
 
 class NodeGroup : public Memory, public Dumpable {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
 
   NodeGroup(const std::string & name,
 	    const Mesh & mesh,
             const std::string & id = "node_group",
             const MemoryID & memory_id = 0);
   ~NodeGroup() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
-  typedef Array<UInt>::const_iterator<UInt> const_node_iterator;
+  using const_node_iterator = Array<UInt>::const_iterator<UInt>;
 
   /// empty the node group
   void empty();
 
   /// iterator to the beginning of the node group
   inline const_node_iterator begin() const;
   /// iterator to the end of the node group
   inline const_node_iterator end() const;
 
   /// add a node and give the local position through an iterator
   inline const_node_iterator add(UInt node, bool check_for_duplicate = true);
 
   /// remove a node
   inline void remove(UInt node);
 
+#ifndef SWIG
   inline decltype(auto) find(UInt node) const {
     return node_group.find(node);
   }
-  
+#endif
   /// remove duplicated nodes
   void optimize();
 
   /// append a group to current one
   void append(const NodeGroup & other_group);
 
   /// apply a filter on current node group
   template <typename T>
   void applyNodeFilter(T & filter);
 
   /// function to print the contain of the class
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
 
   AKANTU_GET_MACRO_NOT_CONST(Nodes, node_group, Array<UInt> &);
   AKANTU_GET_MACRO(Nodes, node_group, const Array<UInt> &);
   AKANTU_GET_MACRO(Name, name, const std::string &);
 
   /// give the number of nodes in the current group
   inline UInt size() const;
 
   UInt * storage(){return node_group.storage();};
   
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// name of the group
   std::string name;
 
   /// list of nodes in the group
   Array<UInt> & node_group;
 
   /// reference to the mesh in question
   //const Mesh & mesh;
 };
 
 /// standard output stream operator
 inline std::ostream & operator <<(std::ostream & stream, const NodeGroup & _this)
 {
   _this.printself(stream);
   return stream;
 }
 
 } // akantu
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 #include "node_group_inline_impl.cc"
 
 
 
 #endif /* __AKANTU_NODE_GROUP_HH__ */
diff --git a/src/mesh_utils/mesh_partition/mesh_partition_mesh_data.cc b/src/mesh_utils/mesh_partition/mesh_partition_mesh_data.cc
index 1088437c9..b54222c4d 100644
--- a/src/mesh_utils/mesh_partition/mesh_partition_mesh_data.cc
+++ b/src/mesh_utils/mesh_partition/mesh_partition_mesh_data.cc
@@ -1,141 +1,141 @@
 /**
  * @file   mesh_partition_mesh_data.cc
  *
  * @author Dana Christen <dana.christen@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri May 03 2013
  * @date last modification: Wed Nov 11 2015
  *
  * @brief  implementation of the MeshPartitionMeshData class
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #include "mesh_partition_mesh_data.hh"
 #if !defined(AKANTU_NDEBUG)
 #include <set>
 #endif
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 MeshPartitionMeshData::MeshPartitionMeshData(const Mesh & mesh,
                                              UInt spatial_dimension,
                                              const ID & id,
                                              const MemoryID & memory_id)
     : MeshPartition(mesh, spatial_dimension, id, memory_id) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 MeshPartitionMeshData::MeshPartitionMeshData(
     const Mesh & mesh, const ElementTypeMapArray<UInt> & mapping,
     UInt spatial_dimension, const ID & id, const MemoryID & memory_id)
     : MeshPartition(mesh, spatial_dimension, id, memory_id),
       partition_mapping(&mapping) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshPartitionMeshData::partitionate(UInt nb_part,
                                          __attribute__((unused))
                                          const EdgeLoadFunctor & edge_load_func,
                                          const Array<UInt> & pairs) {
   AKANTU_DEBUG_IN();
 
   tweakConnectivity(pairs);
 
   nb_partitions = nb_part;
   GhostType ghost_type = _not_ghost;
   UInt spatial_dimension = mesh.getSpatialDimension();
   Mesh::type_iterator it =
       mesh.firstType(spatial_dimension, ghost_type, _ek_not_defined);
   Mesh::type_iterator end =
       mesh.lastType(spatial_dimension, ghost_type, _ek_not_defined);
 
   UInt linearized_el = 0;
   UInt nb_elements = mesh.getNbElement(mesh.getSpatialDimension(), ghost_type);
-  Int * partition_list = new Int[nb_elements];
+  auto * partition_list = new Int[nb_elements];
 
 #if !defined(AKANTU_NDEBUG)
   std::set<UInt> partitions;
 #endif
   for (; it != end; ++it) {
     ElementType type = *it;
     const Array<UInt> & partition_array =
         (*partition_mapping)(type, ghost_type);
     Array<UInt>::const_iterator<Vector<UInt> > p_it = partition_array.begin(1);
     Array<UInt>::const_iterator<Vector<UInt> > p_end = partition_array.end(1);
     AKANTU_DEBUG_ASSERT(UInt(p_end - p_it) ==
                             mesh.getNbElement(type, ghost_type),
                         "The partition mapping does not have the right number "
                             << "of entries for type " << type
                             << " and ghost type " << ghost_type << "."
                             << " Tags=" << p_end - p_it
                             << " Mesh=" << mesh.getNbElement(type, ghost_type));
     for (; p_it != p_end; ++p_it, ++linearized_el) {
       partition_list[linearized_el] = (*p_it)(0);
 #if !defined(AKANTU_NDEBUG)
       partitions.insert((*p_it)(0));
 #endif
     }
   }
 
 #if !defined(AKANTU_NDEBUG)
   AKANTU_DEBUG_ASSERT(partitions.size() == nb_part,
                       "The number of real partitions does not match with the "
                       "number of asked partitions");
 #endif
 
   fillPartitionInformation(mesh, partition_list);
 
   delete[] partition_list;
 
   restoreConnectivity();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshPartitionMeshData::reorder() { AKANTU_DEBUG_TO_IMPLEMENT(); }
 
 /* -------------------------------------------------------------------------- */
 void MeshPartitionMeshData::setPartitionMapping(
     const ElementTypeMapArray<UInt> & mapping) {
   partition_mapping = &mapping;
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshPartitionMeshData::setPartitionMappingFromMeshData(
     const std::string & data_name) {
   partition_mapping = &(mesh.getData<UInt>(data_name));
 }
 
 } // akantu
diff --git a/src/mesh_utils/mesh_partition/mesh_partition_scotch.cc b/src/mesh_utils/mesh_partition/mesh_partition_scotch.cc
index 15daa922f..c50f985ac 100644
--- a/src/mesh_utils/mesh_partition/mesh_partition_scotch.cc
+++ b/src/mesh_utils/mesh_partition/mesh_partition_scotch.cc
@@ -1,481 +1,481 @@
 /**
  * @file   mesh_partition_scotch.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  implementation of the MeshPartitionScotch class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "mesh_partition_scotch.hh"
 #include "aka_common.hh"
 #include "aka_random_generator.hh"
 #include "aka_static_if.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 #include <cstdio>
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 #if !defined(AKANTU_USE_PTSCOTCH)
 #ifndef AKANTU_SCOTCH_NO_EXTERN
 extern "C" {
 #endif // AKANTU_SCOTCH_NO_EXTERN
 #include <scotch.h>
 #ifndef AKANTU_SCOTCH_NO_EXTERN
 }
 #endif // AKANTU_SCOTCH_NO_EXTERN
 #else  // AKANTU_USE_PTSCOTCH
 #include <ptscotch.h>
 #endif // AKANTU_USE_PTSCOTCH
 
 namespace akantu {
 
 namespace {
   constexpr int scotch_version = int(SCOTCH_VERSION);
 }
 
 /* -------------------------------------------------------------------------- */
 MeshPartitionScotch::MeshPartitionScotch(const Mesh & mesh,
                                          UInt spatial_dimension, const ID & id,
                                          const MemoryID & memory_id)
     : MeshPartition(mesh, spatial_dimension, id, memory_id) {
   AKANTU_DEBUG_IN();
 
   // check if the akantu types and Scotch one are consistent
   static_assert(
       sizeof(Int) == sizeof(SCOTCH_Num),
       "The integer type of Akantu does not match the one from Scotch");
 
   static_if(aka::bool_constant_v<scotch_version >= 6>)
       .then([](auto && y) { SCOTCH_randomSeed(y); })
       .else_([](auto && y) {
         srandom(y);
       })(std::forward<UInt>(RandomGenerator<UInt>::seed()));
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 static SCOTCH_Mesh * createMesh(const Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt nb_nodes = mesh.getNbNodes();
 
   UInt total_nb_element = 0;
   UInt nb_edge = 0;
 
   Mesh::type_iterator it = mesh.firstType(spatial_dimension);
   Mesh::type_iterator end = mesh.lastType(spatial_dimension);
   for (; it != end; ++it) {
     ElementType type = *it;
 
     UInt nb_element = mesh.getNbElement(type);
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
     total_nb_element += nb_element;
     nb_edge += nb_element * nb_nodes_per_element;
   }
 
   SCOTCH_Num vnodbas = 0;
   SCOTCH_Num vnodnbr = nb_nodes;
 
   SCOTCH_Num velmbas = vnodnbr;
   SCOTCH_Num velmnbr = total_nb_element;
 
-  SCOTCH_Num * verttab = new SCOTCH_Num[vnodnbr + velmnbr + 1];
+  auto * verttab = new SCOTCH_Num[vnodnbr + velmnbr + 1];
   SCOTCH_Num * vendtab = verttab + 1;
 
-  SCOTCH_Num * velotab = NULL;
-  SCOTCH_Num * vnlotab = NULL;
-  SCOTCH_Num * vlbltab = NULL;
+  SCOTCH_Num * velotab = nullptr;
+  SCOTCH_Num * vnlotab = nullptr;
+  SCOTCH_Num * vlbltab = nullptr;
 
   memset(verttab, 0, (vnodnbr + velmnbr + 1) * sizeof(SCOTCH_Num));
 
   it = mesh.firstType(spatial_dimension);
   for (; it != end; ++it) {
     ElementType type = *it;
     if (Mesh::getSpatialDimension(type) != spatial_dimension)
       continue;
 
     UInt nb_element = mesh.getNbElement(type);
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
     const Array<UInt> & connectivity = mesh.getConnectivity(type, _not_ghost);
 
     /// count number of occurrence of each node
     for (UInt el = 0; el < nb_element; ++el) {
       UInt * conn_val = connectivity.storage() + el * nb_nodes_per_element;
       for (UInt n = 0; n < nb_nodes_per_element; ++n) {
         verttab[*(conn_val++)]++;
       }
     }
   }
 
   /// convert the occurrence array in a csr one
   for (UInt i = 1; i < nb_nodes; ++i)
     verttab[i] += verttab[i - 1];
   for (UInt i = nb_nodes; i > 0; --i)
     verttab[i] = verttab[i - 1];
   verttab[0] = 0;
 
   /// rearrange element to get the node-element list
   SCOTCH_Num edgenbr = verttab[vnodnbr] + nb_edge;
-  SCOTCH_Num * edgetab = new SCOTCH_Num[edgenbr];
+  auto * edgetab = new SCOTCH_Num[edgenbr];
 
   UInt linearized_el = 0;
 
   it = mesh.firstType(spatial_dimension);
   for (; it != end; ++it) {
     ElementType type = *it;
 
     UInt nb_element = mesh.getNbElement(type);
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
     const Array<UInt> & connectivity = mesh.getConnectivity(type, _not_ghost);
 
     for (UInt el = 0; el < nb_element; ++el, ++linearized_el) {
       UInt * conn_val = connectivity.storage() + el * nb_nodes_per_element;
       for (UInt n = 0; n < nb_nodes_per_element; ++n)
         edgetab[verttab[*(conn_val++)]++] = linearized_el + velmbas;
     }
   }
 
   for (UInt i = nb_nodes; i > 0; --i)
     verttab[i] = verttab[i - 1];
   verttab[0] = 0;
 
   SCOTCH_Num * verttab_tmp = verttab + vnodnbr + 1;
   SCOTCH_Num * edgetab_tmp = edgetab + verttab[vnodnbr];
 
   it = mesh.firstType(spatial_dimension);
   for (; it != end; ++it) {
     ElementType type = *it;
 
     UInt nb_element = mesh.getNbElement(type);
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
     const Array<UInt> & connectivity = mesh.getConnectivity(type, _not_ghost);
 
     for (UInt el = 0; el < nb_element; ++el) {
       *verttab_tmp = *(verttab_tmp - 1) + nb_nodes_per_element;
       verttab_tmp++;
       UInt * conn = connectivity.storage() + el * nb_nodes_per_element;
       for (UInt i = 0; i < nb_nodes_per_element; ++i) {
         *(edgetab_tmp++) = *(conn++) + vnodbas;
       }
     }
   }
 
-  SCOTCH_Mesh * meshptr = new SCOTCH_Mesh;
+  auto * meshptr = new SCOTCH_Mesh;
 
   SCOTCH_meshInit(meshptr);
 
   SCOTCH_meshBuild(meshptr, velmbas, vnodbas, velmnbr, vnodnbr, verttab,
                    vendtab, velotab, vnlotab, vlbltab, edgenbr, edgetab);
 
   /// Check the mesh
   AKANTU_DEBUG_ASSERT(SCOTCH_meshCheck(meshptr) == 0,
                       "Scotch mesh is not consistent");
 
 #ifndef AKANTU_NDEBUG
   if (AKANTU_DEBUG_TEST(dblDump)) {
     /// save initial graph
     FILE * fmesh = fopen("ScotchMesh.msh", "w");
     SCOTCH_meshSave(meshptr, fmesh);
     fclose(fmesh);
 
     /// write geometry file
     std::ofstream fgeominit;
     fgeominit.open("ScotchMesh.xyz");
     fgeominit << spatial_dimension << std::endl << nb_nodes << std::endl;
 
     const Array<Real> & nodes = mesh.getNodes();
     Real * nodes_val = nodes.storage();
     for (UInt i = 0; i < nb_nodes; ++i) {
       fgeominit << i << " ";
       for (UInt s = 0; s < spatial_dimension; ++s)
         fgeominit << *(nodes_val++) << " ";
       fgeominit << std::endl;
       ;
     }
     fgeominit.close();
   }
 #endif
 
   AKANTU_DEBUG_OUT();
   return meshptr;
 }
 
 /* -------------------------------------------------------------------------- */
 static void destroyMesh(SCOTCH_Mesh * meshptr) {
   AKANTU_DEBUG_IN();
 
   SCOTCH_Num velmbas, vnodbas, vnodnbr, velmnbr, *verttab, *vendtab, *velotab,
       *vnlotab, *vlbltab, edgenbr, *edgetab, degrptr;
 
   SCOTCH_meshData(meshptr, &velmbas, &vnodbas, &velmnbr, &vnodnbr, &verttab,
                   &vendtab, &velotab, &vnlotab, &vlbltab, &edgenbr, &edgetab,
                   &degrptr);
 
   delete[] verttab;
   delete[] edgetab;
 
   SCOTCH_meshExit(meshptr);
 
   delete meshptr;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshPartitionScotch::partitionate(UInt nb_part,
                                        const EdgeLoadFunctor & edge_load_func,
                                        const Array<UInt> & pairs) {
   AKANTU_DEBUG_IN();
 
   nb_partitions = nb_part;
 
   tweakConnectivity(pairs);
 
   AKANTU_DEBUG_INFO("Partitioning the mesh " << mesh.getID() << " in "
                                              << nb_part << " parts.");
 
   Array<Int> dxadj;
   Array<Int> dadjncy;
   Array<Int> edge_loads;
   buildDualGraph(dxadj, dadjncy, edge_loads, edge_load_func);
 
   /// variables that will hold our structures in scotch format
   SCOTCH_Graph scotch_graph;
   SCOTCH_Strat scotch_strat;
 
   /// description number and arrays for struct mesh for scotch
   SCOTCH_Num baseval = 0; // base numbering for element and
   // nodes (0 -> C , 1 -> fortran)
   SCOTCH_Num vertnbr = dxadj.size() - 1; // number of vertexes
   SCOTCH_Num * parttab;                  // array of partitions
   SCOTCH_Num edgenbr = dxadj(vertnbr);   // twice  the number  of "edges"
   //(an "edge" bounds two nodes)
   SCOTCH_Num * verttab = dxadj.storage(); // array of start indices in edgetab
-  SCOTCH_Num * vendtab = NULL; // array of after-last indices in edgetab
-  SCOTCH_Num * velotab = NULL; // integer  load  associated with
+  SCOTCH_Num * vendtab = nullptr; // array of after-last indices in edgetab
+  SCOTCH_Num * velotab = nullptr; // integer  load  associated with
   // every vertex ( optional )
   SCOTCH_Num * edlotab = edge_loads.storage(); // integer  load  associated with
   // every edge ( optional )
   SCOTCH_Num * edgetab = dadjncy.storage(); // adjacency array of every vertex
-  SCOTCH_Num * vlbltab = NULL;              // vertex label array (optional)
+  SCOTCH_Num * vlbltab = nullptr;           // vertex label array (optional)
 
   /// Allocate space for Scotch arrays
   parttab = new SCOTCH_Num[vertnbr];
 
   /// Initialize the strategy structure
   SCOTCH_stratInit(&scotch_strat);
 
   /// Initialize the graph structure
   SCOTCH_graphInit(&scotch_graph);
 
   /// Build the graph from the adjacency arrays
   SCOTCH_graphBuild(&scotch_graph, baseval, vertnbr, verttab, vendtab, velotab,
                     vlbltab, edgenbr, edgetab, edlotab);
 
 #ifndef AKANTU_NDEBUG
   if (AKANTU_DEBUG_TEST(dblDump)) {
     /// save initial graph
     FILE * fgraphinit = fopen("GraphIniFile.grf", "w");
     SCOTCH_graphSave(&scotch_graph, fgraphinit);
     fclose(fgraphinit);
 
     /// write geometry file
     std::ofstream fgeominit;
     fgeominit.open("GeomIniFile.xyz");
     fgeominit << spatial_dimension << std::endl << vertnbr << std::endl;
 
     const Array<Real> & nodes = mesh.getNodes();
 
     Mesh::type_iterator f_it =
         mesh.firstType(spatial_dimension, _not_ghost, _ek_not_defined);
     Mesh::type_iterator f_end =
         mesh.lastType(spatial_dimension, _not_ghost, _ek_not_defined);
     Array<Real>::const_vector_iterator nodes_it =
         nodes.begin(spatial_dimension);
 
     UInt out_linerized_el = 0;
     for (; f_it != f_end; ++f_it) {
       ElementType type = *f_it;
 
       UInt nb_element = mesh.getNbElement(*f_it);
       UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
       const Array<UInt> & connectivity = mesh.getConnectivity(type);
 
       Vector<Real> mid(spatial_dimension);
       for (UInt el = 0; el < nb_element; ++el) {
         mid.set(0.);
         for (UInt n = 0; n < nb_nodes_per_element; ++n) {
           UInt node = connectivity.storage()[nb_nodes_per_element * el + n];
           mid += Vector<Real>(nodes_it[node]);
         }
         mid /= nb_nodes_per_element;
 
         fgeominit << out_linerized_el++ << " ";
         for (UInt s = 0; s < spatial_dimension; ++s)
           fgeominit << mid[s] << " ";
 
         fgeominit << std::endl;
         ;
       }
     }
     fgeominit.close();
   }
 #endif
   /// Check the graph
   AKANTU_DEBUG_ASSERT(SCOTCH_graphCheck(&scotch_graph) == 0,
                       "Graph to partition is not consistent");
 
   /// Partition the mesh
   SCOTCH_graphPart(&scotch_graph, nb_part, &scotch_strat, parttab);
 
   /// Check the graph
   AKANTU_DEBUG_ASSERT(SCOTCH_graphCheck(&scotch_graph) == 0,
                       "Partitioned graph is not consistent");
 
 #ifndef AKANTU_NDEBUG
   if (AKANTU_DEBUG_TEST(dblDump)) {
     /// save the partitioned graph
     FILE * fgraph = fopen("GraphFile.grf", "w");
     SCOTCH_graphSave(&scotch_graph, fgraph);
     fclose(fgraph);
 
     /// save the partition map
     std::ofstream fmap;
     fmap.open("MapFile.map");
     fmap << vertnbr << std::endl;
     for (Int i = 0; i < vertnbr; i++)
       fmap << i << "    " << parttab[i] << std::endl;
     fmap.close();
   }
 #endif
 
   /// free the scotch data structures
   SCOTCH_stratExit(&scotch_strat);
   SCOTCH_graphFree(&scotch_graph);
   SCOTCH_graphExit(&scotch_graph);
 
   fillPartitionInformation(mesh, parttab);
 
   delete[] parttab;
 
   restoreConnectivity();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshPartitionScotch::reorder() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Reordering the mesh " << mesh.getID());
   SCOTCH_Mesh * scotch_mesh = createMesh(mesh);
 
   UInt nb_nodes = mesh.getNbNodes();
 
   SCOTCH_Strat scotch_strat;
   // SCOTCH_Ordering scotch_order;
 
-  SCOTCH_Num * permtab = new SCOTCH_Num[nb_nodes];
-  SCOTCH_Num * peritab = NULL;
+  auto * permtab = new SCOTCH_Num[nb_nodes];
+  SCOTCH_Num * peritab = nullptr;
   SCOTCH_Num cblknbr = 0;
-  SCOTCH_Num * rangtab = NULL;
-  SCOTCH_Num * treetab = NULL;
+  SCOTCH_Num * rangtab = nullptr;
+  SCOTCH_Num * treetab = nullptr;
 
   /// Initialize the strategy structure
   SCOTCH_stratInit(&scotch_strat);
 
   SCOTCH_Graph scotch_graph;
 
   SCOTCH_graphInit(&scotch_graph);
   SCOTCH_meshGraph(scotch_mesh, &scotch_graph);
 
 #ifndef AKANTU_NDEBUG
   if (AKANTU_DEBUG_TEST(dblDump)) {
     FILE * fgraphinit = fopen("ScotchMesh.grf", "w");
     SCOTCH_graphSave(&scotch_graph, fgraphinit);
     fclose(fgraphinit);
   }
 #endif
 
   /// Check the graph
   // AKANTU_DEBUG_ASSERT(SCOTCH_graphCheck(&scotch_graph) == 0,
   //		      "Mesh to Graph is not consistent");
 
   SCOTCH_graphOrder(&scotch_graph, &scotch_strat, permtab, peritab, &cblknbr,
                     rangtab, treetab);
 
   SCOTCH_graphExit(&scotch_graph);
   SCOTCH_stratExit(&scotch_strat);
   destroyMesh(scotch_mesh);
 
   /// Renumbering
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   for (UInt g = _not_ghost; g <= _ghost; ++g) {
-    GhostType gt = (GhostType)g;
+    auto gt = (GhostType)g;
 
     Mesh::type_iterator it = mesh.firstType(_all_dimensions, gt);
     Mesh::type_iterator end = mesh.lastType(_all_dimensions, gt);
 
     for (; it != end; ++it) {
       ElementType type = *it;
 
       UInt nb_element = mesh.getNbElement(type, gt);
       UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
       const Array<UInt> & connectivity = mesh.getConnectivity(type, gt);
 
       UInt * conn = connectivity.storage();
       for (UInt el = 0; el < nb_element * nb_nodes_per_element; ++el, ++conn) {
         *conn = permtab[*conn];
       }
     }
   }
 
   /// \todo think of a in-place way to do it
-  Real * new_coordinates = new Real[spatial_dimension * nb_nodes];
+  auto * new_coordinates = new Real[spatial_dimension * nb_nodes];
   Real * old_coordinates = mesh.getNodes().storage();
   for (UInt i = 0; i < nb_nodes; ++i) {
     memcpy(new_coordinates + permtab[i] * spatial_dimension,
            old_coordinates + i * spatial_dimension,
            spatial_dimension * sizeof(Real));
   }
   memcpy(old_coordinates, new_coordinates,
          nb_nodes * spatial_dimension * sizeof(Real));
   delete[] new_coordinates;
 
   delete[] permtab;
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/src/mesh_utils/mesh_utils.cc b/src/mesh_utils/mesh_utils.cc
index d4378f2b7..92a3478be 100644
--- a/src/mesh_utils/mesh_utils.cc
+++ b/src/mesh_utils/mesh_utils.cc
@@ -1,2172 +1,2172 @@
 /**
  * @file   mesh_utils.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Leonardo Snozzi <leonardo.snozzi@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Aug 20 2010
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  All mesh utils necessary for various tasks
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "mesh_utils.hh"
 #include "element_synchronizer.hh"
 #include "fe_engine.hh"
 #include "mesh_accessor.hh"
 /* -------------------------------------------------------------------------- */
 #include <limits>
 #include <numeric>
 #include <queue>
 #include <set>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::buildNode2Elements(const Mesh & mesh,
                                    CSR<Element> & node_to_elem,
                                    UInt spatial_dimension) {
   AKANTU_DEBUG_IN();
   if (spatial_dimension == _all_dimensions)
     spatial_dimension = mesh.getSpatialDimension();
 
   /// count number of occurrence of each node
   UInt nb_nodes = mesh.getNbNodes();
 
   /// array for the node-element list
   node_to_elem.resizeRows(nb_nodes);
   node_to_elem.clearRows();
 
   AKANTU_DEBUG_ASSERT(
       mesh.firstType(spatial_dimension) != mesh.lastType(spatial_dimension),
       "Some elements must be found in right dimension to compute facets!");
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     Mesh::type_iterator first =
         mesh.firstType(spatial_dimension, *gt, _ek_not_defined);
     Mesh::type_iterator last =
         mesh.lastType(spatial_dimension, *gt, _ek_not_defined);
 
     for (; first != last; ++first) {
       ElementType type = *first;
       UInt nb_element = mesh.getNbElement(type, *gt);
       Array<UInt>::const_iterator<Vector<UInt>> conn_it =
           mesh.getConnectivity(type, *gt).begin(
               Mesh::getNbNodesPerElement(type));
 
       for (UInt el = 0; el < nb_element; ++el, ++conn_it)
         for (UInt n = 0; n < conn_it->size(); ++n)
           ++node_to_elem.rowOffset((*conn_it)(n));
     }
   }
 
   node_to_elem.countToCSR();
   node_to_elem.resizeCols();
 
   /// rearrange element to get the node-element list
   Element e;
   node_to_elem.beginInsertions();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     Mesh::type_iterator first =
         mesh.firstType(spatial_dimension, *gt, _ek_not_defined);
     Mesh::type_iterator last =
         mesh.lastType(spatial_dimension, *gt, _ek_not_defined);
     e.ghost_type = *gt;
     for (; first != last; ++first) {
       ElementType type = *first;
       e.type = type;
       UInt nb_element = mesh.getNbElement(type, *gt);
       Array<UInt>::const_iterator<Vector<UInt>> conn_it =
           mesh.getConnectivity(type, *gt).begin(
               Mesh::getNbNodesPerElement(type));
 
       for (UInt el = 0; el < nb_element; ++el, ++conn_it) {
         e.element = el;
         for (UInt n = 0; n < conn_it->size(); ++n)
           node_to_elem.insertInRow((*conn_it)(n), e);
       }
     }
   }
 
   node_to_elem.endInsertions();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * This function should disappear in the future (used in mesh partitioning)
  */
 // void MeshUtils::buildNode2Elements(const Mesh & mesh, CSR<UInt> &
 // node_to_elem,
 //                                    UInt spatial_dimension) {
 //   AKANTU_DEBUG_IN();
 //   if (spatial_dimension == _all_dimensions)
 //     spatial_dimension = mesh.getSpatialDimension();
 //   UInt nb_nodes = mesh.getNbNodes();
 
 //   const Mesh::ConnectivityTypeList & type_list =
 //   mesh.getConnectivityTypeList(); Mesh::ConnectivityTypeList::const_iterator
 //   it;
 
 //   UInt nb_types = type_list.size();
 //   UInt nb_good_types = 0;
 
 //   Vector<UInt> nb_nodes_per_element(nb_types);
 //   UInt ** conn_val = new UInt *[nb_types];
 //   Vector<UInt> nb_element(nb_types);
 
 //   for (it = type_list.begin(); it != type_list.end(); ++it) {
 //     ElementType type = *it;
 //     if (Mesh::getSpatialDimension(type) != spatial_dimension)
 //       continue;
 
 //     nb_nodes_per_element[nb_good_types] = Mesh::getNbNodesPerElement(type);
 //     conn_val[nb_good_types] = mesh.getConnectivity(type,
 //     _not_ghost).storage(); nb_element[nb_good_types] =
 //         mesh.getConnectivity(type, _not_ghost).size();
 //     nb_good_types++;
 //   }
 
 //   AKANTU_DEBUG_ASSERT(
 //       nb_good_types != 0,
 //       "Some elements must be found in right dimension to compute facets!");
 
 //   /// array for the node-element list
 //   node_to_elem.resizeRows(nb_nodes);
 //   node_to_elem.clearRows();
 
 //   /// count number of occurrence of each node
 //   for (UInt t = 0; t < nb_good_types; ++t) {
 //     for (UInt el = 0; el < nb_element[t]; ++el) {
 //       UInt el_offset = el * nb_nodes_per_element[t];
 //       for (UInt n = 0; n < nb_nodes_per_element[t]; ++n) {
 //         ++node_to_elem.rowOffset(conn_val[t][el_offset + n]);
 //       }
 //     }
 //   }
 
 //   node_to_elem.countToCSR();
 //   node_to_elem.resizeCols();
 //   node_to_elem.beginInsertions();
 
 //   /// rearrange element to get the node-element list
 //   for (UInt t = 0, linearized_el = 0; t < nb_good_types; ++t)
 //     for (UInt el = 0; el < nb_element[t]; ++el, ++linearized_el) {
 //       UInt el_offset = el * nb_nodes_per_element[t];
 //       for (UInt n = 0; n < nb_nodes_per_element[t]; ++n)
 //         node_to_elem.insertInRow(conn_val[t][el_offset + n], linearized_el);
 //     }
 
 //   node_to_elem.endInsertions();
 //   delete[] conn_val;
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::buildNode2ElementsElementTypeMap(const Mesh & mesh,
                                                  CSR<UInt> & node_to_elem,
                                                  const ElementType & type,
                                                  const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
   UInt nb_nodes = mesh.getNbNodes();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_elements = mesh.getConnectivity(type, ghost_type).size();
 
   UInt * conn_val = mesh.getConnectivity(type, ghost_type).storage();
 
   /// array for the node-element list
   node_to_elem.resizeRows(nb_nodes);
   node_to_elem.clearRows();
 
   /// count number of occurrence of each node
   for (UInt el = 0; el < nb_elements; ++el) {
     UInt el_offset = el * nb_nodes_per_element;
     for (UInt n = 0; n < nb_nodes_per_element; ++n)
       ++node_to_elem.rowOffset(conn_val[el_offset + n]);
   }
 
   /// convert the occurrence array in a csr one
   node_to_elem.countToCSR();
 
   node_to_elem.resizeCols();
   node_to_elem.beginInsertions();
 
   /// save the element index in the node-element list
   for (UInt el = 0; el < nb_elements; ++el) {
     UInt el_offset = el * nb_nodes_per_element;
     for (UInt n = 0; n < nb_nodes_per_element; ++n) {
       node_to_elem.insertInRow(conn_val[el_offset + n], el);
     }
   }
 
   node_to_elem.endInsertions();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::buildFacets(Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     GhostType gt_facet = *gt;
     Mesh::type_iterator it = mesh.firstType(spatial_dimension - 1, gt_facet);
     Mesh::type_iterator end = mesh.lastType(spatial_dimension - 1, gt_facet);
     for (; it != end; ++it) {
       mesh.getConnectivity(*it, *gt).resize(0);
       // \todo inform the mesh event handler
     }
   }
 
   buildFacetsDimension(mesh, mesh, true, spatial_dimension);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::buildAllFacets(const Mesh & mesh, Mesh & mesh_facets,
                                UInt to_dimension) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   buildAllFacets(mesh, mesh_facets, spatial_dimension, to_dimension);
 
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 void MeshUtils::buildAllFacets(const Mesh & mesh, Mesh & mesh_facets,
                                UInt from_dimension, UInt to_dimension) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(
       mesh_facets.isMeshFacets(),
       "The mesh_facets should be initialized with initMeshFacets");
 
   /// generate facets
   buildFacetsDimension(mesh, mesh_facets, false, from_dimension);
 
   /// copy nodes type
   MeshAccessor mesh_accessor_facets(mesh_facets);
   mesh_accessor_facets.getNodesType().copy(mesh.getNodesType());
 
   /// sort facets and generate sub-facets
   for (UInt i = from_dimension - 1; i > to_dimension; --i) {
     buildFacetsDimension(mesh_facets, mesh_facets, false, i);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::buildFacetsDimension(const Mesh & mesh, Mesh & mesh_facets,
                                      bool boundary_only, UInt dimension) {
   AKANTU_DEBUG_IN();
 
   // save the current parent of mesh_facets and set it temporarly to mesh since
   // mesh is the one containing the elements for which mesh_facets has the
   // sub-elements
   // example: if the function is called with mesh = mesh_facets
   const Mesh * mesh_facets_parent = nullptr;
   try {
     mesh_facets_parent = &mesh_facets.getMeshParent();
   } catch (...) {
   }
 
   mesh_facets.defineMeshParent(mesh);
   MeshAccessor mesh_accessor(mesh_facets);
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   const Array<Real> & mesh_facets_nodes = mesh_facets.getNodes();
   const Array<Real>::const_vector_iterator mesh_facets_nodes_it =
       mesh_facets_nodes.begin(spatial_dimension);
 
   CSR<Element> node_to_elem;
   buildNode2Elements(mesh, node_to_elem, dimension);
 
   Array<UInt> counter;
   std::vector<Element> connected_elements;
 
   // init the SubelementToElement data to improve performance
   for (auto && ghost_type : ghost_types) {
     for (auto && type : mesh.elementTypes(dimension, ghost_type)) {
       mesh_accessor.getSubelementToElement(type, ghost_type);
 
       Vector<ElementType> facet_types = mesh.getAllFacetTypes(type);
 
       for (auto && ft : arange(facet_types.size())) {
         ElementType facet_type = facet_types(ft);
         mesh_accessor.getElementToSubelement(facet_type, ghost_type);
         mesh_accessor.getConnectivity(facet_type, ghost_type);
       }
     }
   }
 
   const ElementSynchronizer * synchronizer = nullptr;
   if (mesh.isDistributed()) {
     synchronizer = &(mesh.getElementSynchronizer());
   }
 
   Element current_element;
   for (auto && ghost_type : ghost_types) {
     GhostType facet_ghost_type = ghost_type;
     current_element.ghost_type = ghost_type;
 
     for (auto && type : mesh.elementTypes(dimension, ghost_type)) {
       auto facet_types = mesh.getAllFacetTypes(type);
       current_element.type = type;
 
       for (auto && ft : arange(facet_types.size())) {
         auto facet_type = facet_types(ft);
         auto nb_element = mesh.getNbElement(type, ghost_type);
 
         auto element_to_subelement =
             &mesh_facets.getElementToSubelement(facet_type, ghost_type);
         auto connectivity_facets =
             &mesh_facets.getConnectivity(facet_type, ghost_type);
 
         auto nb_facet_per_element = mesh.getNbFacetsPerElement(type, ft);
         const auto & element_connectivity =
             mesh.getConnectivity(type, ghost_type);
         const Matrix<UInt> facet_local_connectivity =
             mesh.getFacetLocalConnectivity(type, ft);
 
         auto nb_nodes_per_facet = connectivity_facets->getNbComponent();
         Vector<UInt> facet(nb_nodes_per_facet);
 
         for (UInt el = 0; el < nb_element; ++el) {
           current_element.element = el;
 
           for (UInt f = 0; f < nb_facet_per_element; ++f) {
             for (UInt n = 0; n < nb_nodes_per_facet; ++n)
               facet(n) =
                   element_connectivity(el, facet_local_connectivity(f, n));
 
             UInt first_node_nb_elements = node_to_elem.getNbCols(facet(0));
             counter.resize(first_node_nb_elements);
             counter.clear();
 
             // loop over the other nodes to search intersecting elements,
             // which are the elements that share another node with the
             // starting element after first_node
             UInt local_el = 0;
             auto first_node_elements = node_to_elem.begin(facet(0));
             auto first_node_elements_end = node_to_elem.end(facet(0));
             for (; first_node_elements != first_node_elements_end;
                  ++first_node_elements, ++local_el) {
               for (UInt n = 1; n < nb_nodes_per_facet; ++n) {
                 auto node_elements_begin = node_to_elem.begin(facet(n));
                 auto node_elements_end = node_to_elem.end(facet(n));
                 counter(local_el) +=
                     std::count(node_elements_begin, node_elements_end,
                                *first_node_elements);
               }
             }
 
             // counting the number of elements connected to the facets and
             // taking the minimum element number, because the facet should
             // be inserted just once
             UInt nb_element_connected_to_facet = 0;
             Element minimum_el = ElementNull;
             connected_elements.clear();
             for (UInt el_f = 0; el_f < first_node_nb_elements; el_f++) {
               Element real_el = node_to_elem(facet(0), el_f);
               if (not(counter(el_f) == nb_nodes_per_facet - 1))
                 continue;
 
               ++nb_element_connected_to_facet;
               minimum_el = std::min(minimum_el, real_el);
               connected_elements.push_back(real_el);
             }
 
             if (minimum_el != current_element)
               continue;
 
             bool full_ghost_facet = false;
 
             UInt n = 0;
             while (n < nb_nodes_per_facet && mesh.isPureGhostNode(facet(n)))
               ++n;
             if (n == nb_nodes_per_facet)
               full_ghost_facet = true;
 
             if (full_ghost_facet)
               continue;
 
             if (boundary_only and nb_element_connected_to_facet != 1)
               continue;
 
             std::vector<Element> elements;
 
             // build elements_on_facets: linearized_el must come first
             // in order to store the facet in the correct direction
             // and avoid to invert the sign in the normal computation
             elements.push_back(current_element);
 
             if (nb_element_connected_to_facet == 1) { /// boundary facet
               elements.push_back(ElementNull);
             } else if (nb_element_connected_to_facet == 2) { /// internal facet
               elements.push_back(connected_elements[1]);
 
               /// check if facet is in between ghost and normal
               /// elements: if it's the case, the facet is either
               /// ghost or not ghost. The criterion to decide this
               /// is arbitrary. It was chosen to check the processor
               /// id (prank) of the two neighboring elements. If
               /// prank of the ghost element is lower than prank of
               /// the normal one, the facet is not ghost, otherwise
               /// it's ghost
               GhostType gt[2] = {_not_ghost, _not_ghost};
               for (UInt el = 0; el < connected_elements.size(); ++el)
                 gt[el] = connected_elements[el].ghost_type;
 
               if (gt[0] != gt[1] and
                   (gt[0] == _not_ghost or gt[1] == _not_ghost)) {
                 UInt prank[2];
                 for (UInt el = 0; el < 2; ++el) {
                   prank[el] = synchronizer->getRank(connected_elements[el]);
                 }
 
                 // ugly trick from Marco detected :P
                 bool ghost_one = (gt[0] != _ghost);
                 if (prank[ghost_one] > prank[!ghost_one])
                   facet_ghost_type = _not_ghost;
                 else
                   facet_ghost_type = _ghost;
 
                 connectivity_facets =
                     &mesh_facets.getConnectivity(facet_type, facet_ghost_type);
                 element_to_subelement = &mesh_facets.getElementToSubelement(
                     facet_type, facet_ghost_type);
               }
             } else { /// facet of facet
               for (UInt i = 1; i < nb_element_connected_to_facet; ++i) {
                 elements.push_back(connected_elements[i]);
               }
             }
 
             element_to_subelement->push_back(elements);
             connectivity_facets->push_back(facet);
 
             /// current facet index
             UInt current_facet = connectivity_facets->size() - 1;
 
             /// loop on every element connected to current facet and
             /// insert current facet in the first free spot of the
             /// subelement_to_element vector
             for (UInt elem = 0; elem < elements.size(); ++elem) {
               Element loc_el = elements[elem];
 
               if (loc_el.type == _not_defined)
                 continue;
 
               Array<Element> & subelement_to_element =
                   mesh_facets.getSubelementToElement(loc_el.type,
                                                      loc_el.ghost_type);
 
               UInt nb_facet_per_loc_element =
                   subelement_to_element.getNbComponent();
 
               for (UInt f_in = 0; f_in < nb_facet_per_loc_element; ++f_in) {
                 auto & el = subelement_to_element(loc_el.element, f_in);
                 if (el.type != _not_defined)
                   continue;
 
                 el.type = facet_type;
                 el.element = current_facet;
                 el.ghost_type = facet_ghost_type;
                 break;
               }
             }
 
             /// reset connectivity in case a facet was found in
             /// between ghost and normal elements
             if (facet_ghost_type != ghost_type) {
               facet_ghost_type = ghost_type;
               connectivity_facets =
                   &mesh_accessor.getConnectivity(facet_type, facet_ghost_type);
               element_to_subelement = &mesh_accessor.getElementToSubelement(
                   facet_type, facet_ghost_type);
             }
           }
         }
       }
     }
   }
 
   // restore the parent of mesh_facet
   if (mesh_facets_parent)
     mesh_facets.defineMeshParent(*mesh_facets_parent);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::renumberMeshNodes(Mesh & mesh,
                                   Array<UInt> & local_connectivities,
                                   UInt nb_local_element, UInt nb_ghost_element,
                                   ElementType type,
                                   Array<UInt> & old_nodes_numbers) {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
   std::map<UInt, UInt> renumbering_map;
   for (UInt i = 0; i < old_nodes_numbers.size(); ++i) {
     renumbering_map[old_nodes_numbers(i)] = i;
   }
 
   /// renumber the nodes
   renumberNodesInConnectivity(local_connectivities,
                               (nb_local_element + nb_ghost_element) *
                                   nb_nodes_per_element,
                               renumbering_map);
 
   old_nodes_numbers.resize(renumbering_map.size());
   for (auto & renumber_pair : renumbering_map) {
     old_nodes_numbers(renumber_pair.second) = renumber_pair.first;
   }
   renumbering_map.clear();
 
   MeshAccessor mesh_accessor(mesh);
 
   /// copy the renumbered connectivity to the right place
   auto & local_conn = mesh_accessor.getConnectivity(type);
   local_conn.resize(nb_local_element);
   memcpy(local_conn.storage(), local_connectivities.storage(),
          nb_local_element * nb_nodes_per_element * sizeof(UInt));
 
   auto & ghost_conn = mesh_accessor.getConnectivity(type, _ghost);
   ghost_conn.resize(nb_ghost_element);
   std::memcpy(ghost_conn.storage(),
               local_connectivities.storage() +
                   nb_local_element * nb_nodes_per_element,
               nb_ghost_element * nb_nodes_per_element * sizeof(UInt));
 
   auto & ghost_counter = mesh_accessor.getGhostsCounters(type, _ghost);
   ghost_counter.resize(nb_ghost_element, 1);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::renumberNodesInConnectivity(
     Array<UInt> & list_nodes, UInt nb_nodes,
     std::map<UInt, UInt> & renumbering_map) {
   AKANTU_DEBUG_IN();
 
   UInt * connectivity = list_nodes.storage();
   UInt new_node_num = renumbering_map.size();
   for (UInt n = 0; n < nb_nodes; ++n, ++connectivity) {
     UInt & node = *connectivity;
-    std::map<UInt, UInt>::iterator it = renumbering_map.find(node);
+    auto it = renumbering_map.find(node);
     if (it == renumbering_map.end()) {
       UInt old_node = node;
       renumbering_map[old_node] = new_node_num;
       node = new_node_num;
       ++new_node_num;
     } else {
       node = it->second;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::purifyMesh(Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   std::map<UInt, UInt> renumbering_map;
 
   RemovedNodesEvent remove_nodes(mesh);
   Array<UInt> & nodes_removed = remove_nodes.getList();
 
   for (UInt gt = _not_ghost; gt <= _ghost; ++gt) {
-    GhostType ghost_type = (GhostType)gt;
+    auto ghost_type = (GhostType)gt;
 
     Mesh::type_iterator it =
         mesh.firstType(_all_dimensions, ghost_type, _ek_not_defined);
     Mesh::type_iterator end =
         mesh.lastType(_all_dimensions, ghost_type, _ek_not_defined);
     for (; it != end; ++it) {
 
       ElementType type(*it);
       UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
       Array<UInt> & connectivity = mesh.getConnectivity(type, ghost_type);
       UInt nb_element(connectivity.size());
 
       renumberNodesInConnectivity(
           connectivity, nb_element * nb_nodes_per_element, renumbering_map);
     }
   }
 
   Array<UInt> & new_numbering = remove_nodes.getNewNumbering();
   std::fill(new_numbering.begin(), new_numbering.end(), UInt(-1));
 
-  std::map<UInt, UInt>::iterator it = renumbering_map.begin();
-  std::map<UInt, UInt>::iterator end = renumbering_map.end();
+  auto it = renumbering_map.begin();
+  auto end = renumbering_map.end();
   for (; it != end; ++it) {
     new_numbering(it->first) = it->second;
   }
 
   for (UInt i = 0; i < new_numbering.size(); ++i) {
     if (new_numbering(i) == UInt(-1))
       nodes_removed.push_back(i);
   }
 
   mesh.sendEvent(remove_nodes);
 
   AKANTU_DEBUG_OUT();
 }
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
 /* -------------------------------------------------------------------------- */
 UInt MeshUtils::insertCohesiveElements(
     Mesh & mesh, Mesh & mesh_facets,
     const ElementTypeMapArray<bool> & facet_insertion,
     Array<UInt> & doubled_nodes, Array<Element> & new_elements,
     bool only_double_facets) {
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt elements_to_insert = updateFacetToDouble(mesh_facets, facet_insertion);
 
   if (elements_to_insert > 0) {
 
     if (spatial_dimension == 1) {
       doublePointFacet(mesh, mesh_facets, doubled_nodes);
     } else {
       doubleFacet(mesh, mesh_facets, spatial_dimension - 1, doubled_nodes,
                   true);
       findSubfacetToDouble<false>(mesh, mesh_facets);
 
       if (spatial_dimension == 2) {
         doubleSubfacet<2>(mesh, mesh_facets, doubled_nodes);
       } else if (spatial_dimension == 3) {
         doubleFacet(mesh, mesh_facets, 1, doubled_nodes, false);
         findSubfacetToDouble<true>(mesh, mesh_facets);
         doubleSubfacet<3>(mesh, mesh_facets, doubled_nodes);
       }
     }
 
     if (!only_double_facets)
       updateCohesiveData(mesh, mesh_facets, new_elements);
   }
 
   return elements_to_insert;
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::doubleNodes(Mesh & mesh, const std::vector<UInt> & old_nodes,
                             Array<UInt> & doubled_nodes) {
   AKANTU_DEBUG_IN();
 
   Array<Real> & position = mesh.getNodes();
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   UInt old_nb_nodes = position.size();
   UInt new_nb_nodes = old_nb_nodes + old_nodes.size();
 
   UInt old_nb_doubled_nodes = doubled_nodes.size();
   UInt new_nb_doubled_nodes = old_nb_doubled_nodes + old_nodes.size();
 
   position.resize(new_nb_nodes);
   doubled_nodes.resize(new_nb_doubled_nodes);
 
   Array<Real>::iterator<Vector<Real>> position_begin =
       position.begin(spatial_dimension);
 
   for (UInt n = 0; n < old_nodes.size(); ++n) {
     UInt new_node = old_nb_nodes + n;
 
     /// store doubled nodes
     doubled_nodes(old_nb_doubled_nodes + n, 0) = old_nodes[n];
     doubled_nodes(old_nb_doubled_nodes + n, 1) = new_node;
 
     /// update position
     std::copy(position_begin + old_nodes[n], position_begin + old_nodes[n] + 1,
               position_begin + new_node);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::doubleFacet(Mesh & mesh, Mesh & mesh_facets,
                             UInt facet_dimension, Array<UInt> & doubled_nodes,
                             bool facet_mode) {
   AKANTU_DEBUG_IN();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType gt_facet = *gt;
 
     Mesh::type_iterator it = mesh_facets.firstType(facet_dimension, gt_facet);
     Mesh::type_iterator end = mesh_facets.lastType(facet_dimension, gt_facet);
 
     for (; it != end; ++it) {
 
       ElementType type_facet = *it;
 
       Array<UInt> & f_to_double =
           mesh_facets.getData<UInt>("facet_to_double", type_facet, gt_facet);
       UInt nb_facet_to_double = f_to_double.size();
 
       if (nb_facet_to_double == 0)
         continue;
 
       ElementType type_subfacet = Mesh::getFacetType(type_facet);
       const UInt nb_subfacet_per_facet =
           Mesh::getNbFacetsPerElement(type_facet);
       GhostType gt_subfacet = _casper;
       Array<std::vector<Element>> * f_to_subfacet = nullptr;
 
       Array<Element> & subfacet_to_facet =
           mesh_facets.getSubelementToElement(type_facet, gt_facet);
 
       Array<UInt> & conn_facet =
           mesh_facets.getConnectivity(type_facet, gt_facet);
       UInt nb_nodes_per_facet = conn_facet.getNbComponent();
 
       UInt old_nb_facet = conn_facet.size();
       UInt new_nb_facet = old_nb_facet + nb_facet_to_double;
 
       conn_facet.resize(new_nb_facet);
       subfacet_to_facet.resize(new_nb_facet);
 
       UInt new_facet = old_nb_facet - 1;
       Element new_facet_el{type_facet, 0, gt_facet};
 
       Array<Element>::iterator<Vector<Element>> subfacet_to_facet_begin =
           subfacet_to_facet.begin(nb_subfacet_per_facet);
       Array<UInt>::iterator<Vector<UInt>> conn_facet_begin =
           conn_facet.begin(nb_nodes_per_facet);
 
       for (UInt facet = 0; facet < nb_facet_to_double; ++facet) {
         UInt old_facet = f_to_double(facet);
         ++new_facet;
 
         /// adding a new facet by copying original one
 
         /// copy connectivity in new facet
         std::copy(conn_facet_begin + old_facet,
                   conn_facet_begin + old_facet + 1,
                   conn_facet_begin + new_facet);
 
         /// update subfacet_to_facet
         std::copy(subfacet_to_facet_begin + old_facet,
                   subfacet_to_facet_begin + old_facet + 1,
                   subfacet_to_facet_begin + new_facet);
 
         new_facet_el.element = new_facet;
 
         /// loop on every subfacet
         for (UInt sf = 0; sf < nb_subfacet_per_facet; ++sf) {
           Element & subfacet = subfacet_to_facet(old_facet, sf);
           if (subfacet == ElementNull)
             continue;
 
           if (gt_subfacet != subfacet.ghost_type) {
             gt_subfacet = subfacet.ghost_type;
             f_to_subfacet = &mesh_facets.getElementToSubelement(
                 type_subfacet, subfacet.ghost_type);
           }
 
           /// update facet_to_subfacet array
           (*f_to_subfacet)(subfacet.element).push_back(new_facet_el);
         }
       }
 
       /// update facet_to_subfacet and _segment_3 facets if any
       if (!facet_mode) {
         updateSubfacetToFacet(mesh_facets, type_facet, gt_facet, true);
         updateFacetToSubfacet(mesh_facets, type_facet, gt_facet, true);
         updateQuadraticSegments<true>(mesh, mesh_facets, type_facet, gt_facet,
                                       doubled_nodes);
       } else
         updateQuadraticSegments<false>(mesh, mesh_facets, type_facet, gt_facet,
                                        doubled_nodes);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 UInt MeshUtils::updateFacetToDouble(
     Mesh & mesh_facets, const ElementTypeMapArray<bool> & facet_insertion) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh_facets.getSpatialDimension();
   UInt nb_facets_to_double = 0.;
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType gt_facet = *gt;
 
     Mesh::type_iterator it =
         mesh_facets.firstType(spatial_dimension - 1, gt_facet);
     Mesh::type_iterator end =
         mesh_facets.lastType(spatial_dimension - 1, gt_facet);
 
     for (; it != end; ++it) {
 
       ElementType type_facet = *it;
 
       const Array<bool> & f_insertion = facet_insertion(type_facet, gt_facet);
       Array<UInt> & f_to_double =
           mesh_facets.getData<UInt>("facet_to_double", type_facet, gt_facet);
 
       Array<std::vector<Element>> & element_to_facet =
           mesh_facets.getElementToSubelement(type_facet, gt_facet);
 
       ElementType el_type = _not_defined;
       GhostType el_gt = _casper;
       UInt nb_facet_per_element = 0;
       Element old_facet_el{type_facet, 0, gt_facet};
 
       Array<Element> * facet_to_element = nullptr;
 
       for (UInt f = 0; f < f_insertion.size(); ++f) {
 
         if (f_insertion(f) == false)
           continue;
 
         ++nb_facets_to_double;
 
         if (element_to_facet(f)[1].type == _not_defined
 #if defined(AKANTU_COHESIVE_ELEMENT)
             || element_to_facet(f)[1].kind() == _ek_cohesive
 #endif
         ) {
           AKANTU_DEBUG_WARNING("attempt to double a facet on the boundary");
           continue;
         }
 
         f_to_double.push_back(f);
 
         UInt new_facet = mesh_facets.getNbElement(type_facet, gt_facet) +
                          f_to_double.size() - 1;
         old_facet_el.element = f;
 
         /// update facet_to_element vector
         Element & elem_to_update = element_to_facet(f)[1];
         UInt el = elem_to_update.element;
 
         if (elem_to_update.ghost_type != el_gt ||
             elem_to_update.type != el_type) {
           el_type = elem_to_update.type;
           el_gt = elem_to_update.ghost_type;
           facet_to_element =
               &mesh_facets.getSubelementToElement(el_type, el_gt);
           nb_facet_per_element = facet_to_element->getNbComponent();
         }
 
         Element * f_update =
             std::find(facet_to_element->storage() + el * nb_facet_per_element,
                       facet_to_element->storage() + el * nb_facet_per_element +
                           nb_facet_per_element,
                       old_facet_el);
 
         AKANTU_DEBUG_ASSERT(
             facet_to_element->storage() + el * nb_facet_per_element !=
                 facet_to_element->storage() + el * nb_facet_per_element +
                     nb_facet_per_element,
             "Facet not found");
 
         f_update->element = new_facet;
 
         /// update elements connected to facet
         std::vector<Element> first_facet_list = element_to_facet(f);
         element_to_facet.push_back(first_facet_list);
 
         /// set new and original facets as boundary facets
         element_to_facet(new_facet)[0] = element_to_facet(new_facet)[1];
 
         element_to_facet(f)[1] = ElementNull;
         element_to_facet(new_facet)[1] = ElementNull;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
   return nb_facets_to_double;
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::resetFacetToDouble(Mesh & mesh_facets) {
   AKANTU_DEBUG_IN();
 
   for (UInt g = _not_ghost; g <= _ghost; ++g) {
-    GhostType gt = (GhostType)g;
+    auto gt = (GhostType)g;
 
     Mesh::type_iterator it = mesh_facets.firstType(_all_dimensions, gt);
     Mesh::type_iterator end = mesh_facets.lastType(_all_dimensions, gt);
     for (; it != end; ++it) {
       ElementType type = *it;
       mesh_facets.getDataPointer<UInt>("facet_to_double", type, gt, 1, false);
 
       mesh_facets.getDataPointer<std::vector<Element>>(
           "facets_to_subfacet_double", type, gt, 1, false);
 
       mesh_facets.getDataPointer<std::vector<Element>>(
           "elements_to_subfacet_double", type, gt, 1, false);
 
       mesh_facets.getDataPointer<std::vector<Element>>(
           "subfacets_to_subsubfacet_double", type, gt, 1, false);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool subsubfacet_mode>
 void MeshUtils::findSubfacetToDouble(Mesh & mesh, Mesh & mesh_facets) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh_facets.getSpatialDimension();
   if (spatial_dimension == 1)
     return;
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType gt_facet = *gt;
 
     Mesh::type_iterator it =
         mesh_facets.firstType(spatial_dimension - 1, gt_facet);
     Mesh::type_iterator end =
         mesh_facets.lastType(spatial_dimension - 1, gt_facet);
 
     for (; it != end; ++it) {
 
       ElementType type_facet = *it;
 
       Array<UInt> & f_to_double =
           mesh_facets.getData<UInt>("facet_to_double", type_facet, gt_facet);
       UInt nb_facet_to_double = f_to_double.size();
       if (nb_facet_to_double == 0)
         continue;
 
       ElementType type_subfacet = Mesh::getFacetType(type_facet);
       GhostType gt_subfacet = _casper;
 
       ElementType type_subsubfacet = Mesh::getFacetType(type_subfacet);
       GhostType gt_subsubfacet = _casper;
 
       Array<UInt> * conn_subfacet = nullptr;
       Array<UInt> * sf_to_double = nullptr;
       Array<std::vector<Element>> * sf_to_subfacet_double = nullptr;
       Array<std::vector<Element>> * f_to_subfacet_double = nullptr;
       Array<std::vector<Element>> * el_to_subfacet_double = nullptr;
 
       UInt nb_subfacet = Mesh::getNbFacetsPerElement(type_facet);
 
       UInt nb_subsubfacet;
       UInt nb_nodes_per_sf_el;
 
       if (subsubfacet_mode) {
         nb_nodes_per_sf_el = Mesh::getNbNodesPerElement(type_subsubfacet);
         nb_subsubfacet = Mesh::getNbFacetsPerElement(type_subfacet);
       } else
         nb_nodes_per_sf_el = Mesh::getNbNodesPerElement(type_subfacet);
 
       Array<Element> & subfacet_to_facet =
           mesh_facets.getSubelementToElement(type_facet, gt_facet);
 
       Array<std::vector<Element>> & element_to_facet =
           mesh_facets.getElementToSubelement(type_facet, gt_facet);
 
       Array<Element> * subsubfacet_to_subfacet = nullptr;
 
       UInt old_nb_facet = subfacet_to_facet.size() - nb_facet_to_double;
 
       Element current_facet{type_facet, 0, gt_facet};
       std::vector<Element> element_list;
       std::vector<Element> facet_list;
       std::vector<Element> * subfacet_list;
       if (subsubfacet_mode)
         subfacet_list = new std::vector<Element>;
 
       /// map to filter subfacets
       Array<std::vector<Element>> * facet_to_subfacet = nullptr;
 
       /// this is used to make sure that both new and old facets are
       /// checked
       UInt facets[2];
 
       /// loop on every facet
       for (UInt f_index = 0; f_index < 2; ++f_index) {
         for (UInt facet = 0; facet < nb_facet_to_double; ++facet) {
           facets[bool(f_index)] = f_to_double(facet);
           facets[!bool(f_index)] = old_nb_facet + facet;
 
           UInt old_facet = facets[0];
           UInt new_facet = facets[1];
 
           Element & starting_element = element_to_facet(new_facet)[0];
           current_facet.element = old_facet;
 
           /// loop on every subfacet
           for (UInt sf = 0; sf < nb_subfacet; ++sf) {
 
             Element & subfacet = subfacet_to_facet(old_facet, sf);
             if (subfacet == ElementNull)
               continue;
 
             if (gt_subfacet != subfacet.ghost_type) {
               gt_subfacet = subfacet.ghost_type;
 
               if (subsubfacet_mode) {
                 subsubfacet_to_subfacet = &mesh_facets.getSubelementToElement(
                     type_subfacet, gt_subfacet);
               } else {
                 conn_subfacet =
                     &mesh_facets.getConnectivity(type_subfacet, gt_subfacet);
                 sf_to_double = &mesh_facets.getData<UInt>(
                     "facet_to_double", type_subfacet, gt_subfacet);
 
                 f_to_subfacet_double =
                     &mesh_facets.getData<std::vector<Element>>(
                         "facets_to_subfacet_double", type_subfacet,
                         gt_subfacet);
 
                 el_to_subfacet_double =
                     &mesh_facets.getData<std::vector<Element>>(
                         "elements_to_subfacet_double", type_subfacet,
                         gt_subfacet);
 
                 facet_to_subfacet = &mesh_facets.getElementToSubelement(
                     type_subfacet, gt_subfacet);
               }
             }
 
             if (subsubfacet_mode) {
               /// loop on every subsubfacet
               for (UInt ssf = 0; ssf < nb_subsubfacet; ++ssf) {
                 Element & subsubfacet =
                     (*subsubfacet_to_subfacet)(subfacet.element, ssf);
 
                 if (subsubfacet == ElementNull)
                   continue;
 
                 if (gt_subsubfacet != subsubfacet.ghost_type) {
                   gt_subsubfacet = subsubfacet.ghost_type;
                   conn_subfacet = &mesh_facets.getConnectivity(type_subsubfacet,
                                                                gt_subsubfacet);
                   sf_to_double = &mesh_facets.getData<UInt>(
                       "facet_to_double", type_subsubfacet, gt_subsubfacet);
 
                   sf_to_subfacet_double =
                       &mesh_facets.getData<std::vector<Element>>(
                           "subfacets_to_subsubfacet_double", type_subsubfacet,
                           gt_subsubfacet);
 
                   f_to_subfacet_double =
                       &mesh_facets.getData<std::vector<Element>>(
                           "facets_to_subfacet_double", type_subsubfacet,
                           gt_subsubfacet);
 
                   el_to_subfacet_double =
                       &mesh_facets.getData<std::vector<Element>>(
                           "elements_to_subfacet_double", type_subsubfacet,
                           gt_subsubfacet);
 
                   facet_to_subfacet = &mesh_facets.getElementToSubelement(
                       type_subsubfacet, gt_subsubfacet);
                 }
 
                 UInt global_ssf = subsubfacet.element;
 
                 Vector<UInt> subsubfacet_connectivity(
                     conn_subfacet->storage() + global_ssf * nb_nodes_per_sf_el,
                     nb_nodes_per_sf_el);
 
                 /// check if subsubfacet is to be doubled
                 if (findElementsAroundSubfacet<true>(
                         mesh, mesh_facets, starting_element, current_facet,
                         subsubfacet_connectivity, element_list, facet_list,
                         subfacet_list) == false &&
                     removeElementsInVector(*subfacet_list,
                                            (*facet_to_subfacet)(global_ssf)) ==
                         false) {
 
                   sf_to_double->push_back(global_ssf);
                   sf_to_subfacet_double->push_back(*subfacet_list);
                   f_to_subfacet_double->push_back(facet_list);
                   el_to_subfacet_double->push_back(element_list);
                 }
               }
             } else {
               const UInt global_sf = subfacet.element;
 
               Vector<UInt> subfacet_connectivity(
                   conn_subfacet->storage() + global_sf * nb_nodes_per_sf_el,
                   nb_nodes_per_sf_el);
 
               /// check if subfacet is to be doubled
               if (findElementsAroundSubfacet<false>(
                       mesh, mesh_facets, starting_element, current_facet,
                       subfacet_connectivity, element_list,
                       facet_list) == false &&
                   removeElementsInVector(
                       facet_list, (*facet_to_subfacet)(global_sf)) == false) {
 
                 sf_to_double->push_back(global_sf);
                 f_to_subfacet_double->push_back(facet_list);
                 el_to_subfacet_double->push_back(element_list);
               }
             }
           }
         }
       }
 
       if (subsubfacet_mode)
         delete subfacet_list;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_COHESIVE_ELEMENT)
 void MeshUtils::updateCohesiveData(Mesh & mesh, Mesh & mesh_facets,
                                    Array<Element> & new_elements) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   bool third_dimension = spatial_dimension == 3;
 
   MeshAccessor mesh_facets_accessor(mesh_facets);
 
   for (auto gt_facet : ghost_types) {
     for (auto type_facet :
          mesh_facets.elementTypes(spatial_dimension - 1, gt_facet)) {
 
       Array<UInt> & f_to_double =
           mesh_facets.getData<UInt>("facet_to_double", type_facet, gt_facet);
 
       UInt nb_facet_to_double = f_to_double.size();
       if (nb_facet_to_double == 0)
         continue;
 
       ElementType type_cohesive = FEEngine::getCohesiveElementType(type_facet);
 
       auto & facet_to_coh_element =
           mesh_facets_accessor.getSubelementToElement(type_cohesive, gt_facet);
 
       auto & conn_facet = mesh_facets.getConnectivity(type_facet, gt_facet);
       auto & conn_cohesive = mesh.getConnectivity(type_cohesive, gt_facet);
       UInt nb_nodes_per_facet = Mesh::getNbNodesPerElement(type_facet);
 
       Array<std::vector<Element>> & element_to_facet =
           mesh_facets.getElementToSubelement(type_facet, gt_facet);
 
       UInt old_nb_cohesive_elements = conn_cohesive.size();
       UInt new_nb_cohesive_elements = conn_cohesive.size() + nb_facet_to_double;
 
       UInt old_nb_facet = element_to_facet.size() - nb_facet_to_double;
       facet_to_coh_element.resize(new_nb_cohesive_elements);
       conn_cohesive.resize(new_nb_cohesive_elements);
 
       UInt new_elements_old_size = new_elements.size();
       new_elements.resize(new_elements_old_size + nb_facet_to_double);
 
       Element c_element{type_cohesive, 0, gt_facet};
       Element f_element{type_facet, 0, gt_facet};
 
       UInt facets[2];
 
       for (UInt facet = 0; facet < nb_facet_to_double; ++facet) {
 
         /// (in 3D cohesive elements connectivity is inverted)
         facets[third_dimension] = f_to_double(facet);
         facets[!third_dimension] = old_nb_facet + facet;
 
         UInt cohesive_element = old_nb_cohesive_elements + facet;
 
         /// store doubled facets
         f_element.element = facets[0];
         facet_to_coh_element(cohesive_element, 0) = f_element;
         f_element.element = facets[1];
         facet_to_coh_element(cohesive_element, 1) = f_element;
 
         /// modify cohesive elements' connectivity
         for (UInt n = 0; n < nb_nodes_per_facet; ++n) {
           conn_cohesive(cohesive_element, n) = conn_facet(facets[0], n);
           conn_cohesive(cohesive_element, n + nb_nodes_per_facet) =
               conn_facet(facets[1], n);
         }
 
         /// update element_to_facet vectors
         c_element.element = cohesive_element;
         element_to_facet(facets[0])[1] = c_element;
         element_to_facet(facets[1])[1] = c_element;
 
         /// add cohesive element to the element event list
         new_elements(new_elements_old_size + facet) = c_element;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::doublePointFacet(Mesh & mesh, Mesh & mesh_facets,
                                  Array<UInt> & doubled_nodes) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   if (spatial_dimension != 1)
     return;
 
   Array<Real> & position = mesh.getNodes();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType gt_facet = *gt;
 
     Mesh::type_iterator it =
         mesh_facets.firstType(spatial_dimension - 1, gt_facet);
     Mesh::type_iterator end =
         mesh_facets.lastType(spatial_dimension - 1, gt_facet);
 
     for (; it != end; ++it) {
 
       ElementType type_facet = *it;
 
       Array<UInt> & conn_facet =
           mesh_facets.getConnectivity(type_facet, gt_facet);
       Array<std::vector<Element>> & element_to_facet =
           mesh_facets.getElementToSubelement(type_facet, gt_facet);
 
       const Array<UInt> & f_to_double =
           mesh_facets.getData<UInt>("facet_to_double", type_facet, gt_facet);
 
       UInt nb_facet_to_double = f_to_double.size();
 
       UInt old_nb_facet = element_to_facet.size() - nb_facet_to_double;
       UInt new_nb_facet = element_to_facet.size();
 
       UInt old_nb_nodes = position.size();
       UInt new_nb_nodes = old_nb_nodes + nb_facet_to_double;
 
       position.resize(new_nb_nodes);
       conn_facet.resize(new_nb_facet);
 
       UInt old_nb_doubled_nodes = doubled_nodes.size();
       doubled_nodes.resize(old_nb_doubled_nodes + nb_facet_to_double);
 
       for (UInt facet = 0; facet < nb_facet_to_double; ++facet) {
         UInt old_facet = f_to_double(facet);
         UInt new_facet = old_nb_facet + facet;
 
         ElementType type = element_to_facet(new_facet)[0].type;
         UInt el = element_to_facet(new_facet)[0].element;
         GhostType gt = element_to_facet(new_facet)[0].ghost_type;
 
         UInt old_node = conn_facet(old_facet);
         UInt new_node = old_nb_nodes + facet;
 
         /// update position
         position(new_node) = position(old_node);
 
         conn_facet(new_facet) = new_node;
         Array<UInt> & conn_segment = mesh.getConnectivity(type, gt);
         UInt nb_nodes_per_segment = conn_segment.getNbComponent();
 
         /// update facet connectivity
         UInt i;
         for (i = 0;
              conn_segment(el, i) != old_node && i <= nb_nodes_per_segment; ++i)
           ;
         conn_segment(el, i) = new_node;
 
         doubled_nodes(old_nb_doubled_nodes + facet, 0) = old_node;
         doubled_nodes(old_nb_doubled_nodes + facet, 1) = new_node;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool third_dim_segments>
 void MeshUtils::updateQuadraticSegments(Mesh & mesh, Mesh & mesh_facets,
                                         ElementType type_facet,
                                         GhostType gt_facet,
                                         Array<UInt> & doubled_nodes) {
   AKANTU_DEBUG_IN();
 
   if (type_facet != _segment_3)
     return;
 
   Array<UInt> & f_to_double =
       mesh_facets.getData<UInt>("facet_to_double", type_facet, gt_facet);
   UInt nb_facet_to_double = f_to_double.size();
 
   UInt old_nb_facet =
       mesh_facets.getNbElement(type_facet, gt_facet) - nb_facet_to_double;
 
   Array<UInt> & conn_facet = mesh_facets.getConnectivity(type_facet, gt_facet);
 
   Array<std::vector<Element>> & element_to_facet =
       mesh_facets.getElementToSubelement(type_facet, gt_facet);
 
   /// this ones matter only for segments in 3D
   Array<std::vector<Element>> * el_to_subfacet_double = nullptr;
   Array<std::vector<Element>> * f_to_subfacet_double = nullptr;
 
   if (third_dim_segments) {
     el_to_subfacet_double = &mesh_facets.getData<std::vector<Element>>(
         "elements_to_subfacet_double", type_facet, gt_facet);
 
     f_to_subfacet_double = &mesh_facets.getData<std::vector<Element>>(
         "facets_to_subfacet_double", type_facet, gt_facet);
   }
 
   std::vector<UInt> middle_nodes;
 
   for (UInt facet = 0; facet < nb_facet_to_double; ++facet) {
     UInt old_facet = f_to_double(facet);
     UInt node = conn_facet(old_facet, 2);
     if (!mesh.isPureGhostNode(node))
       middle_nodes.push_back(node);
   }
 
   UInt n = doubled_nodes.size();
 
   doubleNodes(mesh, middle_nodes, doubled_nodes);
 
   for (UInt facet = 0; facet < nb_facet_to_double; ++facet) {
     UInt old_facet = f_to_double(facet);
     UInt old_node = conn_facet(old_facet, 2);
     if (mesh.isPureGhostNode(old_node))
       continue;
 
     UInt new_node = doubled_nodes(n, 1);
     UInt new_facet = old_nb_facet + facet;
 
     conn_facet(new_facet, 2) = new_node;
 
     if (third_dim_segments) {
       updateElementalConnectivity(mesh_facets, old_node, new_node,
                                   element_to_facet(new_facet));
 
       updateElementalConnectivity(mesh, old_node, new_node,
                                   (*el_to_subfacet_double)(facet),
                                   &(*f_to_subfacet_double)(facet));
     } else {
       updateElementalConnectivity(mesh, old_node, new_node,
                                   element_to_facet(new_facet));
     }
     ++n;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::updateSubfacetToFacet(Mesh & mesh_facets,
                                       ElementType type_subfacet,
                                       GhostType gt_subfacet, bool facet_mode) {
   AKANTU_DEBUG_IN();
 
   Array<UInt> & sf_to_double =
       mesh_facets.getData<UInt>("facet_to_double", type_subfacet, gt_subfacet);
   UInt nb_subfacet_to_double = sf_to_double.size();
 
   /// update subfacet_to_facet vector
   ElementType type_facet = _not_defined;
   GhostType gt_facet = _casper;
   Array<Element> * subfacet_to_facet = nullptr;
   UInt nb_subfacet_per_facet = 0;
   UInt old_nb_subfacet = mesh_facets.getNbElement(type_subfacet, gt_subfacet) -
                          nb_subfacet_to_double;
 
   Array<std::vector<Element>> * facet_list = nullptr;
   if (facet_mode)
     facet_list = &mesh_facets.getData<std::vector<Element>>(
         "facets_to_subfacet_double", type_subfacet, gt_subfacet);
   else
     facet_list = &mesh_facets.getData<std::vector<Element>>(
         "subfacets_to_subsubfacet_double", type_subfacet, gt_subfacet);
 
   Element old_subfacet_el{type_subfacet, 0, gt_subfacet};
   Element new_subfacet_el{type_subfacet, 0, gt_subfacet};
 
   for (UInt sf = 0; sf < nb_subfacet_to_double; ++sf) {
     old_subfacet_el.element = sf_to_double(sf);
     new_subfacet_el.element = old_nb_subfacet + sf;
 
     for (UInt f = 0; f < (*facet_list)(sf).size(); ++f) {
       Element & facet = (*facet_list)(sf)[f];
 
       if (facet.type != type_facet || facet.ghost_type != gt_facet) {
         type_facet = facet.type;
         gt_facet = facet.ghost_type;
 
         subfacet_to_facet =
             &mesh_facets.getSubelementToElement(type_facet, gt_facet);
         nb_subfacet_per_facet = subfacet_to_facet->getNbComponent();
       }
 
       Element * sf_update = std::find(
           subfacet_to_facet->storage() + facet.element * nb_subfacet_per_facet,
           subfacet_to_facet->storage() + facet.element * nb_subfacet_per_facet +
               nb_subfacet_per_facet,
           old_subfacet_el);
 
       AKANTU_DEBUG_ASSERT(subfacet_to_facet->storage() +
                                   facet.element * nb_subfacet_per_facet !=
                               subfacet_to_facet->storage() +
                                   facet.element * nb_subfacet_per_facet +
                                   nb_subfacet_per_facet,
                           "Subfacet not found");
 
       *sf_update = new_subfacet_el;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::updateFacetToSubfacet(Mesh & mesh_facets,
                                       ElementType type_subfacet,
                                       GhostType gt_subfacet, bool facet_mode) {
   AKANTU_DEBUG_IN();
 
   Array<UInt> & sf_to_double =
       mesh_facets.getData<UInt>("facet_to_double", type_subfacet, gt_subfacet);
   UInt nb_subfacet_to_double = sf_to_double.size();
 
   Array<std::vector<Element>> & facet_to_subfacet =
       mesh_facets.getElementToSubelement(type_subfacet, gt_subfacet);
 
   Array<std::vector<Element>> * facet_to_subfacet_double = nullptr;
 
   if (facet_mode) {
     facet_to_subfacet_double = &mesh_facets.getData<std::vector<Element>>(
         "facets_to_subfacet_double", type_subfacet, gt_subfacet);
   } else {
     facet_to_subfacet_double = &mesh_facets.getData<std::vector<Element>>(
         "subfacets_to_subsubfacet_double", type_subfacet, gt_subfacet);
   }
 
   UInt old_nb_subfacet = facet_to_subfacet.size();
   facet_to_subfacet.resize(old_nb_subfacet + nb_subfacet_to_double);
 
   for (UInt sf = 0; sf < nb_subfacet_to_double; ++sf)
     facet_to_subfacet(old_nb_subfacet + sf) = (*facet_to_subfacet_double)(sf);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MeshUtils::doubleSubfacet(Mesh & mesh, Mesh & mesh_facets,
                                Array<UInt> & doubled_nodes) {
   AKANTU_DEBUG_IN();
 
   if (spatial_dimension == 1)
     return;
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType gt_subfacet = *gt;
 
     Mesh::type_iterator it = mesh_facets.firstType(0, gt_subfacet);
     Mesh::type_iterator end = mesh_facets.lastType(0, gt_subfacet);
 
     for (; it != end; ++it) {
 
       ElementType type_subfacet = *it;
 
       Array<UInt> & sf_to_double = mesh_facets.getData<UInt>(
           "facet_to_double", type_subfacet, gt_subfacet);
       UInt nb_subfacet_to_double = sf_to_double.size();
 
       if (nb_subfacet_to_double == 0)
         continue;
 
       AKANTU_DEBUG_ASSERT(
           type_subfacet == _point_1,
           "Only _point_1 subfacet doubling is supported at the moment");
 
       Array<UInt> & conn_subfacet =
           mesh_facets.getConnectivity(type_subfacet, gt_subfacet);
 
       UInt old_nb_subfacet = conn_subfacet.size();
       UInt new_nb_subfacet = old_nb_subfacet + nb_subfacet_to_double;
 
       conn_subfacet.resize(new_nb_subfacet);
 
       std::vector<UInt> nodes_to_double;
       UInt old_nb_doubled_nodes = doubled_nodes.size();
 
       /// double nodes
       for (UInt sf = 0; sf < nb_subfacet_to_double; ++sf) {
         UInt old_subfacet = sf_to_double(sf);
         nodes_to_double.push_back(conn_subfacet(old_subfacet));
       }
 
       doubleNodes(mesh, nodes_to_double, doubled_nodes);
 
       /// add new nodes in connectivity
       for (UInt sf = 0; sf < nb_subfacet_to_double; ++sf) {
         UInt new_subfacet = old_nb_subfacet + sf;
         UInt new_node = doubled_nodes(old_nb_doubled_nodes + sf, 1);
 
         conn_subfacet(new_subfacet) = new_node;
       }
 
       /// update facet and element connectivity
       Array<std::vector<Element>> & f_to_subfacet_double =
           mesh_facets.getData<std::vector<Element>>("facets_to_subfacet_double",
                                                     type_subfacet, gt_subfacet);
 
       Array<std::vector<Element>> & el_to_subfacet_double =
           mesh_facets.getData<std::vector<Element>>(
               "elements_to_subfacet_double", type_subfacet, gt_subfacet);
 
       Array<std::vector<Element>> * sf_to_subfacet_double = nullptr;
 
       if (spatial_dimension == 3)
         sf_to_subfacet_double = &mesh_facets.getData<std::vector<Element>>(
             "subfacets_to_subsubfacet_double", type_subfacet, gt_subfacet);
 
       for (UInt sf = 0; sf < nb_subfacet_to_double; ++sf) {
         UInt old_node = doubled_nodes(old_nb_doubled_nodes + sf, 0);
         UInt new_node = doubled_nodes(old_nb_doubled_nodes + sf, 1);
 
         updateElementalConnectivity(mesh, old_node, new_node,
                                     el_to_subfacet_double(sf),
                                     &f_to_subfacet_double(sf));
 
         updateElementalConnectivity(mesh_facets, old_node, new_node,
                                     f_to_subfacet_double(sf));
 
         if (spatial_dimension == 3)
           updateElementalConnectivity(mesh_facets, old_node, new_node,
                                       (*sf_to_subfacet_double)(sf));
       }
 
       if (spatial_dimension == 2) {
         updateSubfacetToFacet(mesh_facets, type_subfacet, gt_subfacet, true);
         updateFacetToSubfacet(mesh_facets, type_subfacet, gt_subfacet, true);
       } else if (spatial_dimension == 3) {
         updateSubfacetToFacet(mesh_facets, type_subfacet, gt_subfacet, false);
         updateFacetToSubfacet(mesh_facets, type_subfacet, gt_subfacet, false);
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::flipFacets(
     Mesh & mesh_facets, const ElementTypeMapArray<UInt> & global_connectivity,
     GhostType gt_facet) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh_facets.getSpatialDimension();
 
   /// get global connectivity for local mesh
   ElementTypeMapArray<UInt> global_connectivity_tmp("global_connectivity_tmp",
                                                     mesh_facets.getID(),
                                                     mesh_facets.getMemoryID());
 
   global_connectivity_tmp.initialize(
       mesh_facets, _spatial_dimension = spatial_dimension - 1,
       _with_nb_nodes_per_element = true, _with_nb_element = true);
 
   mesh_facets.getGlobalConnectivity(global_connectivity_tmp);
 
   /// loop on every facet
   for (auto type_facet :
        mesh_facets.elementTypes(spatial_dimension - 1, gt_facet)) {
 
     auto & connectivity = mesh_facets.getConnectivity(type_facet, gt_facet);
     const auto & g_connectivity = global_connectivity(type_facet, gt_facet);
 
     auto & el_to_f = mesh_facets.getElementToSubelement(type_facet, gt_facet);
     auto & subfacet_to_facet =
         mesh_facets.getSubelementToElement(type_facet, gt_facet);
 
     UInt nb_subfacet_per_facet = subfacet_to_facet.getNbComponent();
     UInt nb_nodes_per_facet = connectivity.getNbComponent();
     UInt nb_facet = connectivity.size();
 
     UInt nb_nodes_per_P1_facet =
         Mesh::getNbNodesPerElement(Mesh::getP1ElementType(type_facet));
 
     auto & global_conn_tmp = global_connectivity_tmp(type_facet, gt_facet);
 
     auto conn_it = connectivity.begin(nb_nodes_per_facet);
     auto gconn_tmp_it = global_conn_tmp.begin(nb_nodes_per_facet);
     auto conn_glob_it = g_connectivity.begin(nb_nodes_per_facet);
     auto subf_to_f = subfacet_to_facet.begin(nb_subfacet_per_facet);
 
-    UInt * conn_tmp_pointer = new UInt[nb_nodes_per_facet];
+    auto * conn_tmp_pointer = new UInt[nb_nodes_per_facet];
     Vector<UInt> conn_tmp(conn_tmp_pointer, nb_nodes_per_facet);
 
     Element el_tmp;
-    Element * subf_tmp_pointer = new Element[nb_subfacet_per_facet];
+    auto * subf_tmp_pointer = new Element[nb_subfacet_per_facet];
     Vector<Element> subf_tmp(subf_tmp_pointer, nb_subfacet_per_facet);
 
     for (UInt f = 0; f < nb_facet;
          ++f, ++conn_it, ++gconn_tmp_it, ++subf_to_f, ++conn_glob_it) {
 
       Vector<UInt> & gconn_tmp = *gconn_tmp_it;
       const Vector<UInt> & conn_glob = *conn_glob_it;
       Vector<UInt> & conn_local = *conn_it;
 
       /// skip facet if connectivities are the same
       if (gconn_tmp == conn_glob)
         continue;
 
       /// re-arrange connectivity
       conn_tmp = conn_local;
 
       UInt * begin = conn_glob.storage();
       UInt * end = conn_glob.storage() + nb_nodes_per_facet;
 
       for (UInt n = 0; n < nb_nodes_per_facet; ++n) {
 
         UInt * new_node = std::find(begin, end, gconn_tmp(n));
         AKANTU_DEBUG_ASSERT(new_node != end, "Node not found");
 
         UInt new_position = new_node - begin;
 
         conn_local(new_position) = conn_tmp(n);
       }
 
       /// if 3D, check if facets are just rotated
       if (spatial_dimension == 3) {
         /// find first node
         UInt * new_node = std::find(begin, end, gconn_tmp(0));
         AKANTU_DEBUG_ASSERT(new_node != end, "Node not found");
 
         UInt new_position = new_node - begin;
         UInt n = 1;
 
         /// count how many nodes in the received connectivity follow
         /// the same order of those in the local connectivity
         for (; n < nb_nodes_per_P1_facet &&
                gconn_tmp(n) ==
                    conn_glob((new_position + n) % nb_nodes_per_P1_facet);
              ++n)
           ;
 
         /// skip the facet inversion if facet is just rotated
         if (n == nb_nodes_per_P1_facet)
           continue;
       }
 
       /// update data to invert facet
       el_tmp = el_to_f(f)[0];
       el_to_f(f)[0] = el_to_f(f)[1];
       el_to_f(f)[1] = el_tmp;
 
       subf_tmp = (*subf_to_f);
       (*subf_to_f)(0) = subf_tmp(1);
       (*subf_to_f)(1) = subf_tmp(0);
     }
 
     delete[] subf_tmp_pointer;
     delete[] conn_tmp_pointer;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::fillElementToSubElementsData(Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   if (mesh.getNbElement(mesh.getSpatialDimension() - 1) == 0) {
     AKANTU_DEBUG_INFO("There are not facets, add them in the mesh file or call "
                       "the buildFacet method.");
     return;
   }
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   ElementTypeMapArray<Real> barycenters("barycenter_tmp", mesh.getID(),
                                         mesh.getMemoryID());
   barycenters.initialize(mesh, _nb_component = spatial_dimension,
                          _spatial_dimension = _all_dimensions);
   // mesh.initElementTypeMapArray(barycenters, spatial_dimension,
   // _all_dimensions);
 
   Element element;
   for (auto ghost_type : ghost_types) {
     element.ghost_type = ghost_type;
     for (auto & type : mesh.elementTypes(_all_dimensions, ghost_type)) {
       element.type = type;
 
       UInt nb_element = mesh.getNbElement(type, ghost_type);
       Array<Real> & barycenters_arr = barycenters(type, ghost_type);
       barycenters_arr.resize(nb_element);
       auto bary = barycenters_arr.begin(spatial_dimension);
       auto bary_end = barycenters_arr.end(spatial_dimension);
 
       for (UInt el = 0; bary != bary_end; ++bary, ++el) {
         element.element = el;
         mesh.getBarycenter(element, *bary);
       }
     }
   }
 
   MeshAccessor mesh_accessor(mesh);
   for (Int sp(spatial_dimension); sp >= 1; --sp) {
     if (mesh.getNbElement(sp) == 0)
       continue;
 
     for (auto ghost_type : ghost_types) {
       for (auto & type : mesh.elementTypes(sp, ghost_type)) {
         mesh_accessor.getSubelementToElement(type, ghost_type)
             .resize(mesh.getNbElement(type, ghost_type));
         mesh_accessor.getSubelementToElement(type, ghost_type).clear();
       }
 
       for (auto & type : mesh.elementTypes(sp - 1, ghost_type)) {
         mesh_accessor.getElementToSubelement(type, ghost_type)
             .resize(mesh.getNbElement(type, ghost_type));
         mesh.getElementToSubelement(type, ghost_type).clear();
       }
     }
 
     CSR<Element> nodes_to_elements;
     buildNode2Elements(mesh, nodes_to_elements, sp);
 
     Element facet_element;
 
     for (auto ghost_type : ghost_types) {
       facet_element.ghost_type = ghost_type;
       for (auto & type : mesh.elementTypes(sp - 1, ghost_type)) {
         facet_element.type = type;
 
         auto & element_to_subelement =
             mesh.getElementToSubelement(type, ghost_type);
 
         const auto & connectivity = mesh.getConnectivity(type, ghost_type);
 
         auto fit = connectivity.begin(mesh.getNbNodesPerElement(type));
         auto fend = connectivity.end(mesh.getNbNodesPerElement(type));
 
         UInt fid = 0;
         for (; fit != fend; ++fit, ++fid) {
           const Vector<UInt> & facet = *fit;
           facet_element.element = fid;
           std::map<Element, UInt> element_seen_counter;
           UInt nb_nodes_per_facet =
               mesh.getNbNodesPerElement(Mesh::getP1ElementType(type));
 
           for (UInt n(0); n < nb_nodes_per_facet; ++n) {
 
             auto eit = nodes_to_elements.begin(facet(n));
             auto eend = nodes_to_elements.end(facet(n));
             for (; eit != eend; ++eit) {
               auto & elem = *eit;
               auto cit = element_seen_counter.find(elem);
               if (cit != element_seen_counter.end()) {
                 cit->second++;
               } else {
                 element_seen_counter[elem] = 1;
               }
             }
           }
 
           std::vector<Element> connected_elements;
           auto cit = element_seen_counter.begin();
           auto cend = element_seen_counter.end();
           for (; cit != cend; ++cit) {
             if (cit->second == nb_nodes_per_facet)
               connected_elements.push_back(cit->first);
           }
 
           auto ceit = connected_elements.begin();
           auto ceend = connected_elements.end();
           for (; ceit != ceend; ++ceit)
             element_to_subelement(fid).push_back(*ceit);
 
           for (UInt ce = 0; ce < connected_elements.size(); ++ce) {
             Element & elem = connected_elements[ce];
             Array<Element> & subelement_to_element =
                 mesh_accessor.getSubelementToElement(elem.type,
                                                      elem.ghost_type);
 
             UInt f(0);
             for (; f < mesh.getNbFacetsPerElement(elem.type) &&
                    subelement_to_element(elem.element, f) != ElementNull;
                  ++f)
               ;
 
             AKANTU_DEBUG_ASSERT(
                 f < mesh.getNbFacetsPerElement(elem.type),
                 "The element " << elem << " seems to have too many facets!! ("
                                << f << " < "
                                << mesh.getNbFacetsPerElement(elem.type) << ")");
 
             subelement_to_element(elem.element, f) = facet_element;
           }
         }
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool third_dim_points>
 bool MeshUtils::findElementsAroundSubfacet(
     const Mesh & mesh, const Mesh & mesh_facets,
     const Element & starting_element, const Element & end_facet,
     const Vector<UInt> & subfacet_connectivity,
     std::vector<Element> & elem_list, std::vector<Element> & facet_list,
     std::vector<Element> * subfacet_list) {
   AKANTU_DEBUG_IN();
 
   /// preallocated stuff before starting
   bool facet_matched = false;
 
   elem_list.clear();
   facet_list.clear();
 
   if (third_dim_points)
     subfacet_list->clear();
 
   elem_list.push_back(starting_element);
 
   const Array<UInt> * facet_connectivity = nullptr;
   const Array<UInt> * sf_connectivity = nullptr;
   const Array<Element> * facet_to_element = nullptr;
   const Array<Element> * subfacet_to_facet = nullptr;
 
   ElementType current_type = _not_defined;
   GhostType current_ghost_type = _casper;
 
   ElementType current_facet_type = _not_defined;
   GhostType current_facet_ghost_type = _casper;
 
   ElementType current_subfacet_type = _not_defined;
   GhostType current_subfacet_ghost_type = _casper;
 
   const Array<std::vector<Element>> * element_to_facet = nullptr;
 
   const Element * opposing_el = nullptr;
 
   std::queue<Element> elements_to_check;
   elements_to_check.push(starting_element);
 
   /// keep going until there are elements to check
   while (!elements_to_check.empty()) {
 
     /// check current element
     Element & current_el = elements_to_check.front();
 
     if (current_el.type != current_type ||
         current_el.ghost_type != current_ghost_type) {
 
       current_type = current_el.type;
       current_ghost_type = current_el.ghost_type;
 
       facet_to_element =
           &mesh_facets.getSubelementToElement(current_type, current_ghost_type);
     }
 
     /// loop over each facet of the element
     for (UInt f = 0; f < facet_to_element->getNbComponent(); ++f) {
 
       const Element & current_facet =
           (*facet_to_element)(current_el.element, f);
 
       if (current_facet == ElementNull)
         continue;
 
       if (current_facet_type != current_facet.type ||
           current_facet_ghost_type != current_facet.ghost_type) {
 
         current_facet_type = current_facet.type;
         current_facet_ghost_type = current_facet.ghost_type;
 
         element_to_facet = &mesh_facets.getElementToSubelement(
             current_facet_type, current_facet_ghost_type);
         facet_connectivity = &mesh_facets.getConnectivity(
             current_facet_type, current_facet_ghost_type);
 
         if (third_dim_points)
           subfacet_to_facet = &mesh_facets.getSubelementToElement(
               current_facet_type, current_facet_ghost_type);
       }
 
       /// check if end facet is reached
       if (current_facet == end_facet)
         facet_matched = true;
 
       /// add this facet if not already passed
       if (std::find(facet_list.begin(), facet_list.end(), current_facet) ==
               facet_list.end() &&
           hasElement(*facet_connectivity, current_facet,
                      subfacet_connectivity)) {
         facet_list.push_back(current_facet);
 
         if (third_dim_points) {
           /// check subfacets
           for (UInt sf = 0; sf < subfacet_to_facet->getNbComponent(); ++sf) {
             const Element & current_subfacet =
                 (*subfacet_to_facet)(current_facet.element, sf);
 
             if (current_subfacet == ElementNull)
               continue;
 
             if (current_subfacet_type != current_subfacet.type ||
                 current_subfacet_ghost_type != current_subfacet.ghost_type) {
               current_subfacet_type = current_subfacet.type;
               current_subfacet_ghost_type = current_subfacet.ghost_type;
 
               sf_connectivity = &mesh_facets.getConnectivity(
                   current_subfacet_type, current_subfacet_ghost_type);
             }
 
             if (std::find(subfacet_list->begin(), subfacet_list->end(),
                           current_subfacet) == subfacet_list->end() &&
                 hasElement(*sf_connectivity, current_subfacet,
                            subfacet_connectivity))
               subfacet_list->push_back(current_subfacet);
           }
         }
       } else
         continue;
 
       /// consider opposing element
       if ((*element_to_facet)(current_facet.element)[0] == current_el)
         opposing_el = &(*element_to_facet)(current_facet.element)[1];
       else
         opposing_el = &(*element_to_facet)(current_facet.element)[0];
 
       /// skip null elements since they are on a boundary
       if (*opposing_el == ElementNull)
         continue;
 
       /// skip this element if already added
       if (std::find(elem_list.begin(), elem_list.end(), *opposing_el) !=
           elem_list.end())
         continue;
 
       /// only regular elements have to be checked
       if (opposing_el->kind() == _ek_regular)
         elements_to_check.push(*opposing_el);
 
       elem_list.push_back(*opposing_el);
 
 #ifndef AKANTU_NDEBUG
       const Array<UInt> & conn_elem =
           mesh.getConnectivity(opposing_el->type, opposing_el->ghost_type);
 
       AKANTU_DEBUG_ASSERT(
           hasElement(conn_elem, *opposing_el, subfacet_connectivity),
           "Subfacet doesn't belong to this element");
 #endif
     }
 
     /// erased checked element from the list
     elements_to_check.pop();
   }
 
   AKANTU_DEBUG_OUT();
   return facet_matched;
 }
 
 /* -------------------------------------------------------------------------- */
 UInt MeshUtils::updateLocalMasterGlobalConnectivity(Mesh & mesh,
                                                     UInt local_nb_new_nodes) {
   const auto & comm = mesh.getCommunicator();
   Int rank = comm.whoAmI();
   Int nb_proc = comm.getNbProc();
   if (nb_proc == 1)
     return local_nb_new_nodes;
 
   /// resize global ids array
   Array<UInt> & nodes_global_ids = mesh.getGlobalNodesIds();
   UInt old_nb_nodes = mesh.getNbNodes() - local_nb_new_nodes;
 
   nodes_global_ids.resize(mesh.getNbNodes());
 
   /// compute the number of global nodes based on the number of old nodes
   Vector<UInt> old_local_master_nodes(nb_proc);
   for (UInt n = 0; n < old_nb_nodes; ++n)
     if (mesh.isLocalOrMasterNode(n))
       ++old_local_master_nodes(rank);
   comm.allGather(old_local_master_nodes);
   UInt old_global_nodes =
       std::accumulate(old_local_master_nodes.storage(),
                       old_local_master_nodes.storage() + nb_proc, 0);
 
   /// compute amount of local or master doubled nodes
   Vector<UInt> local_master_nodes(nb_proc);
   for (UInt n = old_nb_nodes; n < mesh.getNbNodes(); ++n)
     if (mesh.isLocalOrMasterNode(n))
       ++local_master_nodes(rank);
 
   comm.allGather(local_master_nodes);
 
   /// update global number of nodes
   UInt total_nb_new_nodes = std::accumulate(
       local_master_nodes.storage(), local_master_nodes.storage() + nb_proc, 0);
 
   if (total_nb_new_nodes == 0)
     return 0;
 
   /// set global ids of local and master nodes
   UInt starting_index =
       std::accumulate(local_master_nodes.storage(),
                       local_master_nodes.storage() + rank, old_global_nodes);
 
   for (UInt n = old_nb_nodes; n < mesh.getNbNodes(); ++n) {
     if (mesh.isLocalOrMasterNode(n)) {
       nodes_global_ids(n) = starting_index;
       ++starting_index;
     }
   }
 
   MeshAccessor mesh_accessor(mesh);
   mesh_accessor.setNbGlobalNodes(old_global_nodes + total_nb_new_nodes);
   return total_nb_new_nodes;
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::updateElementalConnectivity(
     Mesh & mesh, UInt old_node, UInt new_node,
     const std::vector<Element> & element_list,
     __attribute__((unused)) const std::vector<Element> * facet_list) {
   AKANTU_DEBUG_IN();
 
   ElementType el_type = _not_defined;
   GhostType gt_type = _casper;
   Array<UInt> * conn_elem = nullptr;
 #if defined(AKANTU_COHESIVE_ELEMENT)
   const Array<Element> * cohesive_facets = nullptr;
 #endif
   UInt nb_nodes_per_element = 0;
   UInt * n_update = nullptr;
 
   for (UInt el = 0; el < element_list.size(); ++el) {
     const Element & elem = element_list[el];
     if (elem.type == _not_defined)
       continue;
 
     if (elem.type != el_type || elem.ghost_type != gt_type) {
       el_type = elem.type;
       gt_type = elem.ghost_type;
       conn_elem = &mesh.getConnectivity(el_type, gt_type);
       nb_nodes_per_element = conn_elem->getNbComponent();
 #if defined(AKANTU_COHESIVE_ELEMENT)
       if (elem.kind() == _ek_cohesive)
         cohesive_facets =
             &mesh.getMeshFacets().getSubelementToElement(el_type, gt_type);
 #endif
     }
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
     if (elem.kind() == _ek_cohesive) {
 
       AKANTU_DEBUG_ASSERT(
           facet_list != nullptr,
           "Provide a facet list in order to update cohesive elements");
 
       /// loop over cohesive element's facets
       for (UInt f = 0, n = 0; f < 2; ++f, n += nb_nodes_per_element / 2) {
         const Element & facet = (*cohesive_facets)(elem.element, f);
 
         /// skip facets if not present in the list
         if (std::find(facet_list->begin(), facet_list->end(), facet) ==
             facet_list->end())
           continue;
 
         n_update = std::find(
             conn_elem->storage() + elem.element * nb_nodes_per_element + n,
             conn_elem->storage() + elem.element * nb_nodes_per_element + n +
                 nb_nodes_per_element / 2,
             old_node);
 
         AKANTU_DEBUG_ASSERT(n_update !=
                                 conn_elem->storage() +
                                     elem.element * nb_nodes_per_element + n +
                                     nb_nodes_per_element / 2,
                             "Node not found in current element");
 
         /// update connectivity
         *n_update = new_node;
       }
     } else {
 #endif
       n_update =
           std::find(conn_elem->storage() + elem.element * nb_nodes_per_element,
                     conn_elem->storage() + elem.element * nb_nodes_per_element +
                         nb_nodes_per_element,
                     old_node);
 
       AKANTU_DEBUG_ASSERT(n_update != conn_elem->storage() +
                                           elem.element * nb_nodes_per_element +
                                           nb_nodes_per_element,
                           "Node not found in current element");
 
       /// update connectivity
       *n_update = new_node;
 #if defined(AKANTU_COHESIVE_ELEMENT)
     }
 #endif
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/src/mesh_utils/mesh_utils_inline_impl.cc b/src/mesh_utils/mesh_utils_inline_impl.cc
index ceafd545b..4c7c8bf27 100644
--- a/src/mesh_utils/mesh_utils_inline_impl.cc
+++ b/src/mesh_utils/mesh_utils_inline_impl.cc
@@ -1,82 +1,82 @@
 /**
  * @file   mesh_utils_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Aug 20 2010
  * @date last modification: Fri Mar 20 2015
  *
  * @brief  Mesh utils inline functions
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 inline bool MeshUtils::hasElement(const Array<UInt> & connectivity,
                                   const Element & el,
                                   const Vector<UInt> & nodes) {
 
   UInt nb_nodes_per_element = connectivity.getNbComponent();
 
   const Vector<UInt> el_nodes(connectivity.storage() +
                                   el.element * nb_nodes_per_element,
                               nb_nodes_per_element);
   UInt * el_nodes_end = el_nodes.storage() + nb_nodes_per_element;
 
   UInt n = 0;
 
   while (n < nodes.size() &&
          std::find(el_nodes.storage(), el_nodes_end, nodes[n]) != el_nodes_end)
     ++n;
 
   return (n == nodes.size());
 }
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 inline bool
 MeshUtils::removeElementsInVector(const std::vector<Element> & elem_to_remove,
                                   std::vector<Element> & elem_list) {
   if (elem_list.size() <= elem_to_remove.size())
     return true;
 
-  std::vector<Element>::const_iterator el_it = elem_to_remove.begin();
-  std::vector<Element>::const_iterator el_last = elem_to_remove.end();
+  auto el_it = elem_to_remove.begin();
+  auto el_last = elem_to_remove.end();
   std::vector<Element>::iterator el_del;
 
   UInt deletions = 0;
 
   for (; el_it != el_last; ++el_it) {
     el_del = std::find(elem_list.begin(), elem_list.end(), *el_it);
 
     if (el_del != elem_list.end()) {
       elem_list.erase(el_del);
       ++deletions;
     }
   }
 
   AKANTU_DEBUG_ASSERT(deletions == 0 || deletions == elem_to_remove.size(),
                       "Not all elements have been erased");
 
   return deletions == 0;
 }
diff --git a/src/mesh_utils/mesh_utils_pbc.cc b/src/mesh_utils/mesh_utils_pbc.cc
index bf406ba4b..0a2c7067a 100644
--- a/src/mesh_utils/mesh_utils_pbc.cc
+++ b/src/mesh_utils/mesh_utils_pbc.cc
@@ -1,298 +1,298 @@
 /**
  * @file   mesh_utils_pbc.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Wed Feb 09 2011
  * @date last modification: Tue Sep 15 2015
  *
  * @brief  periodic boundary condition connectivity tweak
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <map>
 /* -------------------------------------------------------------------------- */
 #include "element_group.hh"
 #include "mesh_accessor.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /// class that sorts a set of nodes of same coordinates in 'dir' direction
 class CoordinatesComparison {
 public:
   CoordinatesComparison(const UInt dimension, const UInt dir_1, const UInt dir_2,
                         Real normalization, Real tolerance, const Array<Real> & coords)
     : dim(dimension), dir_1(dir_1), dir_2(dir_2), normalization(normalization),
       tolerance(tolerance), coords_it(coords.begin(dim)) {}
   // answers the question whether n2 is larger or equal to n1
   bool operator()(const UInt n1, const UInt n2) {
     Vector<Real> coords_n1 = coords_it[n1];
     Vector<Real> coords_n2 = coords_it[n2];
     return this->operator()(coords_n1, coords_n2);
   }
 
   bool operator()(const Vector<Real> & coords_n1, const Vector<Real> & coords_n2) {
     Real diff = coords_n1(dir_1) - coords_n2(dir_1);;
     if (dim == 2 || std::abs(diff) / normalization > tolerance)
       return diff > 0. ? false : true;
     else if (dim > 2) {
       diff = coords_n1(dir_2) - coords_n2(dir_2);;
       return diff > 0 ? false : true;
     }
     return true;
   }
 
 private:
   UInt dim;
   UInt dir_1;
   UInt dir_2;
   Real normalization;
   Real tolerance;
   const Array<Real>::const_vector_iterator coords_it;
 };
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::computePBCMap(const Mesh & mesh, const UInt dir,
                               std::map<UInt, UInt> & pbc_pair) {
   Array<UInt> selected_left;
   Array<UInt> selected_right;
 
   const UInt dim = mesh.getSpatialDimension();
   Array<Real>::const_vector_iterator it = mesh.getNodes().begin(dim);
   Array<Real>::const_vector_iterator end = mesh.getNodes().end(dim);
 
   if (dim <= dir)
     return;
 
   const Vector<Real> & lower_bounds = mesh.getLowerBounds();
   const Vector<Real> & upper_bounds = mesh.getUpperBounds();
 
   AKANTU_DEBUG_INFO("min " << lower_bounds(dir));
   AKANTU_DEBUG_INFO("max " << upper_bounds(dir));
 
   for (UInt node = 0; it != end; ++it, ++node) {
     const Vector<Real> & coords = *it;
     AKANTU_DEBUG_TRACE("treating " << coords(dir));
     if (Math::are_float_equal(coords(dir), lower_bounds(dir))) {
       AKANTU_DEBUG_TRACE("pushing node " << node << " on the left side");
       selected_left.push_back(node);
     } else if (Math::are_float_equal(coords(dir), upper_bounds(dir))) {
       selected_right.push_back(node);
       AKANTU_DEBUG_TRACE("pushing node " << node << " on the right side");
     }
   }
 
   AKANTU_DEBUG_INFO(
       "found " << selected_left.size() << " and " << selected_right.size()
                << " nodes at each boundary for direction " << dir);
 
   // match pairs
   MeshUtils::matchPBCPairs(mesh, dir, selected_left, selected_right, pbc_pair);
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::computePBCMap(const Mesh & mesh,
                               const SurfacePair & surface_pair,
                               std::map<UInt, UInt> & pbc_pair) {
 
   Array<UInt> selected_first;
   Array<UInt> selected_second;
 
   // find nodes on surfaces
   const ElementGroup & first_surf = mesh.getElementGroup(surface_pair.first);
   const ElementGroup & second_surf = mesh.getElementGroup(surface_pair.second);
 
   // if this surface pair is not on this proc
   if (first_surf.getNbNodes() == 0 || second_surf.getNbNodes() == 0) {
     AKANTU_DEBUG_WARNING("computePBCMap has at least one surface without any "
                          "nodes. I will ignore it.");
     return;
   }
 
   // copy nodes from element group
   selected_first.copy(first_surf.getNodeGroup().getNodes());
   selected_second.copy(second_surf.getNodeGroup().getNodes());
 
   // coordinates
   const Array<Real> & coords = mesh.getNodes();
   const UInt dim = mesh.getSpatialDimension();
 
   // variables to find min and max of surfaces
   Real first_max[3], first_min[3];
   Real second_max[3], second_min[3];
   for (UInt i = 0; i < dim; ++i) {
     first_min[i] = std::numeric_limits<Real>::max();
     second_min[i] = std::numeric_limits<Real>::max();
     first_max[i] = -std::numeric_limits<Real>::max();
     second_max[i] = -std::numeric_limits<Real>::max();
   }
 
   // find min and max of surface nodes
   for (Array<UInt>::scalar_iterator it = selected_first.begin();
        it != selected_first.end(); ++it) {
     for (UInt i = 0; i < dim; ++i) {
       if (first_min[i] > coords(*it, i))
         first_min[i] = coords(*it, i);
       if (first_max[i] < coords(*it, i))
         first_max[i] = coords(*it, i);
     }
   }
   for (Array<UInt>::scalar_iterator it = selected_second.begin();
        it != selected_second.end(); ++it) {
     for (UInt i = 0; i < dim; ++i) {
       if (second_min[i] > coords(*it, i))
         second_min[i] = coords(*it, i);
       if (second_max[i] < coords(*it, i))
         second_max[i] = coords(*it, i);
     }
   }
 
   // find direction of pbc
   Int first_dir = -1;
 #ifndef AKANTU_NDEBUG
   Int second_dir = -2;
 #endif
   for (UInt i = 0; i < dim; ++i) {
     if (Math::are_float_equal(first_min[i], first_max[i])) {
       first_dir = i;
     }
 #ifndef AKANTU_NDEBUG
     if (Math::are_float_equal(second_min[i], second_max[i])) {
       second_dir = i;
     }
 #endif
   }
 
   AKANTU_DEBUG_ASSERT(first_dir == second_dir,
                       "Surface pair has not same direction. Surface "
                           << surface_pair.first << " dir=" << first_dir
                           << " ; Surface " << surface_pair.second
                           << " dir=" << second_dir);
   UInt dir = first_dir;
 
   // match pairs
   if (first_min[dir] < second_min[dir])
     MeshUtils::matchPBCPairs(mesh, dir, selected_first, selected_second,
                              pbc_pair);
   else
     MeshUtils::matchPBCPairs(mesh, dir, selected_second, selected_first,
                              pbc_pair);
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::matchPBCPairs(const Mesh & mesh, const UInt dir,
                               Array<UInt> & selected_left,
                               Array<UInt> & selected_right,
                               std::map<UInt, UInt> & pbc_pair) {
 
   // tolerance is that large because most meshers generate points coordinates
   // with single precision only (it is the case of GMSH for instance)
   Real tolerance = 1e-7;
   const UInt dim = mesh.getSpatialDimension();
   Real normalization = mesh.getUpperBounds()(dir) - mesh.getLowerBounds()(dir);
 
   AKANTU_DEBUG_ASSERT(std::abs(normalization) > Math::getTolerance(),
                       "In matchPBCPairs: The normalization is zero. "
                           << "Did you compute the bounding box of the mesh?");
 
-  UInt odir_1 = UInt(-1), odir_2 = UInt(-1);
+  auto odir_1 = UInt(-1), odir_2 = UInt(-1);
 
   if (dim == 3) {
     if (dir == _x) {
       odir_1 = _y;
       odir_2 = _z;
     } else if (dir == _y) {
       odir_1 = _x;
       odir_2 = _z;
     } else if (dir == _z) {
       odir_1 = _x;
       odir_2 = _y;
     }
   } else if (dim == 2) {
     if (dir == _x) {
       odir_1 = _y;
     } else if (dir == _y) {
       odir_1 = _x;
     }
   }
 
   CoordinatesComparison compare_nodes(dim, odir_1, odir_2, normalization,
                                       tolerance, mesh.getNodes());
 
   std::sort(selected_left.begin(), selected_left.end(), compare_nodes);
   std::sort(selected_right.begin(), selected_right.end(), compare_nodes);
 
   Array<UInt>::scalar_iterator it_left = selected_left.begin();
   Array<UInt>::scalar_iterator end_left = selected_left.end();
 
   Array<UInt>::scalar_iterator it_right = selected_right.begin();
   Array<UInt>::scalar_iterator end_right = selected_right.end();
 
   Array<Real>::const_vector_iterator nit = mesh.getNodes().begin(dim);
 
   while ((it_left != end_left) && (it_right != end_right)) {
     UInt i1 = *it_left;
     UInt i2 = *it_right;
 
     Vector<Real> coords1 = nit[i1];
     Vector<Real> coords2 = nit[i2];
 
     AKANTU_DEBUG_TRACE("do I pair? " << i1 << "(" << coords1 << ") with" << i2
                                      << "(" << coords2 << ") in direction "
                                      << dir);
 
     Real dx = 0.0;
     Real dy = 0.0;
     if (dim >= 2)
       dx = coords1(odir_1) - coords2(odir_1);
     if (dim == 3)
       dy = coords1(odir_2) - coords2(odir_2);
 
     if (std::abs(dx * dx + dy * dy) / normalization < tolerance) {
       // then i match these pairs
       if (pbc_pair.count(i2)) {
         i2 = pbc_pair[i2];
       }
       pbc_pair[i1] = i2;
 
       AKANTU_DEBUG_TRACE("pairing "
                          << i1 << "(" << coords1
                          << ") with" << i2 << "(" << coords2
                          << ") in direction " << dir);
       ++it_left;
       ++it_right;
     } else if (compare_nodes(coords1, coords2)) {
       ++it_left;
     } else {
       ++it_right;
     }
   }
   AKANTU_DEBUG_INFO("found " << pbc_pair.size() << " pairs for direction "
                              << dir);
 }
 
 } // akantu
diff --git a/src/model/boundary_condition.hh b/src/model/boundary_condition.hh
index 65a09e0a1..60754053d 100644
--- a/src/model/boundary_condition.hh
+++ b/src/model/boundary_condition.hh
@@ -1,108 +1,106 @@
 /**
  * @file   boundary_condition.hh
  *
  * @author Dana Christen <dana.christen@gmail.com>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri Dec 18 2015
  *
  * @brief  XXX
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_BOUNDARY_CONDITION_HH__
 #define __AKANTU_BOUNDARY_CONDITION_HH__
 
 #include "aka_common.hh"
 #include "boundary_condition_functor.hh"
 #include "mesh.hh"
 #include "fe_engine.hh"
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 template <class ModelType>
 class BoundaryCondition {
 
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 private:
 
   /* ------------------------------------------------------------------------ */
   /* Constructors / Destructors / Initializers                                */
   /* ------------------------------------------------------------------------ */
 public:
-  BoundaryCondition()
-      : model(nullptr), primal(nullptr), dual(nullptr),
-        primal_increment(nullptr) {}
+  BoundaryCondition() : model(nullptr) {}
   ///Initialize the boundary conditions
   void initBC(ModelType & ptr, Array<Real> & primal, Array<Real> & dual);
   void initBC(ModelType & ptr, Array<Real> & primal,
 	      Array<Real> & primal_increment, Array<Real> & dual);
   /* ------------------------------------------------------------------------ */
   /* Methods and accessors                                                    */
   /* ------------------------------------------------------------------------ */
 public:
 
   //inline void initBoundaryCondition();
   template<typename FunctorType>
   ///Apply the boundary conditions
   inline void applyBC(const FunctorType & func);
 
   template<class FunctorType>
   inline void applyBC(const FunctorType & func, const std::string & group_name);
 
   template<class FunctorType>
   inline void applyBC(const FunctorType & func, const ElementGroup & element_group);
 
   AKANTU_GET_MACRO_NOT_CONST(Model, *model, ModelType &);
   AKANTU_GET_MACRO_NOT_CONST(Primal,*primal, Array<Real> &);
   AKANTU_GET_MACRO_NOT_CONST(Dual,  *dual,   Array<Real> &);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 
 public:
 
   template<class FunctorType, BC::Functor::Type type = FunctorType::type>
   struct TemplateFunctionWrapper;
 
 private:
 
   ModelType * model;
-  Array<Real> * primal;
-  Array<Real> * dual;
-  Array<Real> * primal_increment;
+  Array<Real> * primal{nullptr};
+  Array<Real> * dual{nullptr};
+  Array<Real> * primal_increment{nullptr};
 };
 
 } // akantu
 
 #include "boundary_condition_tmpl.hh"
 
 #endif /* __AKANTU_BOUNDARY_CONDITION_HH__ */
 
diff --git a/src/model/boundary_condition_functor.hh b/src/model/boundary_condition_functor.hh
index 776fa1514..2c177874d 100644
--- a/src/model/boundary_condition_functor.hh
+++ b/src/model/boundary_condition_functor.hh
@@ -1,197 +1,197 @@
 /**
  * @file   boundary_condition_functor.hh
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri May 03 2013
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Definitions of the functors to apply boundary conditions
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "fe_engine.hh"
 #include "integration_point.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_BOUNDARY_CONDITION_FUNCTOR_HH__
 #define __AKANTU_BOUNDARY_CONDITION_FUNCTOR_HH__
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 namespace BC {
-typedef ::akantu::SpacialDirection Axis;
+  using Axis = ::akantu::SpacialDirection;
 
-struct Functor {
-  enum Type { _dirichlet, _neumann };
+  struct Functor {
+    enum Type { _dirichlet, _neumann };
 };
 
 /* ------------------------------------------------------------------------ */
 /* Dirichlet                                                                */
 /* ------------------------------------------------------------------------ */
 namespace Dirichlet {
   /* ---------------------------------------------------------------------- */
   class DirichletFunctor : public Functor {
   protected:
-    DirichletFunctor() : axis(_x) {}
+    DirichletFunctor() = default;
     explicit DirichletFunctor(Axis ax) : axis(ax) {}
 
   public:
     void operator()(__attribute__((unused)) UInt node,
                     __attribute__((unused)) Vector<bool> & flags,
                     __attribute__((unused)) Vector<Real> & primal,
                     __attribute__((unused)) const Vector<Real> & coord) const {
       AKANTU_DEBUG_TO_IMPLEMENT();
     }
 
   public:
     static const Type type = _dirichlet;
 
   protected:
-    Axis axis;
+    Axis axis{_x};
   };
 
   /* ---------------------------------------------------------------------- */
   class FlagOnly : public DirichletFunctor {
   public:
     explicit FlagOnly(Axis ax = _x) : DirichletFunctor(ax) {}
 
   public:
     inline void operator()(UInt node, Vector<bool> & flags,
                            Vector<Real> & primal,
                            const Vector<Real> & coord) const;
   };
 
   /* ---------------------------------------------------------------------- */
   class FreeBoundary : public DirichletFunctor {
   public:
     explicit FreeBoundary(Axis ax = _x) : DirichletFunctor(ax) {}
 
   public:
     inline void operator()(UInt node, Vector<bool> & flags,
                            Vector<Real> & primal,
                            const Vector<Real> & coord) const;
   };
 
   /* ---------------------------------------------------------------------- */
   class FixedValue : public DirichletFunctor {
   public:
     FixedValue(Real val, Axis ax = _x) : DirichletFunctor(ax), value(val) {}
 
   public:
     inline void operator()(UInt node, Vector<bool> & flags,
                            Vector<Real> & primal,
                            const Vector<Real> & coord) const;
 
   protected:
     Real value;
   };
 
   /* ---------------------------------------------------------------------- */
   class IncrementValue : public DirichletFunctor {
   public:
     IncrementValue(Real val, Axis ax = _x) : DirichletFunctor(ax), value(val) {}
 
   public:
     inline void operator()(UInt node, Vector<bool> & flags,
                            Vector<Real> & primal,
                            const Vector<Real> & coord) const;
 
     inline void setIncrement(Real val) { this->value = val; }
 
   protected:
     Real value;
   };
 } // end namespace Dirichlet
 
 /* ------------------------------------------------------------------------ */
 /* Neumann                                                                  */
 /* ------------------------------------------------------------------------ */
 namespace Neumann {
   /* ---------------------------------------------------------------------- */
   class NeumannFunctor : public Functor {
 
   protected:
-    NeumannFunctor() {}
+    NeumannFunctor() = default;
 
   public:
     virtual void operator()(const IntegrationPoint & quad_point,
                             Vector<Real> & dual, const Vector<Real> & coord,
                             const Vector<Real> & normals) const = 0;
 
-    virtual ~NeumannFunctor() {}
+    virtual ~NeumannFunctor() = default;
 
   public:
     static const Type type = _neumann;
   };
 
   /* ---------------------------------------------------------------------- */
   class FromHigherDim : public NeumannFunctor {
   public:
     explicit FromHigherDim(const Matrix<Real> & mat) : bc_data(mat) {}
-    ~FromHigherDim() override {}
+    ~FromHigherDim() override = default;
 
   public:
     inline void operator()(const IntegrationPoint & quad_point,
                            Vector<Real> & dual, const Vector<Real> & coord,
                            const Vector<Real> & normals) const override;
 
   protected:
     Matrix<Real> bc_data;
   };
 
   /* ---------------------------------------------------------------------- */
   class FromSameDim : public NeumannFunctor {
   public:
     explicit FromSameDim(const Vector<Real> & vec) : bc_data(vec) {}
-    ~FromSameDim() override {}
+    ~FromSameDim() override = default;
 
   public:
     inline void operator()(const IntegrationPoint & quad_point,
                            Vector<Real> & dual, const Vector<Real> & coord,
                            const Vector<Real> & normals) const override;
 
   protected:
     Vector<Real> bc_data;
   };
 
   /* ---------------------------------------------------------------------- */
   class FreeBoundary : public NeumannFunctor {
   public:
     inline void operator()(const IntegrationPoint & quad_point,
                            Vector<Real> & dual, const Vector<Real> & coord,
                            const Vector<Real> & normals) const override;
   };
 } // end namespace Neumann
 } // end namespace BC
 
 } // akantu
 
 #include "boundary_condition_functor_inline_impl.cc"
 
 #endif /* __AKANTU_BOUNDARY_CONDITION_FUNCTOR_HH__ */
diff --git a/src/model/boundary_condition_tmpl.hh b/src/model/boundary_condition_tmpl.hh
index dbf6f1e2d..bf9336598 100644
--- a/src/model/boundary_condition_tmpl.hh
+++ b/src/model/boundary_condition_tmpl.hh
@@ -1,259 +1,257 @@
 /**
  * @file   boundary_condition_tmpl.hh
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri May 03 2013
  * @date last modification: Fri Oct 16 2015
  *
  * @brief  implementation of the applyBC
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "boundary_condition.hh"
 #include "element_group.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_BOUNDARY_CONDITION_TMPL_HH__
 #define __AKANTU_BOUNDARY_CONDITION_TMPL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 void BoundaryCondition<ModelType>::initBC(ModelType & model,
                                           Array<Real> & primal,
                                           Array<Real> & dual) {
   this->model = &model;
   this->primal = &primal;
   this->dual = &dual;
   if (this->model->getSpatialDimension() > 1)
     this->model->initFEEngineBoundary();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 void BoundaryCondition<ModelType>::initBC(ModelType & model,
                                           Array<Real> & primal,
                                           Array<Real> & primal_increment,
                                           Array<Real> & dual) {
   this->initBC(model, primal, dual);
   this->primal_increment = &primal_increment;
 }
 
 /* -------------------------------------------------------------------------- */
 /* Partial specialization for DIRICHLET functors */
 template <typename ModelType>
 template <typename FunctorType>
 struct BoundaryCondition<ModelType>::TemplateFunctionWrapper<
     FunctorType, BC::Functor::_dirichlet> {
   static inline void applyBC(const FunctorType & func,
                              const ElementGroup & group,
                              BoundaryCondition<ModelType> & bc_instance) {
     auto & model = bc_instance.getModel();
     auto & primal = bc_instance.getPrimal();
 
     const auto & coords = model.getMesh().getNodes();
     auto & boundary_flags = model.getBlockedDOFs();
     UInt dim = model.getMesh().getSpatialDimension();
 
     auto primal_iter = primal.begin(primal.getNbComponent());
     auto coords_iter = coords.begin(dim);
     auto flags_iter = boundary_flags.begin(boundary_flags.getNbComponent());
 
     for (auto n : group.getNodeGroup()) {
       Vector<bool> flag(flags_iter[n]);
       Vector<Real> primal(primal_iter[n]);
       Vector<Real> coords(coords_iter[n]);
       func(n, flag, primal, coords);
     }
   }
 };
 
 /* -------------------------------------------------------------------------- */
 /* Partial specialization for NEUMANN functors */
 template <typename ModelType>
 template <typename FunctorType>
 struct BoundaryCondition<ModelType>::TemplateFunctionWrapper<
     FunctorType, BC::Functor::_neumann> {
   static inline void applyBC(const FunctorType & func,
                              const ElementGroup & group,
                              BoundaryCondition<ModelType> & bc_instance) {
     UInt dim = bc_instance.getModel().getSpatialDimension();
     switch (dim) {
     case 1: {
       AKANTU_DEBUG_TO_IMPLEMENT();
       break;
     }
     case 2:
     case 3: {
       applyBC(func, group, bc_instance, _not_ghost);
       applyBC(func, group, bc_instance, _ghost);
       break;
     }
     }
   }
 
   static inline void applyBC(const FunctorType & func,
                              const ElementGroup & group,
                              BoundaryCondition<ModelType> & bc_instance,
                              GhostType ghost_type) {
     auto & model = bc_instance.getModel();
     auto & dual = bc_instance.getDual();
     const auto & mesh = model.getMesh();
     const auto & nodes_coords = mesh.getNodes();
     const auto & fem_boundary = model.getFEEngineBoundary();
 
     UInt dim = model.getSpatialDimension();
     UInt nb_degree_of_freedom = dual.getNbComponent();
 
     IntegrationPoint quad_point;
     quad_point.ghost_type = ghost_type;
 
     // Loop over the boundary element types
     for (auto && type : group.elementTypes(dim - 1, ghost_type)) {
       const auto & element_ids = group.getElements(type, ghost_type);
 
       UInt nb_quad_points =
           fem_boundary.getNbIntegrationPoints(type, ghost_type);
       UInt nb_elements = element_ids.size();
       UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
 
       Array<Real> * dual_before_integ = new Array<Real>(
           nb_elements * nb_quad_points, nb_degree_of_freedom, 0.);
       Array<Real> * quad_coords =
           new Array<Real>(nb_elements * nb_quad_points, dim);
 
       const auto & normals_on_quad =
           fem_boundary.getNormalsOnIntegrationPoints(type, ghost_type);
 
       fem_boundary.interpolateOnIntegrationPoints(
           nodes_coords, *quad_coords, dim, type, ghost_type, element_ids);
       auto normals_begin = normals_on_quad.begin(dim);
       decltype(normals_begin) normals_iter;
       auto quad_coords_iter = quad_coords->begin(dim);
       auto dual_iter = dual_before_integ->begin(nb_degree_of_freedom);
 
       quad_point.type = type;
       for (auto el : element_ids) {
         quad_point.element = el;
         normals_iter = normals_begin + el * nb_quad_points;
         for (auto && q : arange(nb_quad_points)) {
           quad_point.num_point = q;
           func(quad_point, *dual_iter, *quad_coords_iter, *normals_iter);
           ++dual_iter;
           ++quad_coords_iter;
           ++normals_iter;
         }
       }
 
       delete quad_coords;
 
       /* -------------------------------------------------------------------- */
       // Initialization of iterators
       auto dual_iter_mat = dual_before_integ->begin(nb_degree_of_freedom, 1);
       auto shapes_iter_begin = fem_boundary.getShapes(type, ghost_type)
                                    .begin(1, nb_nodes_per_element);
 
       Array<Real> * dual_by_shapes =
           new Array<Real>(nb_elements * nb_quad_points,
                           nb_degree_of_freedom * nb_nodes_per_element);
 
       auto dual_by_shapes_iter =
           dual_by_shapes->begin(nb_degree_of_freedom, nb_nodes_per_element);
 
       /* -------------------------------------------------------------------- */
       // Loop computing dual x shapes
       for (auto el : element_ids) {
         auto shapes_iter = shapes_iter_begin + el * nb_quad_points;
 
         for (UInt q(0); q < nb_quad_points;
              ++q, ++dual_iter_mat, ++dual_by_shapes_iter, ++shapes_iter) {
           dual_by_shapes_iter->mul<false, false>(*dual_iter_mat, *shapes_iter);
         }
       }
 
       delete dual_before_integ;
 
       Array<Real> * dual_by_shapes_integ = new Array<Real>(
           nb_elements, nb_degree_of_freedom * nb_nodes_per_element);
       fem_boundary.integrate(*dual_by_shapes, *dual_by_shapes_integ,
                              nb_degree_of_freedom * nb_nodes_per_element, type,
                              ghost_type, element_ids);
       delete dual_by_shapes;
 
       // assemble the result into force vector
       model.getDOFManager().assembleElementalArrayLocalArray(
           *dual_by_shapes_integ, dual, type, ghost_type, 1., element_ids);
       delete dual_by_shapes_integ;
     }
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 template <typename FunctorType>
 inline void BoundaryCondition<ModelType>::applyBC(const FunctorType & func) {
-  GroupManager::const_element_group_iterator bit =
-      model->getMesh().getGroupManager().element_group_begin();
-  GroupManager::const_element_group_iterator bend =
-      model->getMesh().getGroupManager().element_group_end();
+  auto bit = model->getMesh().getGroupManager().element_group_begin();
+  auto bend = model->getMesh().getGroupManager().element_group_end();
   for (; bit != bend; ++bit)
     applyBC(func, *bit);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 template <typename FunctorType>
 inline void
 BoundaryCondition<ModelType>::applyBC(const FunctorType & func,
                                       const std::string & group_name) {
   try {
     const ElementGroup & element_group =
         model->getMesh().getElementGroup(group_name);
     applyBC(func, element_group);
   } catch (akantu::debug::Exception e) {
     AKANTU_EXCEPTION("Error applying a boundary condition onto \""
                      << group_name << "\"! [" << e.what() << "]");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 template <typename FunctorType>
 inline void
 BoundaryCondition<ModelType>::applyBC(const FunctorType & func,
                                       const ElementGroup & element_group) {
 #if !defined(AKANTU_NDEBUG)
   if (element_group.getDimension() != model->getSpatialDimension() - 1)
     AKANTU_DEBUG_WARNING("The group "
                          << element_group.getName()
                          << " does not contain only boundaries elements");
 #endif
 
   TemplateFunctionWrapper<FunctorType>::applyBC(func, element_group, *this);
 }
 
 #endif /* __AKANTU_BOUNDARY_CONDITION_TMPL_HH__ */
 
 } // namespace akantu
diff --git a/src/model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion.cc b/src/model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion.cc
index 3ea76cbf8..76ab3d295 100644
--- a/src/model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion.cc
+++ b/src/model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion.cc
@@ -1,310 +1,310 @@
 /**
  * @file   neighborhood_max_criterion.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  *
  * @date creation: Thu Oct 15 2015
  * @date last modification: Tue Nov 24 2015
  *
  * @brief  Implementation of class NeighborhoodMaxCriterion
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "neighborhood_max_criterion.hh"
 #include "grid_synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NeighborhoodMaxCriterion::NeighborhoodMaxCriterion(
     Model & model, const ElementTypeMapReal & quad_coordinates,
     const ID & criterion_id, const ID & id, const MemoryID & memory_id)
     : NeighborhoodBase(model, quad_coordinates, id, memory_id),
       Parsable(_st_non_local, id), is_highest("is_highest", id, memory_id),
       criterion(criterion_id, id, memory_id) {
 
   AKANTU_DEBUG_IN();
 
   this->registerParam("radius", neighborhood_radius, 100.,
                       _pat_parsable | _pat_readable, "Non local radius");
 
   Mesh & mesh = this->model.getMesh();
   /// allocate the element type map arrays for _not_ghosts: One entry per quad
   GhostType ghost_type = _not_ghost;
   Mesh::type_iterator it = mesh.firstType(spatial_dimension, ghost_type);
   Mesh::type_iterator last_type = mesh.lastType(spatial_dimension, ghost_type);
 
   for (; it != last_type; ++it) {
     UInt new_size = this->quad_coordinates(*it, ghost_type).size();
     this->is_highest.alloc(new_size, 1, *it, ghost_type, true);
     this->criterion.alloc(new_size, 1, *it, ghost_type, true);
   }
 
   /// criterion needs allocation also for ghost
   ghost_type = _ghost;
   it = mesh.firstType(spatial_dimension, ghost_type);
   last_type = mesh.lastType(spatial_dimension, ghost_type);
   for (; it != last_type; ++it) {
     UInt new_size = this->quad_coordinates(*it, ghost_type).size();
     this->criterion.alloc(new_size, 1, *it, ghost_type, true);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 NeighborhoodMaxCriterion::~NeighborhoodMaxCriterion() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodMaxCriterion::initNeighborhood() {
   AKANTU_DEBUG_IN();
 
   /// parse the input parameter
   const Parser & parser = getStaticParser();
   const ParserSection & section_neighborhood =
       *(parser.getSubSections(_st_neighborhood).first);
   this->parseSection(section_neighborhood);
 
   AKANTU_DEBUG_INFO("Creating the grid");
   this->createGrid();
 
   /// insert the non-ghost quads into the grid
   this->insertAllQuads(_not_ghost);
 
   /// store the number of current ghost elements for each type in the mesh
   ElementTypeMap<UInt> nb_ghost_protected;
   Mesh & mesh = this->model.getMesh();
   Mesh::type_iterator it = mesh.firstType(spatial_dimension, _ghost);
   Mesh::type_iterator last_type = mesh.lastType(spatial_dimension, _ghost);
   for (; it != last_type; ++it)
     nb_ghost_protected(mesh.getNbElement(*it, _ghost), *it, _ghost);
 
   /// create the grid synchronizer
   this->createGridSynchronizer();
 
   /// insert the ghost quads into the grid
   this->insertAllQuads(_ghost);
 
   /// create the pair lists
   this->updatePairList();
 
   /// remove the unneccessary ghosts
   this->cleanupExtraGhostElements(nb_ghost_protected);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodMaxCriterion::createGridSynchronizer() {
   this->is_creating_grid = true;
   std::set<SynchronizationTag> tags;
   tags.insert(_gst_nh_criterion);
 
   std::stringstream sstr;
   sstr << getID() << ":grid_synchronizer";
   this->grid_synchronizer = std::make_unique<GridSynchronizer>(
       this->model.getMesh(), *spatial_grid, * this, tags, sstr.str(), 0, false);
   this->is_creating_grid = false;
 }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodMaxCriterion::insertAllQuads(const GhostType & ghost_type) {
   IntegrationPoint q;
   q.ghost_type = ghost_type;
   Mesh & mesh = this->model.getMesh();
 
   Mesh::type_iterator it = mesh.firstType(spatial_dimension, ghost_type);
   Mesh::type_iterator last_type = mesh.lastType(spatial_dimension, ghost_type);
   for (; it != last_type; ++it) {
     UInt nb_element = mesh.getNbElement(*it, ghost_type);
     UInt nb_quad =
         this->model.getFEEngine().getNbIntegrationPoints(*it, ghost_type);
 
     const Array<Real> & quads = this->quad_coordinates(*it, ghost_type);
     q.type = *it;
 
     Array<Real>::const_vector_iterator quad = quads.begin(spatial_dimension);
 
     for (UInt e = 0; e < nb_element; ++e) {
       q.element = e;
       for (UInt nq = 0; nq < nb_quad; ++nq) {
         q.num_point = nq;
         q.global_num = q.element * nb_quad + nq;
         spatial_grid->insert(q, *quad);
         ++quad;
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodMaxCriterion::findMaxQuads(
     std::vector<IntegrationPoint> & max_quads) {
   AKANTU_DEBUG_IN();
 
   /// clear the element type maps
   this->is_highest.clear();
   this->criterion.clear();
 
   /// update the values of the criterion
   this->model.updateDataForNonLocalCriterion(criterion);
 
   /// start the exchange the value of the criterion on the ghost elements
   this->model.asynchronousSynchronize(_gst_nh_criterion);
 
   /// compare to not-ghost neighbors
   checkNeighbors(_not_ghost);
 
   /// finish the exchange
   this->model.waitEndSynchronize(_gst_nh_criterion);
 
   /// compare to ghost neighbors
   checkNeighbors(_ghost);
 
   /// extract the quads with highest criterion in their neighborhood
   IntegrationPoint quad;
   quad.ghost_type = _not_ghost;
   Mesh & mesh = this->model.getMesh();
   Mesh::type_iterator it = mesh.firstType(spatial_dimension, _not_ghost);
   Mesh::type_iterator last_type = mesh.lastType(spatial_dimension, _not_ghost);
   for (; it != last_type; ++it) {
     quad.type = *it;
     Array<bool>::const_scalar_iterator is_highest_it =
         is_highest(*it, _not_ghost).begin();
     Array<bool>::const_scalar_iterator is_highest_end =
         is_highest(*it, _not_ghost).end();
 
     UInt nb_quadrature_points =
         this->model.getFEEngine().getNbIntegrationPoints(*it, _not_ghost);
     UInt q = 0;
 
     /// loop over is_highest for the current element type
     for (; is_highest_it != is_highest_end; ++is_highest_it, ++q) {
       if (*is_highest_it) {
         /// gauss point has the highest stress in his neighbourhood
         quad.element = q / nb_quadrature_points;
         quad.global_num = q;
         quad.num_point = q % nb_quadrature_points;
         max_quads.push_back(quad);
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodMaxCriterion::checkNeighbors(const GhostType & ghost_type2) {
   AKANTU_DEBUG_IN();
 
   PairList::const_iterator first_pair = pair_list[ghost_type2].begin();
   PairList::const_iterator last_pair = pair_list[ghost_type2].end();
 
   // Compute the weights
   for (; first_pair != last_pair; ++first_pair) {
     const IntegrationPoint & lq1 = first_pair->first;
     const IntegrationPoint & lq2 = first_pair->second;
 
     Array<bool> & has_highest_eq_stress_1 =
         is_highest(lq1.type, lq1.ghost_type);
 
     const Array<Real> & criterion_1 = this->criterion(lq1.type, lq1.ghost_type);
     const Array<Real> & criterion_2 = this->criterion(lq2.type, lq2.ghost_type);
 
     if (criterion_1(lq1.global_num) < criterion_2(lq2.global_num))
       has_highest_eq_stress_1(lq1.global_num) = false;
     else if (ghost_type2 != _ghost) {
       Array<bool> & has_highest_eq_stress_2 =
           is_highest(lq2.type, lq2.ghost_type);
       has_highest_eq_stress_2(lq2.global_num) = false;
     }
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodMaxCriterion::cleanupExtraGhostElements(
     const ElementTypeMap<UInt> & nb_ghost_protected) {
 
   Mesh & mesh = this->model.getMesh();
   /// create remove elements event
   RemovedElementsEvent remove_elem(mesh);
   /// create set of ghosts to keep
   std::set<Element> relevant_ghost_elements;
   PairList::const_iterator first_pair = pair_list[_ghost].begin();
   PairList::const_iterator last_pair = pair_list[_ghost].end();
   for (; first_pair != last_pair; ++first_pair) {
     const IntegrationPoint & q2 = first_pair->second;
     relevant_ghost_elements.insert(q2);
   }
 
   Array<Element> ghosts_to_erase(0);
   Mesh::type_iterator it = mesh.firstType(spatial_dimension, _ghost);
   Mesh::type_iterator last_type = mesh.lastType(spatial_dimension, _ghost);
 
   Element element;
   element.ghost_type = _ghost;
 
-  std::set<Element>::const_iterator end = relevant_ghost_elements.end();
+  auto end = relevant_ghost_elements.end();
   for (; it != last_type; ++it) {
     element.type = *it;
     UInt nb_ghost_elem = mesh.getNbElement(*it, _ghost);
     UInt nb_ghost_elem_protected = 0;
     try {
       nb_ghost_elem_protected = nb_ghost_protected(*it, _ghost);
     } catch (...) {
     }
 
     if (!remove_elem.getNewNumbering().exists(*it, _ghost))
       remove_elem.getNewNumbering().alloc(nb_ghost_elem, 1, *it, _ghost);
     else
       remove_elem.getNewNumbering(*it, _ghost).resize(nb_ghost_elem);
     Array<UInt> & new_numbering = remove_elem.getNewNumbering(*it, _ghost);
     for (UInt g = 0; g < nb_ghost_elem; ++g) {
       element.element = g;
       if (element.element >= nb_ghost_elem_protected &&
           relevant_ghost_elements.find(element) == end) {
         ghosts_to_erase.push_back(element);
         new_numbering(element.element) = UInt(-1);
       }
     }
     /// renumber remaining ghosts
     UInt ng = 0;
     for (UInt g = 0; g < nb_ghost_elem; ++g) {
       if (new_numbering(g) != UInt(-1)) {
         new_numbering(g) = ng;
         ++ng;
       }
     }
   }
 
   mesh.sendEvent(remove_elem);
   this->onElementsRemoved(ghosts_to_erase, remove_elem.getNewNumbering(),
                           remove_elem);
 }
 
 } // namespace akantu
diff --git a/src/model/common/non_local_toolbox/base_weight_function.hh b/src/model/common/non_local_toolbox/base_weight_function.hh
index 59bc32172..dc482f725 100644
--- a/src/model/common/non_local_toolbox/base_weight_function.hh
+++ b/src/model/common/non_local_toolbox/base_weight_function.hh
@@ -1,169 +1,169 @@
 /**
  * @file   base_weight_function.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Cyprien Wolff <cyprien.wolff@epfl.ch>
  *
  * @date creation: Mon Aug 24 2015
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Base weight function for non local materials
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "data_accessor.hh"
 #include "model.hh"
 #include "non_local_manager.hh"
 #include "parsable.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_BASE_WEIGHT_FUNCTION_HH__
 #define __AKANTU_BASE_WEIGHT_FUNCTION_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /*  Normal weight function                                                    */
 /* -------------------------------------------------------------------------- */
 class BaseWeightFunction : public Parsable, public DataAccessor<Element> {
 public:
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
   BaseWeightFunction(NonLocalManager & manager,
                      const std::string & type = "base")
       : Parsable(_st_weight_function, "weight_function:" + type),
         manager(manager), type(type),
         spatial_dimension(manager.getModel().getMesh().getSpatialDimension()) {
     this->registerParam("update_rate", update_rate, 1U, _pat_parsmod,
                         "Update frequency");
   }
 
-  ~BaseWeightFunction() override {}
+  ~BaseWeightFunction() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
   /// initialize the weight function
   virtual inline void init();
 
   /// update the internal parameters
   virtual void updateInternals(){};
 
   /* ------------------------------------------------------------------------ */
   /// set the non-local radius
   inline void setRadius(Real radius);
 
   /* ------------------------------------------------------------------------ */
   /// compute the weight for a given distance between two quadrature points
   inline Real operator()(Real r, const IntegrationPoint & q1,
                          const IntegrationPoint & q2);
 
   /// print function
   void printself(std::ostream & stream, int indent = 0) const override {
     std::string space;
     for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
       ;
     stream << space << "WeightFunction " << type << " [" << std::endl;
     Parsable::printself(stream, indent);
     stream << space << "]" << std::endl;
   }
 
   /* --------------------------------------------------------------------------
    */
   /* Accessors */
   /* --------------------------------------------------------------------------
    */
 
 public:
   /// get the radius
   Real getRadius() { return R; }
   /// get the update rate
   UInt getUpdateRate() { return update_rate; }
 
 public:
   /* ------------------------------------------------------------------------ */
   /* Data Accessor inherited members                                          */
   /* ------------------------------------------------------------------------ */
 
   UInt getNbData(const Array<Element> &,
                  const SynchronizationTag &) const override {
     return 0;
   }
 
   inline void packData(CommunicationBuffer &, const Array<Element> &,
                        const SynchronizationTag &) const override {}
 
   inline void unpackData(CommunicationBuffer &, const Array<Element> &,
                          const SynchronizationTag &) override {}
 
   /* ------------------------------------------------------------------------ */
   /* Accessors */
   /* ------------------------------------------------------------------------ */
 public:
   AKANTU_GET_MACRO(Type, type, const ID &);
 
 protected:
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
   /// reference to the non-local manager
   NonLocalManager & manager;
 
   /// the non-local radius
   Real R;
 
   /// the non-local radius squared
   Real R2;
 
   /// the update rate
   UInt update_rate;
 
   /// name of the type of weight function
   const std::string type;
 
   /// the spatial dimension
   UInt spatial_dimension;
 };
 
 inline std::ostream & operator<<(std::ostream & stream,
                                  const BaseWeightFunction & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #include "base_weight_function_inline_impl.cc"
 
 /* -------------------------------------------------------------------------- */
 /* Include all other weight function types                                    */
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_DAMAGE_NON_LOCAL)
 #include "damaged_weight_function.hh"
 #include "remove_damaged_weight_function.hh"
 #include "remove_damaged_with_damage_rate_weight_function.hh"
 #include "stress_based_weight_function.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 
 #endif /* __AKANTU_BASE_WEIGHT_FUNCTION_HH__ */
diff --git a/src/model/common/non_local_toolbox/non_local_manager.cc b/src/model/common/non_local_toolbox/non_local_manager.cc
index fe6e38c1a..4c6e1b89a 100644
--- a/src/model/common/non_local_toolbox/non_local_manager.cc
+++ b/src/model/common/non_local_toolbox/non_local_manager.cc
@@ -1,639 +1,638 @@
 /**
  * @file   non_local_manager.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Apr 13 2012
  * @date last modification: Wed Dec 16 2015
  *
  * @brief  Implementation of non-local manager
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "non_local_manager.hh"
 #include "grid_synchronizer.hh"
 #include "model.hh"
 #include "non_local_neighborhood.hh"
 /* -------------------------------------------------------------------------- */
 #include <numeric>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NonLocalManager::NonLocalManager(Model & model,
                                  NonLocalManagerCallback & callback,
                                  const ID & id, const MemoryID & memory_id)
     : Memory(id, memory_id), Parsable(_st_neighborhoods, id),
       spatial_dimension(model.getMesh().getSpatialDimension()), model(model),
       integration_points_positions("integration_points_positions", id,
                                    memory_id),
       volumes("volumes", id, memory_id), compute_stress_calls(0),
       dummy_registry(nullptr), dummy_grid(nullptr) {
   /// parse the neighborhood information from the input file
   const Parser & parser = getStaticParser();
 
   /// iterate over all the non-local sections and store them in a map
   std::pair<Parser::const_section_iterator, Parser::const_section_iterator>
       weight_sect = parser.getSubSections(_st_non_local);
   Parser::const_section_iterator it = weight_sect.first;
   for (; it != weight_sect.second; ++it) {
     const ParserSection & section = *it;
     ID name = section.getName();
     this->weight_function_types[name] = section;
   }
 
   this->callback = &callback;
 }
 
 /* -------------------------------------------------------------------------- */
 NonLocalManager::~NonLocalManager() = default;
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::initialize() {
   volumes.initialize(this->model.getFEEngine(),
                      _spatial_dimension = spatial_dimension);
 
   AKANTU_DEBUG_ASSERT(this->callback,
                       "A callback should be registered prior to this call");
   this->callback->insertIntegrationPointsInNeighborhoods(_not_ghost);
 
   auto & mesh = this->model.getMesh();
   mesh.registerEventHandler(*this, _ehp_non_local_manager);
 
   /// store the number of current ghost elements for each type in the mesh
   //ElementTypeMap<UInt> nb_ghost_protected;
   // for (auto type : mesh.elementTypes(spatial_dimension, _ghost))
   //   nb_ghost_protected(mesh.getNbElement(type, _ghost), type, _ghost);
 
   /// exchange the missing ghosts for the non-local neighborhoods
   this->createNeighborhoodSynchronizers();
 
   /// insert the ghost quadrature points of the non-local materials into the
   /// non-local neighborhoods
   this->callback->insertIntegrationPointsInNeighborhoods(_ghost);
 
   FEEngine & fee = this->model.getFEEngine();
   this->updatePairLists();
 
   /// cleanup the unneccessary ghost elements
   this->cleanupExtraGhostElements(); //nb_ghost_protected);
 
   this->callback->initializeNonLocal();
 
   this->setJacobians(fee, _ek_regular);
 
   this->initNonLocalVariables();
   this->computeWeights();
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::setJacobians(const FEEngine & fe_engine,
                                    const ElementKind & kind) {
   Mesh & mesh = this->model.getMesh();
   for (auto ghost_type : ghost_types) {
     for (auto type : mesh.elementTypes(spatial_dimension, ghost_type, kind)) {
       jacobians(type, ghost_type) =
           &fe_engine.getIntegratorInterface().getJacobians(type, ghost_type);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::createNeighborhood(const ID & weight_func,
                                          const ID & neighborhood_id) {
 
   AKANTU_DEBUG_IN();
 
   auto weight_func_it = this->weight_function_types.find(weight_func);
   AKANTU_DEBUG_ASSERT(weight_func_it != weight_function_types.end(),
                       "No info found in the input file for the weight_function "
                           << weight_func << " in the neighborhood "
                           << neighborhood_id);
 
   const ParserSection & section = weight_func_it->second;
   const ID weight_func_type = section.getOption();
   /// create new neighborhood for given ID
   std::stringstream sstr;
   sstr << id << ":neighborhood:" << neighborhood_id;
 
   if (weight_func_type == "base_wf")
     neighborhoods[neighborhood_id] =
         std::make_unique<NonLocalNeighborhood<BaseWeightFunction>>(
             *this, this->integration_points_positions, sstr.str());
 #if defined(AKANTU_DAMAGE_NON_LOCAL)
   else if (weight_func_type == "remove_wf")
     neighborhoods[neighborhood_id] =
         std::make_unique<NonLocalNeighborhood<RemoveDamagedWeightFunction>>(
             *this, this->integration_points_positions, sstr.str());
   else if (weight_func_type == "stress_wf")
     neighborhoods[neighborhood_id] =
         std::make_unique<NonLocalNeighborhood<StressBasedWeightFunction>>(
             *this, this->integration_points_positions, sstr.str());
   else if (weight_func_type == "damage_wf")
     neighborhoods[neighborhood_id] =
         std::make_unique<NonLocalNeighborhood<DamagedWeightFunction>>(
             *this, this->integration_points_positions, sstr.str());
 #endif
   else
     AKANTU_EXCEPTION("error in weight function type provided in material file");
 
   neighborhoods[neighborhood_id]->parseSection(section);
   neighborhoods[neighborhood_id]->initNeighborhood();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::createNeighborhoodSynchronizers() {
   /// exchange all the neighborhood IDs, so that every proc knows how many
   /// neighborhoods exist globally
   /// First: Compute locally the maximum ID size
   UInt max_id_size = 0;
   UInt current_size = 0;
   NeighborhoodMap::const_iterator it;
   for (it = neighborhoods.begin(); it != neighborhoods.end(); ++it) {
     current_size = it->first.size();
     if (current_size > max_id_size)
       max_id_size = current_size;
   }
 
   /// get the global maximum ID size on each proc
   const Communicator & static_communicator =
       model.getMesh().getCommunicator();
   static_communicator.allReduce(max_id_size, SynchronizerOperation::_max);
 
   /// get the rank for this proc and the total nb proc
   UInt prank = static_communicator.whoAmI();
   UInt psize = static_communicator.getNbProc();
 
   /// exchange the number of neighborhoods on each proc
   Array<Int> nb_neighborhoods_per_proc(psize);
   nb_neighborhoods_per_proc(prank) = neighborhoods.size();
   static_communicator.allGather(nb_neighborhoods_per_proc);
 
   /// compute the total number of neighborhoods
   UInt nb_neighborhoods_global = std::accumulate(
       nb_neighborhoods_per_proc.begin(), nb_neighborhoods_per_proc.end(), 0);
 
   /// allocate an array of chars to store the names of all neighborhoods
   Array<char> buffer(nb_neighborhoods_global, max_id_size);
 
   /// starting index on this proc
   UInt starting_index =
       std::accumulate(nb_neighborhoods_per_proc.begin(),
                       nb_neighborhoods_per_proc.begin() + prank, 0);
 
   it = neighborhoods.begin();
   /// store the names of local neighborhoods in the buffer
   for (UInt i = 0; i < neighborhoods.size(); ++i, ++it) {
     UInt c = 0;
     for (; c < it->first.size(); ++c)
       buffer(i + starting_index, c) = it->first[c];
 
     for (; c < max_id_size; ++c)
       buffer(i + starting_index, c) = char(0);
   }
 
   /// store the nb of data to send in the all gather
   Array<Int> buffer_size(nb_neighborhoods_per_proc);
   buffer_size *= max_id_size;
   /// exchange the names of all the neighborhoods with all procs
   static_communicator.allGatherV(buffer, buffer_size);
 
   for (UInt i = 0; i < nb_neighborhoods_global; ++i) {
     std::stringstream neighborhood_id;
     for (UInt c = 0; c < max_id_size; ++c) {
       if (buffer(i, c) == char(0))
         break;
       neighborhood_id << buffer(i, c);
     }
     global_neighborhoods.insert(neighborhood_id.str());
   }
 
   /// this proc does not know all the neighborhoods -> create dummy
   /// grid so that this proc can participate in the all gather for
   /// detecting the overlap of neighborhoods this proc doesn't know
   Vector<Real> grid_center(this->spatial_dimension,
                            std::numeric_limits<Real>::max());
   Vector<Real> spacing(this->spatial_dimension, 0.);
 
   dummy_grid = std::make_unique<SpatialGrid<IntegrationPoint>>(
       this->spatial_dimension, spacing, grid_center);
 
   for (auto & neighborhood_id : global_neighborhoods) {
     it = neighborhoods.find(neighborhood_id);
     if (it != neighborhoods.end()) {
       it->second->createGridSynchronizer();
     } else {
       dummy_synchronizers[neighborhood_id] = std::make_unique<GridSynchronizer>(
           this->model.getMesh(), *dummy_grid,
           std::string(this->id + ":" + neighborhood_id + ":grid_synchronizer"),
           this->memory_id, false);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::synchronize(DataAccessor<Element> & data_accessor, const SynchronizationTag & tag) {
   for (auto & neighborhood_id : global_neighborhoods) {
     auto it = neighborhoods.find(neighborhood_id);
     if (it != neighborhoods.end()) {
       it->second->synchronize(data_accessor, tag);
     } else {
       auto synchronizer_it = dummy_synchronizers.find(neighborhood_id);
       if (synchronizer_it == dummy_synchronizers.end()) continue;
 
       synchronizer_it->second->synchronizeOnce(data_accessor, tag);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::averageInternals(const GhostType & ghost_type) {
   /// update the weights of the weight function
   if (ghost_type == _not_ghost)
     this->computeWeights();
 
   /// loop over all neighborhoods and compute the non-local variables
   for (auto & neighborhood : neighborhoods) {
     /// loop over all the non-local variables of the given neighborhood
     for (auto & non_local_variable : non_local_variables) {
       NonLocalVariable & non_local_var = *non_local_variable.second;
       neighborhood.second->weightedAverageOnNeighbours(
           non_local_var.local, non_local_var.non_local,
           non_local_var.nb_component, ghost_type);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::computeWeights() {
   AKANTU_DEBUG_IN();
 
   this->updateWeightFunctionInternals();
   this->volumes.clear();
 
-  for (auto global_neighborhood : global_neighborhoods) {
+  for (const auto & global_neighborhood : global_neighborhoods) {
     auto it = neighborhoods.find(global_neighborhood);
 
     if (it != neighborhoods.end())
       it->second->updateWeights();
     else {
       dummy_synchronizers[global_neighborhood]->synchronize(dummy_accessor,
                                                             _gst_mnl_weight);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::updatePairLists() {
   AKANTU_DEBUG_IN();
 
   integration_points_positions.initialize(
       this->model.getFEEngine(), _nb_component = spatial_dimension,
       _spatial_dimension = spatial_dimension);
 
   /// compute the position of the quadrature points
   this->model.getFEEngine().computeIntegrationPointsCoordinates(
       integration_points_positions);
 
   for (auto & pair : neighborhoods)
     pair.second->updatePairList();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::registerNonLocalVariable(const ID & variable_name,
                                                const ID & nl_variable_name,
                                                UInt nb_component) {
 
   AKANTU_DEBUG_IN();
 
   auto non_local_variable_it = non_local_variables.find(variable_name);
 
   if (non_local_variable_it == non_local_variables.end())
     non_local_variables[nl_variable_name] = std::make_unique<NonLocalVariable>(
         variable_name, nl_variable_name, this->id, nb_component);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 ElementTypeMapReal &
 NonLocalManager::registerWeightFunctionInternal(const ID & field_name) {
 
   AKANTU_DEBUG_IN();
 
   auto it = this->weight_function_internals.find(field_name);
   if (it == weight_function_internals.end()) {
     weight_function_internals[field_name] =
         std::make_unique<ElementTypeMapReal>(field_name, this->id,
                                              this->memory_id);
   }
 
   return *(weight_function_internals[field_name]);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::updateWeightFunctionInternals() {
   for (auto & pair : this->weight_function_internals) {
     auto & internals = *pair.second;
     internals.clear();
     for (auto ghost_type : ghost_types)
       this->callback->updateLocalInternal(internals, ghost_type, _ek_regular);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::initNonLocalVariables() {
   /// loop over all the non-local variables
   for (auto & pair : non_local_variables) {
     auto & variable = *pair.second;
     variable.non_local.initialize(this->model.getFEEngine(),
                                   _nb_component = variable.nb_component,
                                   _spatial_dimension = spatial_dimension);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::computeAllNonLocalStresses() {
 
   /// update the flattened version of the internals
   for (auto & pair : non_local_variables) {
     auto & variable = *pair.second;
     variable.local.clear();
     variable.non_local.clear();
     for (auto ghost_type : ghost_types) {
       this->callback->updateLocalInternal(variable.local, ghost_type,
                                           _ek_regular);
     }
   }
 
   this->volumes.clear();
 
   for (auto & pair : neighborhoods) {
     auto & neighborhood = *pair.second;
     neighborhood.asynchronousSynchronize(_gst_mnl_for_average);
   }
 
   this->averageInternals(_not_ghost);
 
   AKANTU_DEBUG_INFO("Wait distant non local stresses");
 
   for (auto & pair : neighborhoods) {
     auto & neighborhood = *pair.second;
     neighborhood.waitEndSynchronize(_gst_mnl_for_average);
   }
 
   this->averageInternals(_ghost);
 
   /// copy the results in the materials
   for (auto & pair : non_local_variables) {
     auto & variable = *pair.second;
     for (auto ghost_type : ghost_types) {
       this->callback->updateNonLocalInternal(variable.non_local, ghost_type,
                                              _ek_regular);
     }
   }
 
   this->callback->computeNonLocalStresses(_not_ghost);
 
   ++this->compute_stress_calls;
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::cleanupExtraGhostElements() {
     //ElementTypeMap<UInt> & nb_ghost_protected) {
 
   using ElementSet = std::set<Element>;
   ElementSet relevant_ghost_elements;
 
   /// loop over all the neighborhoods and get their protected ghosts
   for (auto & pair : neighborhoods) {
     auto & neighborhood = *pair.second;
     ElementSet to_keep_per_neighborhood;
 
     neighborhood.cleanupExtraGhostElements(to_keep_per_neighborhood);
     for (auto & element : to_keep_per_neighborhood)
       relevant_ghost_elements.insert(element);
   }
 
   // /// remove all unneccessary ghosts from the mesh
   // /// Create list of element to remove and new numbering for element to keep
   // Mesh & mesh = this->model.getMesh();
   // ElementSet ghost_to_erase;
 
   // RemovedElementsEvent remove_elem(mesh);
   // auto & new_numberings = remove_elem.getNewNumbering();
   // Element element;
   // element.ghost_type = _ghost;
 
   // for (auto & type : mesh.elementTypes(spatial_dimension, _ghost)) {
   //   element.type = type;
   //   UInt nb_ghost_elem = mesh.getNbElement(type, _ghost);
   //   // UInt nb_ghost_elem_protected = 0;
   //   // try {
   //   //   nb_ghost_elem_protected = nb_ghost_protected(type, _ghost);
   //   // } catch (...) {
   //   // }
 
   //   if (!new_numberings.exists(type, _ghost))
   //     new_numberings.alloc(nb_ghost_elem, 1, type, _ghost);
   //   else
   //     new_numberings(type, _ghost).resize(nb_ghost_elem);
 
   //   Array<UInt> & new_numbering = new_numberings(type, _ghost);
   //   for (UInt g = 0; g < nb_ghost_elem; ++g) {
   //     element.element = g;
   //     if (element.element >= nb_ghost_elem_protected &&
   //         relevant_ghost_elements.find(element) ==
   //             relevant_ghost_elements.end()) {
   //       remove_elem.getList().push_back(element);
   //       new_numbering(element.element) = UInt(-1);
   //     }
   //   }
   //   /// renumber remaining ghosts
   //   UInt ng = 0;
   //   for (UInt g = 0; g < nb_ghost_elem; ++g) {
   //     if (new_numbering(g) != UInt(-1)) {
   //       new_numbering(g) = ng;
   //       ++ng;
   //     }
   //   }
   // }
 
   // for (auto & type : mesh.elementTypes(spatial_dimension, _not_ghost)) {
   //   UInt nb_elem = mesh.getNbElement(type, _not_ghost);
   //   if (!new_numberings.exists(type, _not_ghost))
   //     new_numberings.alloc(nb_elem, 1, type, _not_ghost);
   //   Array<UInt> & new_numbering = new_numberings(type, _not_ghost);
   //   for (UInt e = 0; e < nb_elem; ++e) {
   //     new_numbering(e) = e;
   //   }
   // }
   // mesh.sendEvent(remove_elem);
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::onElementsRemoved(
     const Array<Element> & element_list,
     const ElementTypeMapArray<UInt> & new_numbering,
     __attribute__((unused)) const RemovedElementsEvent & event) {
 
   FEEngine & fee = this->model.getFEEngine();
   this->removeIntegrationPointsFromMap(
       event.getNewNumbering(), spatial_dimension, integration_points_positions,
       fee, _ek_regular);
   this->removeIntegrationPointsFromMap(event.getNewNumbering(), 1, volumes, fee,
                                        _ek_regular);
 
   /// loop over all the neighborhoods and call onElementsRemoved
-  std::set<ID>::const_iterator global_neighborhood_it =
-      global_neighborhoods.begin();
+  auto global_neighborhood_it = global_neighborhoods.begin();
   NeighborhoodMap::iterator it;
   for (; global_neighborhood_it != global_neighborhoods.end();
        ++global_neighborhood_it) {
     it = neighborhoods.find(*global_neighborhood_it);
     if (it != neighborhoods.end())
       it->second->onElementsRemoved(element_list, new_numbering, event);
     else
       dummy_synchronizers[*global_neighborhood_it]->onElementsRemoved(
           element_list, new_numbering, event);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::onElementsAdded(const Array<Element> &,
                                       const NewElementsEvent &) {
   this->resizeElementTypeMap(1, volumes, model.getFEEngine());
   this->resizeElementTypeMap(spatial_dimension, integration_points_positions,
                              model.getFEEngine());
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::resizeElementTypeMap(UInt nb_component,
                                            ElementTypeMapReal & element_map,
                                            const FEEngine & fee,
                                            const ElementKind el_kind) {
   Mesh & mesh = this->model.getMesh();
 
   for (auto gt : ghost_types) {
     for (auto type : mesh.elementTypes(spatial_dimension, gt, el_kind)) {
       UInt nb_element = mesh.getNbElement(type, gt);
       UInt nb_quads = fee.getNbIntegrationPoints(type, gt);
       if (!element_map.exists(type, gt))
         element_map.alloc(nb_element * nb_quads, nb_component, type, gt);
       else
         element_map(type, gt).resize(nb_element * nb_quads);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::removeIntegrationPointsFromMap(
     const ElementTypeMapArray<UInt> & new_numbering, UInt nb_component,
     ElementTypeMapReal & element_map, const FEEngine & fee,
     const ElementKind el_kind) {
 
   for (auto gt : ghost_types) {
     for (auto type : new_numbering.elementTypes(_all_dimensions, gt, el_kind)) {
       if (element_map.exists(type, gt)) {
         const Array<UInt> & renumbering = new_numbering(type, gt);
 
         Array<Real> & vect = element_map(type, gt);
         UInt nb_quad_per_elem = fee.getNbIntegrationPoints(type, gt);
         Array<Real> tmp(renumbering.size() * nb_quad_per_elem, nb_component);
 
         AKANTU_DEBUG_ASSERT(
             tmp.size() == vect.size(),
             "Something strange append some mater was created or disappeared in "
                 << vect.getID() << "(" << vect.size() << "!=" << tmp.size()
                 << ") "
                    "!!");
 
         UInt new_size = 0;
         for (UInt i = 0; i < renumbering.size(); ++i) {
           UInt new_i = renumbering(i);
           if (new_i != UInt(-1)) {
             memcpy(tmp.storage() + new_i * nb_component * nb_quad_per_elem,
                    vect.storage() + i * nb_component * nb_quad_per_elem,
                    nb_component * nb_quad_per_elem * sizeof(Real));
             ++new_size;
           }
         }
         tmp.resize(new_size * nb_quad_per_elem);
         vect.copy(tmp);
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 UInt NonLocalManager::getNbData(const Array<Element> & elements,
                                 const ID & id) const {
   UInt size = 0;
   UInt nb_quadrature_points = this->model.getNbIntegrationPoints(elements);
   auto it = non_local_variables.find(id);
 
   AKANTU_DEBUG_ASSERT(it != non_local_variables.end(),
                       "The non-local variable " << id << " is not registered");
 
   size += it->second->nb_component * sizeof(Real) * nb_quadrature_points;
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::packData(CommunicationBuffer & buffer,
                                const Array<Element> & elements,
                                const ID & id) const {
 
   auto it = non_local_variables.find(id);
 
   AKANTU_DEBUG_ASSERT(it != non_local_variables.end(),
                       "The non-local variable " << id << " is not registered");
 
   DataAccessor<Element>::packElementalDataHelper<Real>(
       it->second->local, buffer, elements, true, this->model.getFEEngine());
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::unpackData(CommunicationBuffer & buffer,
                                  const Array<Element> & elements,
                                  const ID & id) const {
   auto it = non_local_variables.find(id);
 
   AKANTU_DEBUG_ASSERT(it != non_local_variables.end(),
                       "The non-local variable " << id << " is not registered");
 
   DataAccessor<Element>::unpackElementalDataHelper<Real>(
       it->second->local, buffer, elements, true, this->model.getFEEngine());
 }
 
 } // namespace akantu
diff --git a/src/model/common/non_local_toolbox/non_local_neighborhood_tmpl.hh b/src/model/common/non_local_toolbox/non_local_neighborhood_tmpl.hh
index aa4f9a31d..b11d6d0ae 100644
--- a/src/model/common/non_local_toolbox/non_local_neighborhood_tmpl.hh
+++ b/src/model/common/non_local_toolbox/non_local_neighborhood_tmpl.hh
@@ -1,280 +1,280 @@
 /**
  * @file   non_local_neighborhood_tmpl.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Sep 28 2015
  * @date last modification: Wed Nov 25 2015
  *
  * @brief  Implementation of class non-local neighborhood
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "non_local_manager.hh"
 #include "non_local_neighborhood.hh"
 #include "communicator.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_NON_LOCAL_NEIGHBORHOOD_TMPL_HH__
 #define __AKANTU_NON_LOCAL_NEIGHBORHOOD_TMPL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class WeightFunction>
 template <class Func>
 inline void NonLocalNeighborhood<WeightFunction>::foreach_weight(
     const GhostType & ghost_type, Func && func) {
   auto weight_it =
       pair_weight[ghost_type]->begin(pair_weight[ghost_type]->getNbComponent());
 
   for (auto & pair : pair_list[ghost_type]) {
     std::forward<decltype(func)>(func)(pair.first, pair.second, *weight_it);
     ++weight_it;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <class WeightFunction>
 template <class Func>
 inline void NonLocalNeighborhood<WeightFunction>::foreach_weight(
     const GhostType & ghost_type, Func && func) const {
   auto weight_it =
       pair_weight[ghost_type]->begin(pair_weight[ghost_type]->getNbComponent());
 
   for (auto & pair : pair_list[ghost_type]) {
     std::forward<decltype(func)>(func)(pair.first, pair.second, *weight_it);
     ++weight_it;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <class WeightFunction>
 NonLocalNeighborhood<WeightFunction>::NonLocalNeighborhood(
     NonLocalManager & manager, const ElementTypeMapReal & quad_coordinates,
     const ID & id, const MemoryID & memory_id)
     : NonLocalNeighborhoodBase(manager.getModel(), quad_coordinates, id,
                                memory_id),
       non_local_manager(manager) {
   AKANTU_DEBUG_IN();
 
   this->weight_function = std::make_unique<WeightFunction>(manager);
 
   this->registerSubSection(_st_weight_function, "weight_parameter",
                            *weight_function);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class WeightFunction>
 NonLocalNeighborhood<WeightFunction>::~NonLocalNeighborhood() = default;
 
 /* -------------------------------------------------------------------------- */
 template <class WeightFunction>
 void NonLocalNeighborhood<WeightFunction>::computeWeights() {
   AKANTU_DEBUG_IN();
 
   this->weight_function->setRadius(this->neighborhood_radius);
   Vector<Real> q1_coord(this->spatial_dimension);
   Vector<Real> q2_coord(this->spatial_dimension);
 
   UInt nb_weights_per_pair = 2; /// w1: q1->q2, w2: q2->q1
 
   /// get the elementtypemap for the neighborhood volume for each quadrature
   /// point
   ElementTypeMapReal & quadrature_points_volumes =
       this->non_local_manager.getVolumes();
 
   /// update the internals of the weight function if applicable (not
   /// all the weight functions have internals and do noting in that
   /// case)
   weight_function->updateInternals();
 
   for (auto ghost_type : ghost_types) {
     /// allocate the array to store the weight, if it doesn't exist already
     if (!(pair_weight[ghost_type])) {
       pair_weight[ghost_type] =
           std::make_unique<Array<Real>>(0, nb_weights_per_pair);
     }
 
     /// resize the array to the correct size
     pair_weight[ghost_type]->resize(pair_list[ghost_type].size());
     /// set entries to zero
     pair_weight[ghost_type]->clear();
 
     /// loop over all pairs in the current pair list array and their
     /// corresponding weights
-    PairList::const_iterator first_pair = pair_list[ghost_type].begin();
-    PairList::const_iterator last_pair = pair_list[ghost_type].end();
+    auto first_pair = pair_list[ghost_type].begin();
+    auto last_pair = pair_list[ghost_type].end();
     Array<Real>::vector_iterator weight_it =
         pair_weight[ghost_type]->begin(nb_weights_per_pair);
 
     // Compute the weights
     for (; first_pair != last_pair; ++first_pair, ++weight_it) {
       Vector<Real> & weight = *weight_it;
       const IntegrationPoint & q1 = first_pair->first;
       const IntegrationPoint & q2 = first_pair->second;
 
       /// get the coordinates for the given pair of quads
       Array<Real>::const_vector_iterator coords_type_1_it =
           this->quad_coordinates(q1.type, q1.ghost_type)
               .begin(this->spatial_dimension);
       q1_coord = coords_type_1_it[q1.global_num];
       Array<Real>::const_vector_iterator coords_type_2_it =
           this->quad_coordinates(q2.type, q2.ghost_type)
               .begin(this->spatial_dimension);
       q2_coord = coords_type_2_it[q2.global_num];
 
       Array<Real> & quad_volumes_1 =
           quadrature_points_volumes(q1.type, q1.ghost_type);
       const Array<Real> & jacobians_2 =
           this->non_local_manager.getJacobians(q2.type, q2.ghost_type);
       const Real & q2_wJ = jacobians_2(q2.global_num);
 
       /// compute distance between the two quadrature points
       Real r = q1_coord.distance(q2_coord);
 
       /// compute the weight for averaging on q1 based on the distance
       Real w1 = this->weight_function->operator()(r, q1, q2);
       weight(0) = q2_wJ * w1;
 
       quad_volumes_1(q1.global_num) += weight(0);
 
       if (q2.ghost_type != _ghost && q1.global_num != q2.global_num) {
         const Array<Real> & jacobians_1 =
             this->non_local_manager.getJacobians(q1.type, q1.ghost_type);
         Array<Real> & quad_volumes_2 =
             quadrature_points_volumes(q2.type, q2.ghost_type);
         /// compute the weight for averaging on q2
         const Real & q1_wJ = jacobians_1(q1.global_num);
         Real w2 = this->weight_function->operator()(r, q2, q1);
         weight(1) = q1_wJ * w2;
         quad_volumes_2(q2.global_num) += weight(1);
       } else
         weight(1) = 0.;
     }
   }
 
   ///  normalize the weights
   for (auto ghost_type : ghost_types) {
     foreach_weight(ghost_type, [&](
                                    const auto & q1, const auto & q2,
                                    auto & weight) {
       auto & quad_volumes_1 = quadrature_points_volumes(q1.type, q1.ghost_type);
       auto & quad_volumes_2 = quadrature_points_volumes(q2.type, q2.ghost_type);
 
       Real q1_volume = quad_volumes_1(q1.global_num);
       auto ghost_type2 = q2.ghost_type;
       weight(0) *= 1. / q1_volume;
       if (ghost_type2 != _ghost) {
         Real q2_volume = quad_volumes_2(q2.global_num);
         weight(1) *= 1. / q2_volume;
       }
     });
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class WeightFunction>
 void NonLocalNeighborhood<WeightFunction>::saveWeights(
     const std::string & filename) const {
   std::ofstream pout;
 
   std::stringstream sstr;
 
   const Communicator & comm = model.getMesh().getCommunicator();
 
   Int prank = comm.whoAmI();
   sstr << filename << "." << prank;
 
   pout.open(sstr.str().c_str());
 
   for (UInt gt = _not_ghost; gt <= _ghost; ++gt) {
-    GhostType ghost_type = (GhostType)gt;
+    auto ghost_type = (GhostType)gt;
 
     AKANTU_DEBUG_ASSERT((pair_weight[ghost_type]),
                         "the weights have not been computed yet");
 
     Array<Real> & weights = *(pair_weight[ghost_type]);
     Array<Real>::const_vector_iterator weights_it = weights.begin(2);
     for (UInt i = 0; i < weights.size(); ++i, ++weights_it)
       pout << "w1: " << (*weights_it)(0) << " w2: " << (*weights_it)(1)
            << std::endl;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <class WeightFunction>
 void NonLocalNeighborhood<WeightFunction>::weightedAverageOnNeighbours(
     const ElementTypeMapReal & to_accumulate, ElementTypeMapReal & accumulated,
     UInt nb_degree_of_freedom, const GhostType & ghost_type2) const {
 
   auto it = non_local_variables.find(accumulated.getName());
   // do averaging only for variables registered in the neighborhood
   if (it == non_local_variables.end())
     return;
 
   foreach_weight(
       ghost_type2,
       [ghost_type2, nb_degree_of_freedom, &to_accumulate,
        &accumulated](const auto & q1, const auto & q2, auto & weight) {
         const Vector<Real> to_acc_1 =
             to_accumulate(q1.type, q1.ghost_type)
                 .begin(nb_degree_of_freedom)[q1.global_num];
         const Vector<Real> to_acc_2 =
             to_accumulate(q2.type, q2.ghost_type)
                 .begin(nb_degree_of_freedom)[q2.global_num];
         Vector<Real> acc_1 = accumulated(q1.type, q1.ghost_type)
                                  .begin(nb_degree_of_freedom)[q1.global_num];
         Vector<Real> acc_2 = accumulated(q2.type, q2.ghost_type)
                                  .begin(nb_degree_of_freedom)[q2.global_num];
 
         acc_1 += weight(0) * to_acc_2;
 
         if (ghost_type2 != _ghost) {
           acc_2 += weight(1) * to_acc_1;
         }
       });
 }
 
 /* -------------------------------------------------------------------------- */
 template <class WeightFunction>
 void NonLocalNeighborhood<WeightFunction>::updateWeights() {
   // Update the weights for the non local variable averaging
   if (this->weight_function->getUpdateRate() &&
       (this->non_local_manager.getNbStressCalls() %
            this->weight_function->getUpdateRate() ==
        0)) {
     SynchronizerRegistry::synchronize(_gst_mnl_weight);
     this->computeWeights();
   }
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_NON_LOCAL_NEIGHBORHOOD_TMPL__ */
diff --git a/src/model/dof_manager.cc b/src/model/dof_manager.cc
index c7db77db8..6e28f5d79 100644
--- a/src/model/dof_manager.cc
+++ b/src/model/dof_manager.cc
@@ -1,595 +1,592 @@
 /**
  * @file   dof_manager.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Aug 12 09:52:30 2015
  *
  * @brief  Implementation of the common parts of the DOFManagers
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dof_manager.hh"
 #include "element_group.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 #include "node_group.hh"
 #include "non_linear_solver.hh"
 #include "sparse_matrix.hh"
 #include "communicator.hh"
 #include "time_step_solver.hh"
 /* -------------------------------------------------------------------------- */
 #include <memory>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFManager(const ID & id, const MemoryID & memory_id)
-    : Memory(id, memory_id), mesh(nullptr), local_system_size(0),
-      pure_local_system_size(0), system_size(0),
+    : Memory(id, memory_id),
       communicator(Communicator::getStaticCommunicator()) {}
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFManager(Mesh & mesh, const ID & id, const MemoryID & memory_id)
     : Memory(id, memory_id), mesh(&mesh), local_system_size(0),
       pure_local_system_size(0), system_size(0),
       communicator(mesh.getCommunicator()) {
   this->mesh->registerEventHandler(*this, _ehp_dof_manager);
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManager::~DOFManager() = default;
 
 /* -------------------------------------------------------------------------- */
 // void DOFManager::getEquationsNumbers(const ID &, Array<UInt> &) {
 //   AKANTU_DEBUG_TO_IMPLEMENT();
 // }
 
 /* -------------------------------------------------------------------------- */
 std::vector<ID> DOFManager::getDOFIDs() const {
   std::vector<ID> keys;
   for (const auto & dof_data : this->dofs)
     keys.push_back(dof_data.first);
 
   return keys;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::assembleElementalArrayLocalArray(
     const Array<Real> & elementary_vect, Array<Real> & array_assembeled,
     const ElementType & type, const GhostType & ghost_type, Real scale_factor,
     const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   UInt nb_element;
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_degree_of_freedom =
       elementary_vect.getNbComponent() / nb_nodes_per_element;
 
   UInt * filter_it = nullptr;
   if (filter_elements != empty_filter) {
     nb_element = filter_elements.size();
     filter_it = filter_elements.storage();
   } else {
     nb_element = this->mesh->getNbElement(type, ghost_type);
   }
 
   AKANTU_DEBUG_ASSERT(elementary_vect.size() == nb_element,
                       "The vector elementary_vect("
                           << elementary_vect.getID()
                           << ") has not the good size.");
 
   const Array<UInt> & connectivity =
       this->mesh->getConnectivity(type, ghost_type);
   // Array<UInt>::const_vector_iterator conn_begin =
   //     connectivity.begin(nb_nodes_per_element);
   // Array<UInt>::const_vector_iterator conn_it = conn_begin;
 
   Array<Real>::const_matrix_iterator elem_it =
       elementary_vect.begin(nb_degree_of_freedom, nb_nodes_per_element);
 
   for (UInt el = 0; el < nb_element; ++el, ++elem_it) {
     UInt element = el;
     if (filter_it != nullptr) {
       // conn_it = conn_begin + *filter_it;
       element = *filter_it;
     }
 
     // const Vector<UInt> & conn = *conn_it;
     const Matrix<Real> & elemental_val = *elem_it;
     for (UInt n = 0; n < nb_nodes_per_element; ++n) {
       UInt offset_node = connectivity(element, n) * nb_degree_of_freedom;
       Vector<Real> assemble(array_assembeled.storage() + offset_node,
                             nb_degree_of_freedom);
       Vector<Real> elem_val = elemental_val(n);
       assemble.aXplusY(elem_val, scale_factor);
     }
 
     if (filter_it != nullptr)
       ++filter_it;
     //    else
     //      ++conn_it;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::assembleElementalArrayToResidual(
     const ID & dof_id, const Array<Real> & elementary_vect,
     const ElementType & type, const GhostType & ghost_type, Real scale_factor,
     const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_degree_of_freedom =
       elementary_vect.getNbComponent() / nb_nodes_per_element;
   Array<Real> array_localy_assembeled(this->mesh->getNbNodes(),
                                       nb_degree_of_freedom);
 
   array_localy_assembeled.clear();
 
   this->assembleElementalArrayLocalArray(
       elementary_vect, array_localy_assembeled, type, ghost_type, scale_factor,
       filter_elements);
 
   this->assembleToResidual(dof_id, array_localy_assembeled, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::assembleElementalArrayToLumpedMatrix(
     const ID & dof_id, const Array<Real> & elementary_vect,
     const ID & lumped_mtx, const ElementType & type,
     const GhostType & ghost_type, Real scale_factor,
     const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_degree_of_freedom =
       elementary_vect.getNbComponent() / nb_nodes_per_element;
   Array<Real> array_localy_assembeled(this->mesh->getNbNodes(),
                                       nb_degree_of_freedom);
 
   array_localy_assembeled.clear();
 
   this->assembleElementalArrayLocalArray(
       elementary_vect, array_localy_assembeled, type, ghost_type, scale_factor,
       filter_elements);
 
   this->assembleToLumpedMatrix(dof_id, array_localy_assembeled, lumped_mtx, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFData::DOFData(const ID & dof_id)
     : support_type(_dst_generic), group_support("__mesh__"), dof(nullptr),
       blocked_dofs(nullptr), increment(nullptr), previous(nullptr),
       solution(0, 1, dof_id + ":solution"),
       local_equation_number(0, 1, dof_id + ":local_equation_number") {}
 
 /* -------------------------------------------------------------------------- */
-DOFManager::DOFData::~DOFData() {}
+DOFManager::DOFData::~DOFData() = default;
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFData & DOFManager::getNewDOFData(const ID & dof_id) {
-  DOFStorage::iterator it = this->dofs.find(dof_id);
+  auto it = this->dofs.find(dof_id);
   if (it != this->dofs.end()) {
     AKANTU_EXCEPTION("This dof array has already been registered");
   }
 
   std::unique_ptr<DOFData> dofs_storage = std::make_unique<DOFData>(dof_id);
   this->dofs[dof_id] = std::move(dofs_storage);
   return *dofs_storage;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFsInternal(const ID & dof_id,
                                       Array<Real> & dofs_array) {
   DOFData & dofs_storage = this->getDOFData(dof_id);
   dofs_storage.dof = &dofs_array;
 
   UInt nb_local_dofs = 0;
   UInt nb_pure_local = 0;
 
   const DOFSupportType & support_type = dofs_storage.support_type;
 
   switch (support_type) {
   case _dst_nodal: {
     UInt nb_nodes = 0;
     const ID & group = dofs_storage.group_support;
 
     NodeGroup * node_group = nullptr;
     if (group == "__mesh__") {
       nb_nodes = this->mesh->getNbNodes();
     } else {
       node_group = &this->mesh->getElementGroup(group).getNodeGroup();
       nb_nodes = node_group->size();
     }
 
     nb_local_dofs = nb_nodes;
     AKANTU_DEBUG_ASSERT(
         dofs_array.size() == nb_local_dofs,
         "The array of dof is too shot to be associated to nodes.");
 
     for (UInt n = 0; n < nb_nodes; ++n) {
       UInt node = n;
       if (node_group)
         node = node_group->getNodes()(n);
 
       nb_pure_local += this->mesh->isLocalOrMasterNode(node) ? 1 : 0;
     }
 
     nb_pure_local *= dofs_array.getNbComponent();
     nb_local_dofs *= dofs_array.getNbComponent();
     break;
   }
   case _dst_generic: {
     nb_local_dofs = nb_pure_local =
         dofs_array.size() * dofs_array.getNbComponent();
     break;
   }
   default: { AKANTU_EXCEPTION("This type of dofs is not handled yet."); }
   }
 
   this->pure_local_system_size += nb_pure_local;
   this->local_system_size += nb_local_dofs;
 
   communicator.allReduce(nb_pure_local, SynchronizerOperation::_sum);
 
   this->system_size += nb_pure_local;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFs(const ID & dof_id, Array<Real> & dofs_array,
                               const DOFSupportType & support_type) {
   DOFData & dofs_storage = this->getNewDOFData(dof_id);
   dofs_storage.support_type = support_type;
 
   this->registerDOFsInternal(dof_id, dofs_array);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFs(const ID & dof_id, Array<Real> & dofs_array,
                               const ID & support_group) {
   DOFData & dofs_storage = this->getNewDOFData(dof_id);
   dofs_storage.support_type = _dst_nodal;
   dofs_storage.group_support = support_group;
 
   this->registerDOFsInternal(dof_id, dofs_array);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFsPrevious(const ID & dof_id, Array<Real> & array) {
   DOFData & dof = this->getDOFData(dof_id);
 
   if (dof.previous != nullptr) {
     AKANTU_EXCEPTION("The previous dofs array for "
                      << dof_id << " has already been registered");
   }
 
   dof.previous = &array;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFsIncrement(const ID & dof_id, Array<Real> & array) {
   DOFData & dof = this->getDOFData(dof_id);
 
   if (dof.increment != nullptr) {
     AKANTU_EXCEPTION("The dofs increment array for "
                      << dof_id << " has already been registered");
   }
 
   dof.increment = &array;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFsDerivative(const ID & dof_id, UInt order,
                                         Array<Real> & dofs_derivative) {
   DOFData & dof = this->getDOFData(dof_id);
   std::vector<Array<Real> *> & derivatives = dof.dof_derivatives;
 
   if (derivatives.size() < order) {
     derivatives.resize(order, nullptr);
   } else {
     if (derivatives[order - 1] != nullptr) {
       AKANTU_EXCEPTION("The dof derivatives of order "
                        << order << " already been registered for this dof ("
                        << dof_id << ")");
     }
   }
 
   derivatives[order - 1] = &dofs_derivative;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerBlockedDOFs(const ID & dof_id,
                                      Array<bool> & blocked_dofs) {
   DOFData & dof = this->getDOFData(dof_id);
 
   if (dof.blocked_dofs != nullptr) {
     AKANTU_EXCEPTION("The blocked dofs array for "
                      << dof_id << " has already been registered");
   }
 
   dof.blocked_dofs = &blocked_dofs;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::splitSolutionPerDOFs() {
-  DOFStorage::iterator it = this->dofs.begin();
-  DOFStorage::iterator end = this->dofs.end();
+  auto it = this->dofs.begin();
+  auto end = this->dofs.end();
 
   for (; it != end; ++it) {
     DOFData & dof_data = *it->second;
     dof_data.solution.resize(dof_data.dof->size() *
                              dof_data.dof->getNbComponent());
     this->getSolutionPerDOFs(it->first, dof_data.solution);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix &
 DOFManager::registerSparseMatrix(const ID & matrix_id,
                                  std::unique_ptr<SparseMatrix> & matrix) {
   SparseMatricesMap::const_iterator it = this->matrices.find(matrix_id);
   if (it != this->matrices.end()) {
     AKANTU_EXCEPTION("The matrix " << matrix_id << " already exists in "
                                    << this->id);
   }
 
   SparseMatrix & ret = *matrix;
   this->matrices[matrix_id] = std::move(matrix);
   return ret;
 }
 
 /* -------------------------------------------------------------------------- */
 /// Get an instance of a new SparseMatrix
 Array<Real> & DOFManager::getNewLumpedMatrix(const ID & id) {
   ID matrix_id = this->id + ":lumped_mtx:" + id;
   LumpedMatricesMap::const_iterator it = this->lumped_matrices.find(matrix_id);
   if (it != this->lumped_matrices.end()) {
     AKANTU_EXCEPTION("The lumped matrix " << matrix_id << " already exists in "
                                           << this->id);
   }
 
   auto mtx =
       std::make_unique<Array<Real>>(this->local_system_size, 1, matrix_id);
   this->lumped_matrices[matrix_id] = std::move(mtx);
   return *this->lumped_matrices[matrix_id];
 }
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolver & DOFManager::registerNonLinearSolver(
     const ID & non_linear_solver_id,
     std::unique_ptr<NonLinearSolver> & non_linear_solver) {
   NonLinearSolversMap::const_iterator it =
       this->non_linear_solvers.find(non_linear_solver_id);
   if (it != this->non_linear_solvers.end()) {
     AKANTU_EXCEPTION("The non linear solver " << non_linear_solver_id
                                               << " already exists in "
                                               << this->id);
   }
 
   NonLinearSolver & ret = *non_linear_solver;
   this->non_linear_solvers[non_linear_solver_id] = std::move(non_linear_solver);
 
   return ret;
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolver & DOFManager::registerTimeStepSolver(
     const ID & time_step_solver_id,
     std::unique_ptr<TimeStepSolver> & time_step_solver) {
   TimeStepSolversMap::const_iterator it =
       this->time_step_solvers.find(time_step_solver_id);
   if (it != this->time_step_solvers.end()) {
     AKANTU_EXCEPTION("The non linear solver " << time_step_solver_id
                                               << " already exists in "
                                               << this->id);
   }
 
   TimeStepSolver & ret = *time_step_solver;
   this->time_step_solvers[time_step_solver_id] = std::move(time_step_solver);
   return ret;
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix & DOFManager::getMatrix(const ID & id) {
   ID matrix_id = this->id + ":mtx:" + id;
   SparseMatricesMap::const_iterator it = this->matrices.find(matrix_id);
   if (it == this->matrices.end()) {
     AKANTU_SILENT_EXCEPTION("The matrix " << matrix_id << " does not exists in "
                                           << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFManager::hasMatrix(const ID & id) const {
   ID mtx_id = this->id + ":mtx:" + id;
-  SparseMatricesMap::const_iterator it = this->matrices.find(mtx_id);
+  auto it = this->matrices.find(mtx_id);
   return it != this->matrices.end();
 }
 
 /* -------------------------------------------------------------------------- */
 Array<Real> & DOFManager::getLumpedMatrix(const ID & id) {
   ID matrix_id = this->id + ":lumped_mtx:" + id;
   LumpedMatricesMap::const_iterator it = this->lumped_matrices.find(matrix_id);
   if (it == this->lumped_matrices.end()) {
     AKANTU_SILENT_EXCEPTION("The lumped matrix "
                             << matrix_id << " does not exists in " << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 const Array<Real> & DOFManager::getLumpedMatrix(const ID & id) const {
   ID matrix_id = this->id + ":lumped_mtx:" + id;
-  LumpedMatricesMap::const_iterator it = this->lumped_matrices.find(matrix_id);
+  auto it = this->lumped_matrices.find(matrix_id);
   if (it == this->lumped_matrices.end()) {
     AKANTU_SILENT_EXCEPTION("The lumped matrix "
                             << matrix_id << " does not exists in " << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFManager::hasLumpedMatrix(const ID & id) const {
   ID mtx_id = this->id + ":lumped_mtx:" + id;
-  LumpedMatricesMap::const_iterator it = this->lumped_matrices.find(mtx_id);
+  auto it = this->lumped_matrices.find(mtx_id);
   return it != this->lumped_matrices.end();
 }
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolver & DOFManager::getNonLinearSolver(const ID & id) {
   ID non_linear_solver_id = this->id + ":nls:" + id;
   NonLinearSolversMap::const_iterator it =
       this->non_linear_solvers.find(non_linear_solver_id);
   if (it == this->non_linear_solvers.end()) {
     AKANTU_EXCEPTION("The non linear solver " << non_linear_solver_id
                                               << " does not exists in "
                                               << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFManager::hasNonLinearSolver(const ID & id) const {
   ID solver_id = this->id + ":nls:" + id;
-  NonLinearSolversMap::const_iterator it =
-      this->non_linear_solvers.find(solver_id);
+  auto it = this->non_linear_solvers.find(solver_id);
   return it != this->non_linear_solvers.end();
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolver & DOFManager::getTimeStepSolver(const ID & id) {
   ID time_step_solver_id = this->id + ":tss:" + id;
   TimeStepSolversMap::const_iterator it =
       this->time_step_solvers.find(time_step_solver_id);
   if (it == this->time_step_solvers.end()) {
     AKANTU_EXCEPTION("The non linear solver " << time_step_solver_id
                                               << " does not exists in "
                                               << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFManager::hasTimeStepSolver(const ID & solver_id) const {
   ID time_step_solver_id = this->id + ":tss:" + solver_id;
-  TimeStepSolversMap::const_iterator it =
-      this->time_step_solvers.find(time_step_solver_id);
+  auto it = this->time_step_solvers.find(time_step_solver_id);
   return it != this->time_step_solvers.end();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::savePreviousDOFs(const ID & dofs_id) {
   this->getPreviousDOFs(dofs_id).copy(this->getDOFs(dofs_id));
 }
 
 /* -------------------------------------------------------------------------- */
 /* Mesh Events                                                                */
 /* -------------------------------------------------------------------------- */
 std::pair<UInt, UInt>
 DOFManager::updateNodalDOFs(const ID & dof_id, const Array<UInt> & nodes_list) {
   auto & dof_data = this->getDOFData(dof_id);
   UInt nb_new_local_dofs = 0;
   UInt nb_new_pure_local = 0;
 
   nb_new_local_dofs = nodes_list.size();
   for (const auto & node : nodes_list) {
     nb_new_pure_local += this->mesh->isLocalOrMasterNode(node) ? 1 : 0;
   }
 
   const auto & dof_array = *dof_data.dof;
   nb_new_pure_local *= dof_array.getNbComponent();
   nb_new_local_dofs *= dof_array.getNbComponent();
 
   this->pure_local_system_size += nb_new_pure_local;
   this->local_system_size += nb_new_local_dofs;
 
   UInt nb_new_global = nb_new_pure_local;
   communicator.allReduce(nb_new_global, SynchronizerOperation::_sum);
 
   this->system_size += nb_new_global;
 
   return std::make_pair(nb_new_local_dofs, nb_new_pure_local);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::onNodesAdded(const Array<UInt> & nodes_list,
                               const NewNodesEvent &) {
   for (auto & pair : this->dofs) {
     const auto & dof_id = pair.first;
     auto & dof_data = this->getDOFData(dof_id);
     if (dof_data.support_type != _dst_nodal)
       continue;
 
     const auto & group = dof_data.group_support;
 
     if (group == "__mesh__") {
       this->updateNodalDOFs(dof_id, nodes_list);
     } else {
       const auto & node_group =
           this->mesh->getElementGroup(group).getNodeGroup();
       Array<UInt> new_nodes_list;
       for (const auto & node : nodes_list) {
         if (node_group.find(node) != UInt(-1))
           new_nodes_list.push_back(node);
       }
 
       this->updateNodalDOFs(dof_id, new_nodes_list);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::onNodesRemoved(const Array<UInt> &, const Array<UInt> &,
                                 const RemovedNodesEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::onElementsAdded(const Array<Element> &,
                                  const NewElementsEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::onElementsRemoved(const Array<Element> &,
                                    const ElementTypeMapArray<UInt> &,
                                    const RemovedElementsEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::onElementsChanged(const Array<Element> &,
                                    const Array<Element> &,
                                    const ElementTypeMapArray<UInt> &,
                                    const ChangedElementsEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/model/dof_manager.hh b/src/model/dof_manager.hh
index fd22976d7..29808a269 100644
--- a/src/model/dof_manager.hh
+++ b/src/model/dof_manager.hh
@@ -1,463 +1,463 @@
 /**
  * @file   dof_manager.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Jul 22 11:43:43 2015
  *
  * @brief  Class handling the different types of dofs
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_memory.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 #include <map>
 #include <set>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_DOF_MANAGER_HH__
 #define __AKANTU_DOF_MANAGER_HH__
 
 namespace akantu {
 class TermsToAssemble;
 class NonLinearSolver;
 class TimeStepSolver;
 class SparseMatrix;
 } // namespace akantu
 
 namespace akantu {
 
 class DOFManager : protected Memory, protected MeshEventHandler {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   DOFManager(const ID & id = "dof_manager", const MemoryID & memory_id = 0);
   DOFManager(Mesh & mesh, const ID & id = "dof_manager",
              const MemoryID & memory_id = 0);
   ~DOFManager() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 private:
   /// common function to help registering dofs
   void registerDOFsInternal(const ID & dof_id, Array<Real> & dofs_array);
 
 public:
   /// register an array of degree of freedom
   virtual void registerDOFs(const ID & dof_id, Array<Real> & dofs_array,
                             const DOFSupportType & support_type);
 
   /// the dof as an implied type of _dst_nodal and is defined only on a subset
   /// of nodes
   virtual void registerDOFs(const ID & dof_id, Array<Real> & dofs_array,
                             const ID & group_support);
 
   /// register an array of previous values of the degree of freedom
   virtual void registerDOFsPrevious(const ID & dof_id,
                                     Array<Real> & dofs_array);
 
   /// register an array of increment of degree of freedom
   virtual void registerDOFsIncrement(const ID & dof_id,
                                      Array<Real> & dofs_array);
 
   /// register an array of derivatives for a particular dof array
   virtual void registerDOFsDerivative(const ID & dof_id, UInt order,
                                       Array<Real> & dofs_derivative);
 
   /// register array representing the blocked degree of freedoms
   virtual void registerBlockedDOFs(const ID & dof_id,
                                    Array<bool> & blocked_dofs);
 
   /// Assemble an array to the global residual array
   virtual void assembleToResidual(const ID & dof_id,
                                   const Array<Real> & array_to_assemble,
                                   Real scale_factor = 1.) = 0;
 
   /// Assemble an array to the global lumped matrix array
   virtual void assembleToLumpedMatrix(const ID & dof_id,
                                       const Array<Real> & array_to_assemble,
                                       const ID & lumped_mtx,
                                       Real scale_factor = 1.) = 0;
 
   /**
    * Assemble elementary values to a local array of the size nb_nodes *
    * nb_dof_per_node. The dof number is implicitly considered as
    * conn(el, n) * nb_nodes_per_element + d.
    * With 0 < n < nb_nodes_per_element and 0 < d < nb_dof_per_node
    **/
   virtual void assembleElementalArrayLocalArray(
       const Array<Real> & elementary_vect, Array<Real> & array_assembeled,
       const ElementType & type, const GhostType & ghost_type,
       Real scale_factor = 1.,
       const Array<UInt> & filter_elements = empty_filter);
 
   /**
    * Assemble elementary values to the global residual array. The dof number is
    * implicitly considered as conn(el, n) * nb_nodes_per_element + d.
    * With 0 < n < nb_nodes_per_element and 0 < d < nb_dof_per_node
    **/
   virtual void assembleElementalArrayToResidual(
       const ID & dof_id, const Array<Real> & elementary_vect,
       const ElementType & type, const GhostType & ghost_type,
       Real scale_factor = 1.,
       const Array<UInt> & filter_elements = empty_filter);
 
   /**
    * Assemble elementary values to a global array corresponding to a lumped
    * matrix
    */
   virtual void assembleElementalArrayToLumpedMatrix(
       const ID & dof_id, const Array<Real> & elementary_vect,
       const ID & lumped_mtx, const ElementType & type,
       const GhostType & ghost_type, Real scale_factor = 1.,
       const Array<UInt> & filter_elements = empty_filter);
 
   /**
    * Assemble elementary values to the global residual array. The dof number is
    * implicitly considered as conn(el, n) * nb_nodes_per_element + d.  With 0 <
    * n < nb_nodes_per_element and 0 < d < nb_dof_per_node
    **/
   virtual void assembleElementalMatricesToMatrix(
       const ID & matrix_id, const ID & dof_id,
       const Array<Real> & elementary_mat, const ElementType & type,
       const GhostType & ghost_type = _not_ghost,
       const MatrixType & elemental_matrix_type = _symmetric,
       const Array<UInt> & filter_elements = empty_filter) = 0;
 
   /// multiply a vector by a matrix and assemble the result to the residual
   virtual void assembleMatMulVectToResidual(const ID & dof_id, const ID & A_id,
                                             const Array<Real> & x,
                                             Real scale_factor = 1) = 0;
 
   /// multiply a vector by a lumped matrix and assemble the result to the
   /// residual
   virtual void assembleLumpedMatMulVectToResidual(const ID & dof_id,
                                                   const ID & A_id,
                                                   const Array<Real> & x,
                                                   Real scale_factor = 1) = 0;
 
   /// assemble coupling terms between to dofs
   virtual void assemblePreassembledMatrix(const ID & dof_id_m,
                                           const ID & dof_id_n,
                                           const ID & matrix_id,
                                           const TermsToAssemble & terms) = 0;
 
   /// sets the residual to 0
   virtual void clearResidual() = 0;
   /// sets the matrix to 0
   virtual void clearMatrix(const ID & mtx) = 0;
   /// sets the lumped matrix to 0
   virtual void clearLumpedMatrix(const ID & mtx) = 0;
 
   /// splits the solution storage from a global view to the per dof storages
   void splitSolutionPerDOFs();
 
   /// extract a lumped matrix part corresponding to a given dof
   virtual void getLumpedMatrixPerDOFs(const ID & dof_id, const ID & lumped_mtx,
                                       Array<Real> & lumped) = 0;
 
 protected:
   /// minimum functionality to implement per derived version of the DOFManager
   /// to allow the splitSolutionPerDOFs function to work
   virtual void getSolutionPerDOFs(const ID & dof_id,
                                   Array<Real> & solution_array) = 0;
 
 protected:
   /* ------------------------------------------------------------------------ */
   /// register a matrix
   SparseMatrix & registerSparseMatrix(const ID & matrix_id,
                                       std::unique_ptr<SparseMatrix> & matrix);
 
   /// register a non linear solver instantiated by a derived class
   NonLinearSolver &
   registerNonLinearSolver(const ID & non_linear_solver_id,
                           std::unique_ptr<NonLinearSolver> & non_linear_solver);
 
   /// register a time step solver instantiated by a derived class
   TimeStepSolver &
   registerTimeStepSolver(const ID & time_step_solver_id,
                          std::unique_ptr<TimeStepSolver> & time_step_solver);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// Get the equation numbers corresponding to a dof_id. This might be used to
   /// access the matrix.
   inline const Array<UInt> & getEquationsNumbers(const ID & dof_id) const;
 
   /// Global number of dofs
   AKANTU_GET_MACRO(SystemSize, this->system_size, UInt);
 
   /// Local number of dofs
   AKANTU_GET_MACRO(LocalSystemSize, this->local_system_size, UInt);
 
   /// Retrieve all the registered DOFs
   std::vector<ID> getDOFIDs() const;
 
   /* ------------------------------------------------------------------------ */
   /* DOFs and derivatives accessors                                          */
   /* ------------------------------------------------------------------------ */
   /// Get a reference to the registered dof array for a given id
   inline Array<Real> & getDOFs(const ID & dofs_id);
 
   /// Get the support type of a given dof
   inline DOFSupportType getSupportType(const ID & dofs_id) const;
 
   /// are the dofs registered
   inline bool hasDOFs(const ID & dofs_id) const;
 
   /// Get a reference to the registered dof derivatives array for a given id
   inline Array<Real> & getDOFsDerivatives(const ID & dofs_id, UInt order);
 
   /// Does the dof has derivatives
   inline bool hasDOFsDerivatives(const ID & dofs_id, UInt order) const;
 
   /// Get a reference to the blocked dofs array registered for the given id
   inline const Array<bool> & getBlockedDOFs(const ID & dofs_id) const;
 
   /// Does the dof has a blocked array
   inline bool hasBlockedDOFs(const ID & dofs_id) const;
 
   /// Get a reference to the registered dof increment array for a given id
   inline Array<Real> & getDOFsIncrement(const ID & dofs_id);
 
   /// Does the dof has a increment array
   inline bool hasDOFsIncrement(const ID & dofs_id) const;
 
   /// Does the dof has a previous array
   inline Array<Real> & getPreviousDOFs(const ID & dofs_id);
 
   /// Get a reference to the registered dof array for previous step values a
   /// given id
   inline bool hasPreviousDOFs(const ID & dofs_id) const;
 
   /// saves the values from dofs to previous dofs
   virtual void savePreviousDOFs(const ID & dofs_id);
 
   /// Get a reference to the solution array registered for the given id
   inline const Array<Real> & getSolution(const ID & dofs_id) const;
 
   /* ------------------------------------------------------------------------ */
   /* Matrices accessors                                                       */
   /* ------------------------------------------------------------------------ */
   /// Get an instance of a new SparseMatrix
   virtual SparseMatrix & getNewMatrix(const ID & matrix_id,
                                       const MatrixType & matrix_type) = 0;
 
   /// Get an instance of a new SparseMatrix as a copy of the SparseMatrix
   /// matrix_to_copy_id
   virtual SparseMatrix & getNewMatrix(const ID & matrix_id,
                                       const ID & matrix_to_copy_id) = 0;
 
   /// Get the reference of an existing matrix
   SparseMatrix & getMatrix(const ID & matrix_id);
 
   /// check if the given matrix exists
   bool hasMatrix(const ID & matrix_id) const;
 
   /// Get an instance of a new lumped matrix
   virtual Array<Real> & getNewLumpedMatrix(const ID & matrix_id);
   /// Get the lumped version of a given matrix
   const Array<Real> & getLumpedMatrix(const ID & matrix_id) const;
   /// Get the lumped version of a given matrix
   Array<Real> & getLumpedMatrix(const ID & matrix_id);
 
   /// check if the given matrix exists
   bool hasLumpedMatrix(const ID & matrix_id) const;
 
   /* ------------------------------------------------------------------------ */
   /* Non linear system solver                                                 */
   /* ------------------------------------------------------------------------ */
   /// Get instance of a non linear solver
   virtual NonLinearSolver & getNewNonLinearSolver(
       const ID & nls_solver_id,
       const NonLinearSolverType & _non_linear_solver_type) = 0;
 
   /// get instance of a non linear solver
   virtual NonLinearSolver & getNonLinearSolver(const ID & nls_solver_id);
 
   /// check if the given solver exists
   bool hasNonLinearSolver(const ID & solver_id) const;
 
   /* ------------------------------------------------------------------------ */
   /* Time-Step Solver                                                         */
   /* ------------------------------------------------------------------------ */
   /// Get instance of a time step solver
   virtual TimeStepSolver &
   getNewTimeStepSolver(const ID & time_step_solver_id,
                        const TimeStepSolverType & type,
                        NonLinearSolver & non_linear_solver) = 0;
 
   /// get instance of a time step solver
   virtual TimeStepSolver & getTimeStepSolver(const ID & time_step_solver_id);
 
   /// check if the given solver exists
   bool hasTimeStepSolver(const ID & solver_id) const;
 
   /* ------------------------------------------------------------------------ */
   const Mesh & getMesh() {
     if (mesh) {
       return *mesh;
     } else {
       AKANTU_EXCEPTION("No mesh registered in this dof manager");
     }
   }
 
   /* ------------------------------------------------------------------------ */
   AKANTU_GET_MACRO(Communicator, communicator, const auto &);
 
   /* ------------------------------------------------------------------------ */
   /* MeshEventHandler interface                                               */
   /* ------------------------------------------------------------------------ */
 protected:
   /// helper function for the DOFManager::onNodesAdded method
   virtual std::pair<UInt, UInt> updateNodalDOFs(const ID & dof_id,
                                                 const Array<UInt> & nodes_list);
 public:
   /// function to implement to react on  akantu::NewNodesEvent
   void onNodesAdded(const Array<UInt> & nodes_list,
                     const NewNodesEvent & event) override;
   /// function to implement to react on  akantu::RemovedNodesEvent
   void onNodesRemoved(const Array<UInt> & nodes_list,
                       const Array<UInt> & new_numbering,
                       const RemovedNodesEvent & event) override;
   /// function to implement to react on  akantu::NewElementsEvent
   void onElementsAdded(const Array<Element> & elements_list,
                        const NewElementsEvent & event) override;
   /// function to implement to react on  akantu::RemovedElementsEvent
   void onElementsRemoved(const Array<Element> & elements_list,
                          const ElementTypeMapArray<UInt> & new_numbering,
                          const RemovedElementsEvent & event) override;
   /// function to implement to react on  akantu::ChangedElementsEvent
   void onElementsChanged(const Array<Element> & old_elements_list,
                          const Array<Element> & new_elements_list,
                          const ElementTypeMapArray<UInt> & new_numbering,
                          const ChangedElementsEvent & event) override;
 
 protected:
   struct DOFData;
   inline DOFData & getDOFData(const ID & dof_id);
   inline const DOFData & getDOFData(const ID & dof_id) const;
   template <class _DOFData>
   inline _DOFData & getDOFDataTyped(const ID & dof_id);
   template <class _DOFData>
   inline const _DOFData & getDOFDataTyped(const ID & dof_id) const;
 
   virtual DOFData & getNewDOFData(const ID & dof_id);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// dof representations in the dof manager
   struct DOFData {
     DOFData() = delete;
     explicit DOFData(const ID & dof_id);
     virtual ~DOFData();
 
     /// DOF support type (nodal, general) this is needed to determine how the
     /// dof are shared among processors
     DOFSupportType support_type;
 
     ID group_support;
 
     /// Degree of freedom array
     Array<Real> * dof;
 
     /// Blocked degree of freedoms array
     Array<bool> * blocked_dofs;
 
     /// Degree of freedoms increment
     Array<Real> * increment;
 
     /// Degree of freedoms at previous step
     Array<Real> * previous;
 
     /// Solution associated to the dof
     Array<Real> solution;
 
     /// local numbering equation numbers
     Array<UInt> local_equation_number;
 
     /* ---------------------------------------------------------------------- */
     /* data for dynamic simulations                                           */
     /* ---------------------------------------------------------------------- */
     /// Degree of freedom derivatives arrays
     std::vector<Array<Real> *> dof_derivatives;
   };
 
   /// type to store dofs information
   using DOFStorage = std::map<ID, std::unique_ptr<DOFData>>;
 
   /// type to store all the matrices
   using SparseMatricesMap = std::map<ID, std::unique_ptr<SparseMatrix>>;
 
   /// type to store all the lumped matrices
   using LumpedMatricesMap = std::map<ID, std::unique_ptr<Array<Real>>>;
 
   /// type to store all the non linear solver
   using NonLinearSolversMap = std::map<ID, std::unique_ptr<NonLinearSolver>>;
 
   /// type to store all the time step solver
   using TimeStepSolversMap = std::map<ID, std::unique_ptr<TimeStepSolver>>;
 
   /// store a reference to the dof arrays
   DOFStorage dofs;
 
   /// list of sparse matrices that where created
   SparseMatricesMap matrices;
 
   /// list of lumped matrices
   LumpedMatricesMap lumped_matrices;
 
   /// non linear solvers storage
   NonLinearSolversMap non_linear_solvers;
 
   /// time step solvers storage
   TimeStepSolversMap time_step_solvers;
 
   /// reference to the underlying mesh
-  Mesh * mesh;
+  Mesh * mesh{nullptr};
 
   /// Total number of degrees of freedom (size with the ghosts)
-  UInt local_system_size;
+  UInt local_system_size{0};
 
   /// Number of purely local dofs (size without the ghosts)
-  UInt pure_local_system_size;
+  UInt pure_local_system_size{0};
 
   /// Total number of degrees of freedom
-  UInt system_size;
+  UInt system_size{0};
 
   /// Communicator used for this manager, should be the same as in the mesh if a
   /// mesh is registered
   const Communicator & communicator;
 };
 
 } // namespace akantu
 
 #include "dof_manager_inline_impl.cc"
 
 #endif /* __AKANTU_DOF_MANAGER_HH__ */
diff --git a/src/model/dof_manager_default.cc b/src/model/dof_manager_default.cc
index 8c7d95689..48ba2e685 100644
--- a/src/model/dof_manager_default.cc
+++ b/src/model/dof_manager_default.cc
@@ -1,912 +1,911 @@
 /**
  * @file   dof_manager_default.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Tue Aug 11 16:21:01 2015
  *
  * @brief  Implementation of the default DOFManager
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dof_manager_default.hh"
 #include "dof_synchronizer.hh"
 #include "element_group.hh"
 #include "node_synchronizer.hh"
 #include "non_linear_solver_default.hh"
 #include "sparse_matrix_aij.hh"
 #include "communicator.hh"
 #include "terms_to_assemble.hh"
 #include "time_step_solver_default.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <memory>
 #include <numeric>
 #include <unordered_map>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline void DOFManagerDefault::addSymmetricElementalMatrixToSymmetric(
     SparseMatrixAIJ & matrix, const Matrix<Real> & elementary_mat,
     const Vector<UInt> & equation_numbers, UInt max_size) {
   for (UInt i = 0; i < elementary_mat.rows(); ++i) {
     UInt c_irn = equation_numbers(i);
     if (c_irn < max_size) {
       for (UInt j = i; j < elementary_mat.cols(); ++j) {
         UInt c_jcn = equation_numbers(j);
         if (c_jcn < max_size) {
           matrix(c_irn, c_jcn) += elementary_mat(i, j);
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void DOFManagerDefault::addUnsymmetricElementalMatrixToSymmetric(
     SparseMatrixAIJ & matrix, const Matrix<Real> & elementary_mat,
     const Vector<UInt> & equation_numbers, UInt max_size) {
   for (UInt i = 0; i < elementary_mat.rows(); ++i) {
     UInt c_irn = equation_numbers(i);
     if (c_irn < max_size) {
       for (UInt j = 0; j < elementary_mat.cols(); ++j) {
         UInt c_jcn = equation_numbers(j);
         if (c_jcn < max_size) {
           if (c_jcn >= c_irn) {
             matrix(c_irn, c_jcn) += elementary_mat(i, j);
           }
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void DOFManagerDefault::addElementalMatrixToUnsymmetric(
     SparseMatrixAIJ & matrix, const Matrix<Real> & elementary_mat,
     const Vector<UInt> & equation_numbers, UInt max_size) {
   for (UInt i = 0; i < elementary_mat.rows(); ++i) {
     UInt c_irn = equation_numbers(i);
     if (c_irn < max_size) {
       for (UInt j = 0; j < elementary_mat.cols(); ++j) {
         UInt c_jcn = equation_numbers(j);
         if (c_jcn < max_size) {
           matrix(c_irn, c_jcn) += elementary_mat(i, j);
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManagerDefault::DOFManagerDefault(const ID & id, const MemoryID & memory_id)
     : DOFManager(id, memory_id), residual(0, 1, std::string(id + ":residual")),
       global_residual(nullptr),
       global_solution(0, 1, std::string(id + ":global_solution")),
       global_blocked_dofs(0, 1, std::string(id + ":global_blocked_dofs")),
       previous_global_blocked_dofs(
           0, 1, std::string(id + ":previous_global_blocked_dofs")),
       dofs_type(0, 1, std::string(id + ":dofs_type")),
       data_cache(0, 1, std::string(id + ":data_cache_array")),
-      jacobian_release(0),
+
       global_equation_number(0, 1, "global_equation_number"),
-      first_global_dof_id(0), synchronizer(nullptr) {}
+      synchronizer(nullptr) {}
 
 /* -------------------------------------------------------------------------- */
 DOFManagerDefault::DOFManagerDefault(Mesh & mesh, const ID & id,
                                      const MemoryID & memory_id)
     : DOFManager(mesh, id, memory_id),
       residual(0, 1, std::string(id + ":residual")), global_residual(nullptr),
       global_solution(0, 1, std::string(id + ":global_solution")),
       global_blocked_dofs(0, 1, std::string(id + ":global_blocked_dofs")),
       previous_global_blocked_dofs(
           0, 1, std::string(id + ":previous_global_blocked_dofs")),
       dofs_type(0, 1, std::string(id + ":dofs_type")),
       data_cache(0, 1, std::string(id + ":data_cache_array")),
       jacobian_release(0),
       global_equation_number(0, 1, "global_equation_number"),
       first_global_dof_id(0), synchronizer(nullptr) {
   if (this->mesh->isDistributed())
     this->synchronizer = std::make_unique<DOFSynchronizer>(
         *this, this->id + ":dof_synchronizer", this->memory_id, communicator);
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManagerDefault::~DOFManagerDefault() = default;
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void DOFManagerDefault::assembleToGlobalArray(
     const ID & dof_id, const Array<T> & array_to_assemble,
     Array<T> & global_array, T scale_factor) {
   AKANTU_DEBUG_IN();
   const Array<UInt> & equation_number = this->getLocalEquationNumbers(dof_id);
 
   UInt nb_degree_of_freedoms =
       array_to_assemble.size() * array_to_assemble.getNbComponent();
 
   AKANTU_DEBUG_ASSERT(equation_number.size() == nb_degree_of_freedoms,
                       "The array to assemble does not have a correct size."
                           << " (" << array_to_assemble.getID() << ")");
 
   typename Array<T>::const_scalar_iterator arr_it =
       array_to_assemble.begin_reinterpret(nb_degree_of_freedoms);
   Array<UInt>::const_scalar_iterator equ_it = equation_number.begin();
 
   for (UInt d = 0; d < nb_degree_of_freedoms; ++d, ++arr_it, ++equ_it) {
     global_array(*equ_it) += scale_factor * (*arr_it);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManagerDefault::DOFDataDefault::DOFDataDefault(const ID & dof_id)
     : DOFData(dof_id), associated_nodes(0, 1, dof_id + "associated_nodes") {}
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFData & DOFManagerDefault::getNewDOFData(const ID & dof_id) {
   this->dofs[dof_id] = std::make_unique<DOFDataDefault>(dof_id);
   return *this->dofs[dof_id];
 }
 
 /* -------------------------------------------------------------------------- */
 class GlobalDOFInfoDataAccessor : public DataAccessor<UInt> {
 public:
   typedef
       typename std::unordered_map<UInt, std::vector<UInt>>::size_type size_type;
 
   GlobalDOFInfoDataAccessor() = default;
 
   void addDOFToNode(UInt node, UInt dof) { dofs_per_node[node].push_back(dof); }
   UInt getNthDOFForNode(UInt nth_dof, UInt node) const {
     return dofs_per_node.find(node)->second[nth_dof];
   }
 
   UInt getNbData(const Array<UInt> & nodes,
                  const SynchronizationTag & tag) const override {
     if (tag == _gst_size) {
       return nodes.size() * sizeof(size_type);
     }
 
     if (tag == _gst_update) {
       UInt total_size = 0;
       for (auto node : nodes) {
         auto it = dofs_per_node.find(node);
         if (it != dofs_per_node.end())
           total_size += CommunicationBuffer::sizeInBuffer(it->second);
       }
       return total_size;
     }
 
     return 0;
   }
 
   void packData(CommunicationBuffer & buffer, const Array<UInt> & nodes,
                 const SynchronizationTag & tag) const override {
     for (auto node : nodes) {
       auto it = dofs_per_node.find(node);
       if (tag == _gst_size) {
         if (it != dofs_per_node.end()) {
           buffer << it->second.size();
         } else {
           buffer << 0;
         }
       } else if (tag == _gst_update) {
         if (it != dofs_per_node.end())
           buffer << it->second;
       }
     }
   }
 
   void unpackData(CommunicationBuffer & buffer, const Array<UInt> & nodes,
                   const SynchronizationTag & tag) override {
     for (auto node : nodes) {
       auto it = dofs_per_node.find(node);
       if (tag == _gst_size) {
         size_type size;
         buffer >> size;
         if (size != 0)
           dofs_per_node[node].resize(size);
       } else if (tag == _gst_update) {
         if (it != dofs_per_node.end())
           buffer >> it->second;
       }
     }
   }
 
 protected:
   std::unordered_map<UInt, std::vector<UInt>> dofs_per_node;
 };
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::registerDOFsInternal(const ID & dof_id, UInt nb_dofs,
                                              UInt nb_pure_local_dofs) {
   // auto prank = this->communicator.whoAmI();
   // auto psize = this->communicator.getNbProc();
 
   // access the relevant data to update
   auto & dof_data = this->getDOFDataTyped<DOFDataDefault>(dof_id);
   const auto & support_type = dof_data.support_type;
 
   const auto & group = dof_data.group_support;
 
   if (support_type == _dst_nodal and group != "__mesh__") {
     auto & support_nodes =
         this->mesh->getElementGroup(group).getNodeGroup().getNodes();
     this->updateDOFsData(
         dof_data, nb_dofs, nb_pure_local_dofs,
         [&support_nodes](UInt node) -> UInt { return support_nodes[node]; });
   } else {
 
     this->updateDOFsData(dof_data, nb_dofs, nb_pure_local_dofs,
                          [](UInt node) -> UInt { return node; });
   }
 
   // update the synchronizer if needed
   if (this->synchronizer)
     this->synchronizer->registerDOFs(dof_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::registerDOFs(const ID & dof_id,
                                      Array<Real> & dofs_array,
                                      const DOFSupportType & support_type) {
   // stores the current numbers of dofs
   UInt nb_dofs_old = this->local_system_size;
   UInt nb_pure_local_dofs_old = this->pure_local_system_size;
 
   // update or create the dof_data
   DOFManager::registerDOFs(dof_id, dofs_array, support_type);
 
   UInt nb_dofs = this->local_system_size - nb_dofs_old;
   UInt nb_pure_local_dofs =
       this->pure_local_system_size - nb_pure_local_dofs_old;
 
   this->registerDOFsInternal(dof_id, nb_dofs, nb_pure_local_dofs);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::registerDOFs(const ID & dof_id,
                                      Array<Real> & dofs_array,
                                      const ID & group_support) {
   // stores the current numbers of dofs
   UInt nb_dofs_old = this->local_system_size;
   UInt nb_pure_local_dofs_old = this->pure_local_system_size;
 
   // update or create the dof_data
   DOFManager::registerDOFs(dof_id, dofs_array, group_support);
 
   UInt nb_dofs = this->local_system_size - nb_dofs_old;
   UInt nb_pure_local_dofs =
       this->pure_local_system_size - nb_pure_local_dofs_old;
 
   this->registerDOFsInternal(dof_id, nb_dofs, nb_pure_local_dofs);
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix & DOFManagerDefault::getNewMatrix(const ID & id,
                                                const MatrixType & matrix_type) {
   ID matrix_id = this->id + ":mtx:" + id;
   std::unique_ptr<SparseMatrix> sm =
       std::make_unique<SparseMatrixAIJ>(*this, matrix_type, matrix_id);
   return this->registerSparseMatrix(matrix_id, sm);
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix & DOFManagerDefault::getNewMatrix(const ID & id,
                                                const ID & matrix_to_copy_id) {
 
   ID matrix_id = this->id + ":mtx:" + id;
   SparseMatrixAIJ & sm_to_copy = this->getMatrix(matrix_to_copy_id);
   std::unique_ptr<SparseMatrix> sm =
       std::make_unique<SparseMatrixAIJ>(sm_to_copy, matrix_id);
   return this->registerSparseMatrix(matrix_id, sm);
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrixAIJ & DOFManagerDefault::getMatrix(const ID & id) {
   SparseMatrix & matrix = DOFManager::getMatrix(id);
 
   return dynamic_cast<SparseMatrixAIJ &>(matrix);
 }
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolver &
 DOFManagerDefault::getNewNonLinearSolver(const ID & id,
                                          const NonLinearSolverType & type) {
   ID non_linear_solver_id = this->id + ":nls:" + id;
   std::unique_ptr<NonLinearSolver> nls;
   switch (type) {
 #if defined(AKANTU_IMPLICIT)
   case _nls_newton_raphson:
   case _nls_newton_raphson_modified: {
     nls = std::make_unique<NonLinearSolverNewtonRaphson>(
         *this, type, non_linear_solver_id, this->memory_id);
     break;
   }
   case _nls_linear: {
     nls = std::make_unique<NonLinearSolverLinear>(
         *this, type, non_linear_solver_id, this->memory_id);
     break;
   }
 #endif
   case _nls_lumped: {
     nls = std::make_unique<NonLinearSolverLumped>(
         *this, type, non_linear_solver_id, this->memory_id);
     break;
   }
   default:
     AKANTU_EXCEPTION("The asked type of non linear solver is not supported by "
                      "this dof manager");
   }
 
   return this->registerNonLinearSolver(non_linear_solver_id, nls);
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolver &
 DOFManagerDefault::getNewTimeStepSolver(const ID & id,
                                         const TimeStepSolverType & type,
                                         NonLinearSolver & non_linear_solver) {
   ID time_step_solver_id = this->id + ":tss:" + id;
 
   std::unique_ptr<TimeStepSolver> tss = std::make_unique<TimeStepSolverDefault>(
       *this, type, non_linear_solver, time_step_solver_id, this->memory_id);
 
   return this->registerTimeStepSolver(time_step_solver_id, tss);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::clearResidual() {
   this->residual.resize(this->local_system_size);
   this->residual.clear();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::clearMatrix(const ID & mtx) {
   this->getMatrix(mtx).clear();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::clearLumpedMatrix(const ID & mtx) {
   this->getLumpedMatrix(mtx).clear();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::updateGlobalBlockedDofs() {
-  DOFStorage::iterator it = this->dofs.begin();
-  DOFStorage::iterator end = this->dofs.end();
+  auto it = this->dofs.begin();
+  auto end = this->dofs.end();
 
   this->previous_global_blocked_dofs.copy(this->global_blocked_dofs);
   this->global_blocked_dofs.resize(this->local_system_size);
   this->global_blocked_dofs.clear();
 
   for (; it != end; ++it) {
     if (!this->hasBlockedDOFs(it->first))
       continue;
 
     DOFData & dof_data = *it->second;
     this->assembleToGlobalArray(it->first, *dof_data.blocked_dofs,
                                 this->global_blocked_dofs, true);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void DOFManagerDefault::getArrayPerDOFs(const ID & dof_id,
                                         const Array<T> & global_array,
                                         Array<T> & local_array) const {
   AKANTU_DEBUG_IN();
 
   const Array<UInt> & equation_number = this->getLocalEquationNumbers(dof_id);
 
   UInt nb_degree_of_freedoms = equation_number.size();
   local_array.resize(nb_degree_of_freedoms / local_array.getNbComponent());
 
   auto loc_it = local_array.begin_reinterpret(nb_degree_of_freedoms);
   auto equ_it = equation_number.begin();
 
   for (UInt d = 0; d < nb_degree_of_freedoms; ++d, ++loc_it, ++equ_it) {
     (*loc_it) = global_array(*equ_it);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 // void DOFManagerDefault::getEquationsNumbers(const ID & dof_id,
 //                                             Array<UInt> & equation_numbers) {
 //   AKANTU_DEBUG_IN();
 //   this->getArrayPerDOFs(dof_id, this->global_equation_number,
 //   equation_numbers); AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::getSolutionPerDOFs(const ID & dof_id,
                                            Array<Real> & solution_array) {
   AKANTU_DEBUG_IN();
   this->getArrayPerDOFs(dof_id, this->global_solution, solution_array);
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::getLumpedMatrixPerDOFs(const ID & dof_id,
                                                const ID & lumped_mtx,
                                                Array<Real> & lumped) {
   AKANTU_DEBUG_IN();
   this->getArrayPerDOFs(dof_id, this->getLumpedMatrix(lumped_mtx), lumped);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleToResidual(
     const ID & dof_id, const Array<Real> & array_to_assemble,
     Real scale_factor) {
   AKANTU_DEBUG_IN();
 
   this->assembleToGlobalArray(dof_id, array_to_assemble, this->residual,
                               scale_factor);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleToLumpedMatrix(
     const ID & dof_id, const Array<Real> & array_to_assemble,
     const ID & lumped_mtx, Real scale_factor) {
   AKANTU_DEBUG_IN();
 
   Array<Real> & lumped = this->getLumpedMatrix(lumped_mtx);
   this->assembleToGlobalArray(dof_id, array_to_assemble, lumped, scale_factor);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleMatMulVectToResidual(const ID & dof_id,
                                                      const ID & A_id,
                                                      const Array<Real> & x,
                                                      Real scale_factor) {
   SparseMatrixAIJ & A = this->getMatrix(A_id);
 
   // Array<Real> data_cache(this->local_system_size, 1, 0.);
   this->data_cache.resize(this->local_system_size);
   this->data_cache.clear();
 
   this->assembleToGlobalArray(dof_id, x, data_cache, 1.);
 
   A.matVecMul(data_cache, this->residual, scale_factor, 1.);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleLumpedMatMulVectToResidual(
     const ID & dof_id, const ID & A_id, const Array<Real> & x,
     Real scale_factor) {
   const Array<Real> & A = this->getLumpedMatrix(A_id);
 
   //  Array<Real> data_cache(this->local_system_size, 1, 0.);
   this->data_cache.resize(this->local_system_size);
   this->data_cache.clear();
 
   this->assembleToGlobalArray(dof_id, x, data_cache, scale_factor);
 
   Array<Real>::const_scalar_iterator A_it = A.begin();
   Array<Real>::const_scalar_iterator A_end = A.end();
   Array<Real>::const_scalar_iterator x_it = data_cache.begin();
   Array<Real>::scalar_iterator r_it = this->residual.begin();
 
   for (; A_it != A_end; ++A_it, ++x_it, ++r_it) {
     *r_it += *A_it * *x_it;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleElementalMatricesToMatrix(
     const ID & matrix_id, const ID & dof_id, const Array<Real> & elementary_mat,
     const ElementType & type, const GhostType & ghost_type,
     const MatrixType & elemental_matrix_type,
     const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   DOFData & dof_data = this->getDOFData(dof_id);
 
   AKANTU_DEBUG_ASSERT(dof_data.support_type == _dst_nodal,
                       "This function applies only on Nodal dofs");
 
   this->addToProfile(matrix_id, dof_id, type, ghost_type);
 
   const Array<UInt> & equation_number = this->getLocalEquationNumbers(dof_id);
   SparseMatrixAIJ & A = this->getMatrix(matrix_id);
 
   UInt nb_element;
   if (ghost_type == _not_ghost) {
     nb_element = this->mesh->getNbElement(type);
   } else {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   UInt * filter_it = nullptr;
   if (filter_elements != empty_filter) {
     nb_element = filter_elements.size();
     filter_it = filter_elements.storage();
   } else {
     if (dof_data.group_support != "__mesh__") {
       const Array<UInt> & group_elements =
           this->mesh->getElementGroup(dof_data.group_support)
               .getElements(type, ghost_type);
       nb_element = group_elements.size();
       filter_it = group_elements.storage();
     } else {
       nb_element = this->mesh->getNbElement(type, ghost_type);
     }
   }
 
   AKANTU_DEBUG_ASSERT(elementary_mat.size() == nb_element,
                       "The vector elementary_mat("
                           << elementary_mat.getID()
                           << ") has not the good size.");
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
   UInt nb_degree_of_freedom = dof_data.dof->getNbComponent();
 
   const Array<UInt> & connectivity =
       this->mesh->getConnectivity(type, ghost_type);
   auto conn_begin = connectivity.begin(nb_nodes_per_element);
   auto conn_it = conn_begin;
 
   UInt size_mat = nb_nodes_per_element * nb_degree_of_freedom;
 
   Vector<UInt> element_eq_nb(nb_degree_of_freedom * nb_nodes_per_element);
   Array<Real>::const_matrix_iterator el_mat_it =
       elementary_mat.begin(size_mat, size_mat);
 
   for (UInt e = 0; e < nb_element; ++e, ++el_mat_it) {
     if (filter_it)
       conn_it = conn_begin + *filter_it;
 
     this->extractElementEquationNumber(equation_number, *conn_it,
                                        nb_degree_of_freedom, element_eq_nb);
     std::transform(element_eq_nb.storage(),
                    element_eq_nb.storage() + element_eq_nb.size(),
                    element_eq_nb.storage(), [&](UInt & local) -> UInt {
                      return this->localToGlobalEquationNumber(local);
                    });
 
     if (filter_it)
       ++filter_it;
     else
       ++conn_it;
 
     if (A.getMatrixType() == _symmetric)
       if (elemental_matrix_type == _symmetric)
         this->addSymmetricElementalMatrixToSymmetric(
             A, *el_mat_it, element_eq_nb, A.size());
       else
         this->addUnsymmetricElementalMatrixToSymmetric(
             A, *el_mat_it, element_eq_nb, A.size());
     else
       this->addElementalMatrixToUnsymmetric(A, *el_mat_it, element_eq_nb,
                                             A.size());
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assemblePreassembledMatrix(
     const ID & dof_id_m, const ID & dof_id_n, const ID & matrix_id,
     const TermsToAssemble & terms) {
   const Array<UInt> & equation_number_m =
       this->getLocalEquationNumbers(dof_id_m);
   const Array<UInt> & equation_number_n =
       this->getLocalEquationNumbers(dof_id_n);
   SparseMatrixAIJ & A = this->getMatrix(matrix_id);
 
   for (const auto & term : terms) {
     UInt gi = this->localToGlobalEquationNumber(equation_number_m(term.i()));
     UInt gj = this->localToGlobalEquationNumber(equation_number_n(term.j()));
     A.add(gi, gj, term);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::addToProfile(const ID & matrix_id, const ID & dof_id,
                                      const ElementType & type,
                                      const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   const DOFData & dof_data = this->getDOFData(dof_id);
 
   if (dof_data.support_type != _dst_nodal)
     return;
 
   auto mat_dof = std::make_pair(matrix_id, dof_id);
   auto type_pair = std::make_pair(type, ghost_type);
 
   auto prof_it = this->matrix_profiled_dofs.find(mat_dof);
   if (prof_it != this->matrix_profiled_dofs.end() &&
       std::find(prof_it->second.begin(), prof_it->second.end(), type_pair) !=
           prof_it->second.end())
     return;
 
   UInt nb_degree_of_freedom_per_node = dof_data.dof->getNbComponent();
 
   const Array<UInt> & equation_number = this->getLocalEquationNumbers(dof_id);
 
   SparseMatrixAIJ & A = this->getMatrix(matrix_id);
 
   UInt size = A.size();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
   const auto & connectivity = this->mesh->getConnectivity(type, ghost_type);
   auto cbegin = connectivity.begin(nb_nodes_per_element);
   auto cit = cbegin;
 
   UInt nb_elements = connectivity.size();
   UInt * ge_it = nullptr;
   if (dof_data.group_support != "__mesh__") {
     const Array<UInt> & group_elements =
         this->mesh->getElementGroup(dof_data.group_support)
             .getElements(type, ghost_type);
     ge_it = group_elements.storage();
     nb_elements = group_elements.size();
   }
 
   UInt size_mat = nb_nodes_per_element * nb_degree_of_freedom_per_node;
   Vector<UInt> element_eq_nb(size_mat);
 
   for (UInt e = 0; e < nb_elements; ++e) {
     if (ge_it)
       cit = cbegin + *ge_it;
 
     this->extractElementEquationNumber(
         equation_number, *cit, nb_degree_of_freedom_per_node, element_eq_nb);
     std::transform(element_eq_nb.storage(),
                    element_eq_nb.storage() + element_eq_nb.size(),
                    element_eq_nb.storage(), [&](UInt & local) -> UInt {
                      return this->localToGlobalEquationNumber(local);
                    });
 
     if (ge_it)
       ++ge_it;
     else
       ++cit;
 
     for (UInt i = 0; i < size_mat; ++i) {
       UInt c_irn = element_eq_nb(i);
       if (c_irn < size) {
         for (UInt j = 0; j < size_mat; ++j) {
           UInt c_jcn = element_eq_nb(j);
           if (c_jcn < size) {
             A.add(c_irn, c_jcn);
           }
         }
       }
     }
   }
 
   this->matrix_profiled_dofs[mat_dof].push_back(type_pair);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::applyBoundary(const ID & matrix_id) {
   SparseMatrixAIJ & J = this->getMatrix(matrix_id);
 
   if (this->jacobian_release == J.getValueRelease()) {
     auto are_equal =
         std::equal(global_blocked_dofs.begin(), global_blocked_dofs.end(),
                    previous_global_blocked_dofs.begin());
 
     if (are_equal)
       J.applyBoundary();
 
     previous_global_blocked_dofs.copy(global_blocked_dofs);
   } else {
     J.applyBoundary();
   }
 
   this->jacobian_release = J.getValueRelease();
 }
 
 /* -------------------------------------------------------------------------- */
 const Array<Real> & DOFManagerDefault::getGlobalResidual() {
   if (this->synchronizer) {
     if (not this->global_residual) {
       this->global_residual =
           std::make_unique<Array<Real>>(0, 1, "global_residual");
     }
 
     if (this->synchronizer->getCommunicator().whoAmI() == 0) {
       this->global_residual->resize(this->system_size);
       this->synchronizer->gather(this->residual, *this->global_residual);
     } else {
       this->synchronizer->gather(this->residual);
     }
 
     return *this->global_residual;
   } else {
     return this->residual;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 const Array<Real> & DOFManagerDefault::getResidual() const {
   return this->residual;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::setGlobalSolution(const Array<Real> & solution) {
   if (this->synchronizer) {
     if (this->synchronizer->getCommunicator().whoAmI() == 0) {
       this->synchronizer->scatter(this->global_solution, solution);
     } else {
       this->synchronizer->scatter(this->global_solution);
     }
   } else {
     AKANTU_DEBUG_ASSERT(solution.size() == this->global_solution.size(),
                         "Sequential call to this function needs the solution "
                         "to be the same size as the global_solution");
     this->global_solution.copy(solution);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::onNodesAdded(const Array<UInt> & nodes_list,
                                      const NewNodesEvent & event) {
   DOFManager::onNodesAdded(nodes_list, event);
 
   if (this->synchronizer)
     this->synchronizer->onNodesAdded(nodes_list);
 }
 
 /* -------------------------------------------------------------------------- */
 std::pair<UInt, UInt>
 DOFManagerDefault::updateNodalDOFs(const ID & dof_id,
                                    const Array<UInt> & nodes_list) {
   UInt nb_new_local_dofs, nb_new_pure_local;
   std::tie(nb_new_local_dofs, nb_new_pure_local) =
       DOFManager::updateNodalDOFs(dof_id, nodes_list);
 
   auto & dof_data = this->getDOFDataTyped<DOFDataDefault>(dof_id);
   updateDOFsData(dof_data, nb_new_local_dofs, nb_new_pure_local,
                  [&nodes_list](UInt pos) -> UInt { return nodes_list[pos]; });
 
   return std::make_pair(nb_new_local_dofs, nb_new_pure_local);
 }
 
 /* -------------------------------------------------------------------------- */
-void DOFManagerDefault::updateDOFsData(DOFDataDefault & dof_data,
-                                       UInt nb_new_local_dofs,
-                                       UInt nb_new_pure_local,
-                                       std::function<UInt(UInt)> getNode) {
+void DOFManagerDefault::updateDOFsData(
+    DOFDataDefault & dof_data, UInt nb_new_local_dofs, UInt nb_new_pure_local,
+    const std::function<UInt(UInt)> & getNode) {
   auto prank = this->communicator.whoAmI();
   auto psize = this->communicator.getNbProc();
 
   // access the relevant data to update
   const auto & support_type = dof_data.support_type;
 
   GlobalDOFInfoDataAccessor data_accessor;
 
   // resize all relevant arrays
   this->residual.resize(this->local_system_size);
   this->dofs_type.resize(this->local_system_size);
   this->global_solution.resize(this->local_system_size);
   this->global_blocked_dofs.resize(this->local_system_size);
   this->previous_global_blocked_dofs.resize(this->local_system_size);
   this->global_equation_number.resize(this->local_system_size);
 
   for (auto & lumped_matrix : lumped_matrices)
     lumped_matrix.second->resize(this->local_system_size);
 
   dof_data.local_equation_number.reserve(
       dof_data.local_equation_number.size() + nb_new_local_dofs);
 
   // determine the first local/global dof id to use
   Array<UInt> nb_dofs_per_proc(psize);
   nb_dofs_per_proc(prank) = nb_new_pure_local;
   this->communicator.allGather(nb_dofs_per_proc);
 
   this->first_global_dof_id += std::accumulate(
       nb_dofs_per_proc.begin(), nb_dofs_per_proc.begin() + prank, 0);
   UInt first_dof_id = this->local_system_size - nb_new_local_dofs;
 
   if (support_type == _dst_nodal) {
     dof_data.associated_nodes.reserve(dof_data.associated_nodes.size() +
                                       nb_new_local_dofs);
   }
 
   // update per dof info
   for (UInt d = 0; d < nb_new_local_dofs; ++d) {
     UInt local_eq_num = first_dof_id + d;
     dof_data.local_equation_number.push_back(local_eq_num);
 
     bool is_local_dof = true;
 
     // determine the dof type
     switch (support_type) {
     case _dst_nodal: {
       UInt node = getNode(d / dof_data.dof->getNbComponent());
 
       this->dofs_type(local_eq_num) = this->mesh->getNodeType(node);
       dof_data.associated_nodes.push_back(node);
 
       is_local_dof = this->mesh->isLocalOrMasterNode(node);
 
       if (is_local_dof) {
         data_accessor.addDOFToNode(node, first_global_dof_id);
       }
 
       break;
     }
     case _dst_generic: {
       this->dofs_type(local_eq_num) = _nt_normal;
       break;
     }
     default: { AKANTU_EXCEPTION("This type of dofs is not handled yet."); }
     }
 
     // update global id for local dofs
     if (is_local_dof) {
       this->global_equation_number(local_eq_num) = this->first_global_dof_id;
       this->global_to_local_mapping[this->first_global_dof_id] = local_eq_num;
       ++this->first_global_dof_id;
     } else {
       this->global_equation_number(local_eq_num) = 0;
     }
   }
 
   // synchronize the global numbering for slaves
   if (support_type == _dst_nodal && this->synchronizer) {
     auto nb_dofs_per_node = dof_data.dof->getNbComponent();
 
     auto & node_synchronizer = this->mesh->getNodeSynchronizer();
     node_synchronizer.synchronizeOnce(data_accessor, _gst_size);
     node_synchronizer.synchronizeOnce(data_accessor, _gst_update);
 
     std::vector<UInt> counters(nb_new_local_dofs / nb_dofs_per_node);
 
     for (UInt d = 0; d < nb_new_local_dofs; ++d) {
       UInt local_eq_num = first_dof_id + d;
       if (not this->isSlaveDOF(local_eq_num))
         continue;
 
       UInt node = d / nb_dofs_per_node;
       UInt dof_count = counters[node]++;
       node = getNode(node);
 
       UInt global_dof_id = data_accessor.getNthDOFForNode(dof_count, node);
 
       this->global_equation_number(local_eq_num) = global_dof_id;
       this->global_to_local_mapping[global_dof_id] = local_eq_num;
     }
   }
 }
 
 } // namespace akantu
 
 //  LocalWords:  dof dofs
diff --git a/src/model/dof_manager_default.hh b/src/model/dof_manager_default.hh
index 6a70ac77f..588c00611 100644
--- a/src/model/dof_manager_default.hh
+++ b/src/model/dof_manager_default.hh
@@ -1,360 +1,360 @@
 /**
  * @file   dof_manager_default.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Tue Aug 11 14:06:18 2015
  *
  * @brief  Default implementation of the dof manager
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dof_manager.hh"
 /* -------------------------------------------------------------------------- */
 #include <unordered_map>
 #include <functional>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_DOF_MANAGER_DEFAULT_HH__
 #define __AKANTU_DOF_MANAGER_DEFAULT_HH__
 
 namespace akantu {
 class SparseMatrixAIJ;
 class NonLinearSolverDefault;
 class TimeStepSolverDefault;
 class DOFSynchronizer;
 } // namespace akantu
 
 namespace akantu {
 
 class DOFManagerDefault : public DOFManager {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   DOFManagerDefault(const ID & id = "dof_manager_default",
                     const MemoryID & memory_id = 0);
   DOFManagerDefault(Mesh & mesh, const ID & id = "dof_manager_default",
                     const MemoryID & memory_id = 0);
   ~DOFManagerDefault() override;
 
 protected:
   struct DOFDataDefault : public DOFData {
     explicit DOFDataDefault(const ID & dof_id);
 
     /// associated node for _dst_nodal dofs only
     Array<UInt> associated_nodes;
   };
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 private:
   void registerDOFsInternal(const ID & dof_id, UInt nb_dofs,
                             UInt nb_pure_local_dofs);
 
 public:
   /// register an array of degree of freedom
   void registerDOFs(const ID & dof_id, Array<Real> & dofs_array,
                     const DOFSupportType & support_type) override;
 
   /// the dof as an implied type of _dst_nodal and is defined only on a subset
   /// of nodes
   void registerDOFs(const ID & dof_id, Array<Real> & dofs_array,
                     const ID & group_support) override;
 
   /// Assemble an array to the global residual array
   void assembleToResidual(const ID & dof_id,
                           const Array<Real> & array_to_assemble,
                           Real scale_factor = 1.) override;
 
   /// Assemble an array to the global lumped matrix array
   void assembleToLumpedMatrix(const ID & dof_id,
                               const Array<Real> & array_to_assemble,
                               const ID & lumped_mtx,
                               Real scale_factor = 1.) override;
   /**
    * Assemble elementary values to the global matrix. The dof number is
    * implicitly considered as conn(el, n) * nb_nodes_per_element + d.
    * With 0 < n < nb_nodes_per_element and 0 < d < nb_dof_per_node
    **/
   void assembleElementalMatricesToMatrix(
       const ID & matrix_id, const ID & dof_id,
       const Array<Real> & elementary_mat, const ElementType & type,
       const GhostType & ghost_type, const MatrixType & elemental_matrix_type,
       const Array<UInt> & filter_elements) override;
 
   /// multiply a vector by a matrix and assemble the result to the residual
   void assembleMatMulVectToResidual(const ID & dof_id, const ID & A_id,
                                     const Array<Real> & x,
                                     Real scale_factor = 1) override;
 
   /// multiply a vector by a lumped matrix and assemble the result to the
   /// residual
   void assembleLumpedMatMulVectToResidual(const ID & dof_id, const ID & A_id,
                                           const Array<Real> & x,
                                           Real scale_factor = 1) override;
 
   /// assemble coupling terms between to dofs
   void assemblePreassembledMatrix(const ID & dof_id_m, const ID & dof_id_n,
                                   const ID & matrix_id,
                                   const TermsToAssemble & terms) override;
 
 protected:
   /// Assemble an array to the global residual array
   template <typename T>
   void assembleToGlobalArray(const ID & dof_id,
                              const Array<T> & array_to_assemble,
                              Array<T> & global_array, T scale_factor);
 
 public:
   /// clear the residual
   void clearResidual() override;
 
   /// sets the matrix to 0
   void clearMatrix(const ID & mtx) override;
 
   /// sets the lumped matrix to 0
   void clearLumpedMatrix(const ID & mtx) override;
 
   /// update the global dofs vector
   virtual void updateGlobalBlockedDofs();
 
   /// apply boundary conditions to jacobian matrix
   virtual void applyBoundary(const ID & matrix_id = "J");
 
   // void getEquationsNumbers(const ID & dof_id,
   //                          Array<UInt> & equation_numbers) override;
 
 protected:
   /// Get local part of an array corresponding to a given dofdata
   template <typename T>
   void getArrayPerDOFs(const ID & dof_id, const Array<T> & global_array,
                        Array<T> & local_array) const;
 
   /// Get the part of the solution corresponding to the dof_id
   void getSolutionPerDOFs(const ID & dof_id,
                           Array<Real> & solution_array) override;
 
   /// fill a Vector with the equation numbers corresponding to the given
   /// connectivity
   inline void extractElementEquationNumber(
       const Array<UInt> & equation_numbers, const Vector<UInt> & connectivity,
       UInt nb_degree_of_freedom, Vector<UInt> & local_equation_number);
 
 public:
   /// extract a lumped matrix part corresponding to a given dof
   void getLumpedMatrixPerDOFs(const ID & dof_id, const ID & lumped_mtx,
                               Array<Real> & lumped) override;
 
 private:
   /// Add a symmetric matrices to a symmetric sparse matrix
   void addSymmetricElementalMatrixToSymmetric(
       SparseMatrixAIJ & matrix, const Matrix<Real> & element_mat,
       const Vector<UInt> & equation_numbers, UInt max_size);
 
   /// Add a unsymmetric matrices to a symmetric sparse matrix (i.e. cohesive
   /// elements)
   void addUnsymmetricElementalMatrixToSymmetric(
       SparseMatrixAIJ & matrix, const Matrix<Real> & element_mat,
       const Vector<UInt> & equation_numbers, UInt max_size);
 
   /// Add a matrices to a unsymmetric sparse matrix
   void addElementalMatrixToUnsymmetric(SparseMatrixAIJ & matrix,
                                        const Matrix<Real> & element_mat,
                                        const Vector<UInt> & equation_numbers,
                                        UInt max_size);
 
   void addToProfile(const ID & matrix_id, const ID & dof_id,
                     const ElementType & type, const GhostType & ghost_type);
 
   /* ------------------------------------------------------------------------ */
   /* MeshEventHandler interface                                               */
   /* ------------------------------------------------------------------------ */
 protected:
   std::pair<UInt, UInt>
   updateNodalDOFs(const ID & dof_id, const Array<UInt> & nodes_list) override;
 
 private:
   void updateDOFsData(DOFDataDefault & dof_data, UInt nb_new_local_dofs,
                       UInt nb_new_pure_local,
-                      std::function<UInt(UInt)> getNode);
+                      const std::function<UInt(UInt)> & getNode);
 
 public:
   /// function to implement to react on  akantu::NewNodesEvent
   void onNodesAdded(const Array<UInt> & nodes_list,
                     const NewNodesEvent & event) override;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// Get an instance of a new SparseMatrix
   SparseMatrix & getNewMatrix(const ID & matrix_id,
                               const MatrixType & matrix_type) override;
 
   /// Get an instance of a new SparseMatrix as a copy of the SparseMatrix
   /// matrix_to_copy_id
   SparseMatrix & getNewMatrix(const ID & matrix_id,
                               const ID & matrix_to_copy_id) override;
 
   /// Get the reference of an existing matrix
   SparseMatrixAIJ & getMatrix(const ID & matrix_id);
 
   /* ------------------------------------------------------------------------ */
   /* Non Linear Solver                                                        */
   /* ------------------------------------------------------------------------ */
   /// Get instance of a non linear solver
   NonLinearSolver & getNewNonLinearSolver(
       const ID & nls_solver_id,
       const NonLinearSolverType & _non_linear_solver_type) override;
 
   /* ------------------------------------------------------------------------ */
   /* Time-Step Solver                                                         */
   /* ------------------------------------------------------------------------ */
   /// Get instance of a time step solver
   TimeStepSolver &
   getNewTimeStepSolver(const ID & id, const TimeStepSolverType & type,
                        NonLinearSolver & non_linear_solver) override;
 
   /* ------------------------------------------------------------------------ */
   /// Get the solution array
   AKANTU_GET_MACRO_NOT_CONST(GlobalSolution, global_solution, Array<Real> &);
   /// Set the global solution array
   void setGlobalSolution(const Array<Real> & solution);
 
   /// Get the global residual array across processors (SMP call)
   const Array<Real> & getGlobalResidual();
 
   /// Get the residual array
   const Array<Real> & getResidual() const;
 
   /// Get the blocked dofs array
   AKANTU_GET_MACRO(GlobalBlockedDOFs, global_blocked_dofs, const Array<bool> &);
   /// Get the blocked dofs array
   AKANTU_GET_MACRO(PreviousGlobalBlockedDOFs, previous_global_blocked_dofs,
                    const Array<bool> &);
   /// Get the location type of a given dof
   inline bool isLocalOrMasterDOF(UInt local_dof_num);
 
   /// Answer to the question is a dof a slave dof ?
   inline bool isSlaveDOF(UInt local_dof_num);
 
   /// get the equation numbers (in local numbering) corresponding to a dof ID
   inline const Array<UInt> & getLocalEquationNumbers(const ID & dof_id) const;
 
   /// tells if the dof manager knows about a global dof
   bool hasGlobalEquationNumber(UInt global) const;
 
   /// return the local index of the global equation number
   inline UInt globalToLocalEquationNumber(UInt global) const;
 
   /// converts local equation numbers to global equation numbers;
   inline UInt localToGlobalEquationNumber(UInt local) const;
 
   /// get the array of dof types (use only if you know what you do...)
   inline Int getDOFType(UInt local_id) const;
 
   /// get the array of dof types (use only if you know what you do...)
   inline const Array<UInt> & getDOFsAssociatedNodes(const ID & dof_id) const;
 
   /// access the internal dof_synchronizer
   AKANTU_GET_MACRO_NOT_CONST(Synchronizer, *synchronizer, DOFSynchronizer &);
 
   /// access the internal dof_synchronizer
   bool hasSynchronizer() const { return synchronizer != nullptr; }
 
 protected:
   DOFData & getNewDOFData(const ID & dof_id) override;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   // using AIJMatrixMap = std::map<ID, std::unique_ptr<SparseMatrixAIJ>>;
   // using DefaultNonLinearSolversMap =
   //     std::map<ID, std::unique_ptr<NonLinearSolverDefault>>;
   // using DefaultTimeStepSolversMap =
   //     std::map<ID, std::unique_ptr<TimeStepSolverDefault>>;
 
   using DOFToMatrixProfile =
       std::map<std::pair<ID, ID>,
                std::vector<std::pair<ElementType, GhostType>>>;
 
   /// contains the the dofs that where added to the profile of a given matrix.
   DOFToMatrixProfile matrix_profiled_dofs;
 
   /// rhs to the system of equation corresponding to the residual linked to the
   /// different dofs
   Array<Real> residual;
 
   /// rhs used only on root proc in case of parallel computing, this is the full
   /// gathered rhs array
   std::unique_ptr<Array<Real>> global_residual;
 
   /// solution of the system of equation corresponding to the different dofs
   Array<Real> global_solution;
 
   /// blocked degree of freedom in the system equation corresponding to the
   /// different dofs
   Array<bool> global_blocked_dofs;
 
   /// blocked degree of freedom in the system equation corresponding to the
   /// different dofs
   Array<bool> previous_global_blocked_dofs;
 
   /// define the dofs type, local, shared, ghost
   Array<Int> dofs_type;
 
   /// Map of the different matrices stored in the dof manager
   //AIJMatrixMap aij_matrices;
 
   /// Map of the different time step solvers stored with there real type
   //DefaultTimeStepSolversMap default_time_step_solver_map;
 
   /// Memory cache, this is an array to keep the temporary memory needed for
   /// some operations, it is meant to be resized or cleared when needed
   Array<Real> data_cache;
 
   /// Release at last apply boundary on jacobian
-  UInt jacobian_release;
+  UInt jacobian_release{0};
 
   /// equation number in global numbering
   Array<UInt> global_equation_number;
 
   using equation_numbers_map = std::unordered_map<UInt, UInt>;
 
   /// dual information of global_equation_number
   equation_numbers_map global_to_local_mapping;
 
   /// accumulator to know what would be the next global id to use
-  UInt first_global_dof_id;
+  UInt first_global_dof_id{0};
 
   /// synchronizer to maintain coherency in dof fields
   std::unique_ptr<DOFSynchronizer> synchronizer;
 };
 
 } // namespace akantu
 
 #include "dof_manager_default_inline_impl.cc"
 
 #endif /* __AKANTU_DOF_MANAGER_DEFAULT_HH__ */
diff --git a/src/model/dof_manager_default_inline_impl.cc b/src/model/dof_manager_default_inline_impl.cc
index c3ef864b2..1dc37020f 100644
--- a/src/model/dof_manager_default_inline_impl.cc
+++ b/src/model/dof_manager_default_inline_impl.cc
@@ -1,105 +1,104 @@
 /**
  * @file   dof_manager_default_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Aug 12 10:57:47 2015
  *
  * @brief  Implementation of the DOFManagerDefault inline functions
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dof_manager_default.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_DOF_MANAGER_DEFAULT_INLINE_IMPL_CC__
 #define __AKANTU_DOF_MANAGER_DEFAULT_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline bool DOFManagerDefault::isLocalOrMasterDOF(UInt dof_num) {
   Int dof_type = this->dofs_type(dof_num);
   return (dof_type == Int(_nt_normal)) || (dof_type == Int(_nt_master));
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool DOFManagerDefault::isSlaveDOF(UInt dof_num) {
   Int dof_type = this->dofs_type(dof_num);
   return (dof_type >= 0);
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Array<UInt> &
 DOFManagerDefault::getLocalEquationNumbers(const ID & dof_id) const {
   return this->getDOFData(dof_id).local_equation_number;
 }
 
 inline const Array<UInt> &
 DOFManagerDefault::getDOFsAssociatedNodes(const ID & dof_id) const {
-  const DOFDataDefault & dof_data =
-      this->getDOFDataTyped<DOFDataDefault>(dof_id);
+  const auto & dof_data = this->getDOFDataTyped<DOFDataDefault>(dof_id);
   return dof_data.associated_nodes;
 }
 /* -------------------------------------------------------------------------- */
 inline void DOFManagerDefault::extractElementEquationNumber(
     const Array<UInt> & equation_numbers, const Vector<UInt> & connectivity,
     UInt nb_degree_of_freedom, Vector<UInt> & element_equation_number) {
   for (UInt i = 0, ld = 0; i < connectivity.size(); ++i) {
     UInt n = connectivity(i);
     for (UInt d = 0; d < nb_degree_of_freedom; ++d, ++ld) {
       element_equation_number(ld) =
           equation_numbers(n * nb_degree_of_freedom + d);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt DOFManagerDefault::localToGlobalEquationNumber(UInt local) const {
   return this->global_equation_number(local);
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool DOFManagerDefault::hasGlobalEquationNumber(UInt global) const {
   auto it = this->global_to_local_mapping.find(global);
   return (it != this->global_to_local_mapping.end());
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt DOFManagerDefault::globalToLocalEquationNumber(UInt global) const {
   auto it = this->global_to_local_mapping.find(global);
   AKANTU_DEBUG_ASSERT(it != this->global_to_local_mapping.end(),
                       "This global equation number "
                           << global << " does not exists in " << this->id);
 
   return it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Int DOFManagerDefault::getDOFType(UInt local_id) const {
   return this->dofs_type(local_id);
 }
 /* -------------------------------------------------------------------------- */
 
 } // akantu
 
 #endif /* __AKANTU_DOF_MANAGER_DEFAULT_INLINE_IMPL_CC_ */
diff --git a/src/model/dof_manager_inline_impl.cc b/src/model/dof_manager_inline_impl.cc
index d9dab0b49..89762d580 100644
--- a/src/model/dof_manager_inline_impl.cc
+++ b/src/model/dof_manager_inline_impl.cc
@@ -1,154 +1,154 @@
 /**
  * @file   dof_manager_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Aug 12 11:07:01 2015
  *
  * @brief
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dof_manager.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_DOF_MANAGER_INLINE_IMPL_CC__
 #define __AKANTU_DOF_MANAGER_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline bool DOFManager::hasDOFs(const ID & dof_id) const {
-  DOFStorage::const_iterator it = this->dofs.find(dof_id);
+  auto it = this->dofs.find(dof_id);
   return it != this->dofs.end();
 }
 
 /* -------------------------------------------------------------------------- */
 inline DOFManager::DOFData & DOFManager::getDOFData(const ID & dof_id) {
-  DOFStorage::iterator it = this->dofs.find(dof_id);
+  auto it = this->dofs.find(dof_id);
   if (it == this->dofs.end()) {
     AKANTU_EXCEPTION("The dof " << dof_id << " does not exists in "
                                 << this->id);
   }
   return *it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 const DOFManager::DOFData & DOFManager::getDOFData(const ID & dof_id) const {
-  DOFStorage::const_iterator it = this->dofs.find(dof_id);
+  auto it = this->dofs.find(dof_id);
   if (it == this->dofs.end()) {
     AKANTU_EXCEPTION("The dof " << dof_id << " does not exists in "
                                 << this->id);
   }
   return *it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 const Array<UInt> & DOFManager::getEquationsNumbers(const ID & dof_id) const {
   return getDOFData(dof_id).local_equation_number;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class _DOFData>
 inline _DOFData & DOFManager::getDOFDataTyped(const ID & dof_id) {
   return dynamic_cast<_DOFData &>(this->getDOFData(dof_id));
 }
 
 /* -------------------------------------------------------------------------- */
 template <class _DOFData>
 inline const _DOFData & DOFManager::getDOFDataTyped(const ID & dof_id) const {
   return dynamic_cast<const _DOFData &>(this->getDOFData(dof_id));
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<Real> & DOFManager::getDOFs(const ID & dofs_id) {
   return *(this->getDOFData(dofs_id).dof);
 }
 
 
 /* -------------------------------------------------------------------------- */
 inline DOFSupportType DOFManager::getSupportType(const ID & dofs_id) const {
   return this->getDOFData(dofs_id).support_type;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<Real> & DOFManager::getPreviousDOFs(const ID & dofs_id) {
   return *(this->getDOFData(dofs_id).previous);
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool DOFManager::hasPreviousDOFs(const ID & dofs_id) const {
   return (this->getDOFData(dofs_id).previous != nullptr);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<Real> & DOFManager::getDOFsIncrement(const ID & dofs_id) {
   return *(this->getDOFData(dofs_id).increment);
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool DOFManager::hasDOFsIncrement(const ID & dofs_id) const {
   return (this->getDOFData(dofs_id).increment != nullptr);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<Real> & DOFManager::getDOFsDerivatives(const ID & dofs_id,
                                                     UInt order) {
   std::vector<Array<Real> *> & derivatives =
       this->getDOFData(dofs_id).dof_derivatives;
   if ((order > derivatives.size()) || (derivatives[order - 1] == nullptr))
     AKANTU_EXCEPTION("No derivatives of order " << order << " present in "
                                                 << this->id << " for dof "
                                                 << dofs_id);
 
   return *derivatives[order - 1];
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool DOFManager::hasDOFsDerivatives(const ID & dofs_id,
                                            UInt order) const{
   const std::vector<Array<Real> *> & derivatives =
       this->getDOFData(dofs_id).dof_derivatives;
   return ((order < derivatives.size()) && (derivatives[order - 1] != nullptr));
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Array<Real> & DOFManager::getSolution(const ID & dofs_id) const {
   return this->getDOFData(dofs_id).solution;
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Array<bool> &
 DOFManager::getBlockedDOFs(const ID & dofs_id) const {
   return *(this->getDOFData(dofs_id).blocked_dofs);
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool DOFManager::hasBlockedDOFs(const ID & dofs_id) const {
   return (this->getDOFData(dofs_id).blocked_dofs != nullptr);
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
 
 #endif /* __AKANTU_DOF_MANAGER_INLINE_IMPL_CC__ */
diff --git a/src/model/model.cc b/src/model/model.cc
index a9ffb9eb7..a7064d12c 100644
--- a/src/model/model.cc
+++ b/src/model/model.cc
@@ -1,350 +1,351 @@
 /**
  * @file   model.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Oct 03 2011
  * @date last modification: Thu Nov 19 2015
  *
  * @brief  implementation of model common parts
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "model.hh"
 #include "communicator.hh"
 #include "data_accessor.hh"
 #include "element_group.hh"
 #include "element_synchronizer.hh"
 #include "synchronizer_registry.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Model::Model(Mesh & mesh, UInt dim, const ID & id, const MemoryID & memory_id)
     : Memory(id, memory_id), ModelSolver(mesh, id, memory_id), mesh(mesh),
       spatial_dimension(dim == _all_dimensions ? mesh.getSpatialDimension()
                                                : dim),
       is_pbc_slave_node(0, 1, "is_pbc_slave_node"), parser(getStaticParser()) {
   AKANTU_DEBUG_IN();
 
   this->mesh.registerEventHandler(*this, _ehp_model);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Model::~Model() = default;
 
 /* -------------------------------------------------------------------------- */
 // void Model::setParser(Parser & parser) { this->parser = &parser; }
 
 /* -------------------------------------------------------------------------- */
 void Model::initFull(const ModelOptions & options) {
   AKANTU_DEBUG_IN();
 
   method = options.analysis_method;
   if (!this->hasDefaultSolver()) {
     this->initNewSolver(this->method);
   }
   initModel();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::initNewSolver(const AnalysisMethod & method) {
   ID solver_name;
   TimeStepSolverType tss_type;
   std::tie(solver_name, tss_type) = this->getDefaultSolverID(method);
 
   if (!this->hasSolver(solver_name)) {
     ModelSolverOptions options = this->getDefaultSolverOptions(tss_type);
     this->getNewSolver(solver_name, tss_type, options.non_linear_solver_type);
     this->setIntegrationScheme(solver_name, "displacement",
                                options.integration_scheme_type["displacement"],
                                options.solution_type["displacement"]);
   }
 
   this->method = method;
   this->setDefaultSolver(solver_name);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::initPBC() {
-  std::map<UInt, UInt>::iterator it = pbc_pair.begin();
-  std::map<UInt, UInt>::iterator end = pbc_pair.end();
+  auto it = pbc_pair.begin();
+  auto end = pbc_pair.end();
 
   is_pbc_slave_node.resize(mesh.getNbNodes());
 #ifndef AKANTU_NDEBUG
   Array<Real>::const_vector_iterator coord_it =
       mesh.getNodes().begin(this->spatial_dimension);
 #endif
 
   while (it != end) {
     UInt i1 = (*it).first;
 
     is_pbc_slave_node(i1) = true;
 
 #ifndef AKANTU_NDEBUG
     UInt i2 = (*it).second;
     UInt slave = mesh.isDistributed() ? mesh.getGlobalNodesIds()(i1) : i1;
     UInt master = mesh.isDistributed() ? mesh.getGlobalNodesIds()(i2) : i2;
 
     AKANTU_DEBUG_INFO("pairing " << slave << " (" << Vector<Real>(coord_it[i1])
                                  << ") with " << master << " ("
                                  << Vector<Real>(coord_it[i2]) << ")");
 #endif
     ++it;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::dumpGroup(const std::string & group_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   group.dump();
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::dumpGroup(const std::string & group_name,
                       const std::string & dumper_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   group.dump(dumper_name);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::dumpGroup() {
-  GroupManager::element_group_iterator bit = mesh.element_group_begin();
-  GroupManager::element_group_iterator bend = mesh.element_group_end();
+  auto bit = mesh.element_group_begin();
+  auto bend = mesh.element_group_end();
   for (; bit != bend; ++bit) {
     bit->second->dump();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::setGroupDirectory(const std::string & directory) {
-  GroupManager::element_group_iterator bit = mesh.element_group_begin();
-  GroupManager::element_group_iterator bend = mesh.element_group_end();
+  auto bit = mesh.element_group_begin();
+  auto bend = mesh.element_group_end();
   for (; bit != bend; ++bit) {
     bit->second->setDirectory(directory);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::setGroupDirectory(const std::string & directory,
                               const std::string & group_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   group.setDirectory(directory);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::setGroupBaseName(const std::string & basename,
                              const std::string & group_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   group.setBaseName(basename);
 }
 
 /* -------------------------------------------------------------------------- */
 DumperIOHelper & Model::getGroupDumper(const std::string & group_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   return group.getDumper();
 }
 
 /* -------------------------------------------------------------------------- */
 // DUMPER stuff
 /* -------------------------------------------------------------------------- */
 void Model::addDumpGroupFieldToDumper(const std::string & field_id,
                                       dumper::Field * field,
                                       DumperIOHelper & dumper) {
 #ifdef AKANTU_USE_IOHELPER
   dumper.registerField(field_id, field);
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpField(const std::string & field_id) {
 
   this->addDumpFieldToDumper(mesh.getDefaultDumperName(), field_id);
 }
 /* -------------------------------------------------------------------------- */
 
 void Model::addDumpFieldVector(const std::string & field_id) {
 
   this->addDumpFieldVectorToDumper(mesh.getDefaultDumperName(), field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpFieldTensor(const std::string & field_id) {
 
   this->addDumpFieldTensorToDumper(mesh.getDefaultDumperName(), field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Model::setBaseName(const std::string & field_id) {
 
   mesh.setBaseName(field_id);
 }
 /* -------------------------------------------------------------------------- */
 
 void Model::setBaseNameToDumper(const std::string & dumper_name,
                                 const std::string & basename) {
   mesh.setBaseNameToDumper(dumper_name, basename);
 }
 /* -------------------------------------------------------------------------- */
 
 void Model::addDumpFieldToDumper(const std::string & dumper_name,
                                  const std::string & field_id) {
 
   this->addDumpGroupFieldToDumper(dumper_name, field_id, "all", _ek_regular,
                                   false);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpGroupField(const std::string & field_id,
                               const std::string & group_name) {
 
   ElementGroup & group = mesh.getElementGroup(group_name);
   this->addDumpGroupFieldToDumper(group.getDefaultDumperName(), field_id,
                                   group_name, _ek_regular, false);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::removeDumpGroupField(const std::string & field_id,
                                  const std::string & group_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   this->removeDumpGroupFieldFromDumper(group.getDefaultDumperName(), field_id,
                                        group_name);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::removeDumpGroupFieldFromDumper(const std::string & dumper_name,
                                            const std::string & field_id,
                                            const std::string & group_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   group.removeDumpFieldFromDumper(dumper_name, field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpFieldVectorToDumper(const std::string & dumper_name,
                                        const std::string & field_id) {
-  this->addDumpGroupFieldToDumper(dumper_name, field_id, "all", _ek_regular, 3);
+  this->addDumpGroupFieldToDumper(dumper_name, field_id, "all", _ek_regular,
+                                  true);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpGroupFieldVector(const std::string & field_id,
                                     const std::string & group_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   this->addDumpGroupFieldVectorToDumper(group.getDefaultDumperName(), field_id,
                                         group_name);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpGroupFieldVectorToDumper(const std::string & dumper_name,
                                             const std::string & field_id,
                                             const std::string & group_name) {
   this->addDumpGroupFieldToDumper(dumper_name, field_id, group_name,
                                   _ek_regular, true);
 }
 /* -------------------------------------------------------------------------- */
 
 void Model::addDumpFieldTensorToDumper(const std::string & dumper_name,
                                        const std::string & field_id) {
   this->addDumpGroupFieldToDumper(dumper_name, field_id, "all", _ek_regular,
                                   true);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpGroupFieldToDumper(const std::string & dumper_name,
                                       const std::string & field_id,
                                       const std::string & group_name,
                                       const ElementKind & element_kind,
                                       bool padding_flag) {
   this->addDumpGroupFieldToDumper(dumper_name, field_id, group_name,
                                   this->spatial_dimension, element_kind,
                                   padding_flag);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpGroupFieldToDumper(const std::string & dumper_name,
                                       const std::string & field_id,
                                       const std::string & group_name,
                                       UInt spatial_dimension,
                                       const ElementKind & element_kind,
                                       bool padding_flag) {
 
 #ifdef AKANTU_USE_IOHELPER
   dumper::Field * field = nullptr;
 
   if (!field)
     field = this->createNodalFieldReal(field_id, group_name, padding_flag);
   if (!field)
     field = this->createNodalFieldUInt(field_id, group_name, padding_flag);
   if (!field)
     field = this->createNodalFieldBool(field_id, group_name, padding_flag);
   if (!field)
     field = this->createElementalField(field_id, group_name, padding_flag,
                                        spatial_dimension, element_kind);
   if (!field)
     field = this->mesh.createFieldFromAttachedData<UInt>(field_id, group_name,
                                                          element_kind);
   if (!field)
     field = this->mesh.createFieldFromAttachedData<Real>(field_id, group_name,
                                                          element_kind);
 
   if (!field)
     AKANTU_DEBUG_WARNING("No field could be found based on name: " << field_id);
   if (field) {
     DumperIOHelper & dumper = mesh.getGroupDumper(dumper_name, group_name);
     this->addDumpGroupFieldToDumper(field_id, field, dumper);
   }
 
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Model::dump() { mesh.dump(); }
 
 /* -------------------------------------------------------------------------- */
 
 void Model::setDirectory(const std::string & directory) {
   mesh.setDirectory(directory);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Model::setDirectoryToDumper(const std::string & dumper_name,
                                  const std::string & directory) {
   mesh.setDirectoryToDumper(dumper_name, directory);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Model::setTextModeToDumper() { mesh.setTextModeToDumper(); }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/model/model_inline_impl.cc b/src/model/model_inline_impl.cc
index ef491704e..989145ac8 100644
--- a/src/model/model_inline_impl.cc
+++ b/src/model/model_inline_impl.cc
@@ -1,215 +1,215 @@
 /**
  * @file   model_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Aug 25 2010
  * @date last modification: Wed Nov 11 2015
  *
  * @brief  inline implementation of the model class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "model.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MODEL_INLINE_IMPL_CC__
 #define __AKANTU_MODEL_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename FEEngineClass>
 inline FEEngineClass & Model::getFEEngineClassBoundary(std::string name) {
   AKANTU_DEBUG_IN();
 
   if (name == "")
     name = default_fem;
 
   FEEngineMap::const_iterator it_boun = fems_boundary.find(name);
 
   if (it_boun == fems_boundary.end()) {
     AKANTU_DEBUG_INFO("Creating FEEngine boundary " << name);
 
     FEEngineMap::const_iterator it = fems.find(name);
     AKANTU_DEBUG_ASSERT(it != fems.end(), "The FEEngine "
                                               << name << " is not registered");
 
     UInt spatial_dimension = it->second->getElementDimension();
     std::stringstream sstr;
     sstr << id << ":fem_boundary:" << name;
 
     fems_boundary[name] = std::make_unique<FEEngineClass>(
         it->second->getMesh(), spatial_dimension - 1, sstr.str(), memory_id);
   }
 
   AKANTU_DEBUG_OUT();
   return dynamic_cast<FEEngineClass &>(*fems_boundary[name]);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename FEEngineClass>
 inline FEEngineClass & Model::getFEEngineClass(std::string name) const {
   AKANTU_DEBUG_IN();
 
   if (name == "")
     name = default_fem;
 
-  FEEngineMap::const_iterator it = fems.find(name);
+  auto it = fems.find(name);
   AKANTU_DEBUG_ASSERT(it != fems.end(), "The FEEngine "
                                             << name << " is not registered");
 
   AKANTU_DEBUG_OUT();
   return dynamic_cast<FEEngineClass &>(*(it->second));
 }
 
 /* -------------------------------------------------------------------------- */
 
 inline void Model::unRegisterFEEngineObject(const std::string & name) {
 
-  FEEngineMap::iterator it = fems.find(name);
+  auto it = fems.find(name);
   AKANTU_DEBUG_ASSERT(it != fems.end(), "FEEngine object with name "
                                             << name << " was not found");
 
   fems.erase(it);
   if (!fems.empty())
     default_fem = (*fems.begin()).first;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename FEEngineClass>
 inline void Model::registerFEEngineObject(const std::string & name, Mesh & mesh,
                                           UInt spatial_dimension) {
   if (fems.size() == 0)
     default_fem = name;
 
 #ifndef AKANTU_NDEBUG
-  FEEngineMap::iterator it = fems.find(name);
+  auto it = fems.find(name);
   AKANTU_DEBUG_ASSERT(it == fems.end(), "FEEngine object with name "
                                             << name << " was already created");
 #endif
 
   std::stringstream sstr;
   sstr << id << ":fem:" << name << memory_id;
   fems[name] = std::make_unique<FEEngineClass>(mesh, spatial_dimension, sstr.str(), memory_id);
 }
 
 /* -------------------------------------------------------------------------- */
 inline FEEngine & Model::getFEEngine(const ID & name) const {
   AKANTU_DEBUG_IN();
   ID tmp_name = name;
   if (name == "")
     tmp_name = default_fem;
 
-  FEEngineMap::const_iterator it = fems.find(tmp_name);
+  auto it = fems.find(tmp_name);
 
   AKANTU_DEBUG_ASSERT(it != fems.end(),
                       "The FEEngine " << tmp_name << " is not registered");
 
   AKANTU_DEBUG_OUT();
   return *(it->second);\
 }
 
 /* -------------------------------------------------------------------------- */
 inline FEEngine & Model::getFEEngineBoundary(const ID & name) {
   AKANTU_DEBUG_IN();
 
   ID tmp_name = name;
   if (name == "")
     tmp_name = default_fem;
 
   FEEngineMap::const_iterator it = fems_boundary.find(tmp_name);
   AKANTU_DEBUG_ASSERT(it != fems_boundary.end(), "The FEEngine boundary  "
                                                      << tmp_name
                                                      << " is not registered");
   AKANTU_DEBUG_ASSERT(it->second != nullptr, "The FEEngine boundary "
                                                  << tmp_name
                                                  << " was not created");
 
   AKANTU_DEBUG_OUT();
   return *(it->second);
 }
 
 // /* --------------------------------------------------------------------------
 // */
 // /// @todo : should merge with a single function which handles local and
 // global
 // inline void Model::changeLocalEquationNumberForPBC(std::map<UInt,UInt> &
 // pbc_pair,
 // 					    UInt dimension){
 //   for (std::map<UInt,UInt>::iterator it = pbc_pair.begin();
 //        it != pbc_pair.end();++it) {
 //     Int node_master = (*it).second;
 //     Int node_slave = (*it).first;
 //     for (UInt i = 0; i < dimension; ++i) {
 //       (*dof_synchronizer->getLocalDOFEquationNumbersPointer())
 // 	(node_slave*dimension+i) = dimension*node_master+i;
 //       (*dof_synchronizer->getGlobalDOFEquationNumbersPointer())
 // 	(node_slave*dimension+i) = dimension*node_master+i;
 //     }
 //   }
 // }
 // /* --------------------------------------------------------------------------
 // */
 // inline bool Model::isPBCSlaveNode(const UInt node) const {
 //   // if no pbc is defined, is_pbc_slave_node is of size zero
 //   if (is_pbc_slave_node.size() == 0)
 //     return false;
 //   else
 //     return is_pbc_slave_node(node);
 // }
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Model::allocNodalField(Array<T> *& array, UInt nb_component, const ID & name) {
   if (array == nullptr) {
     UInt nb_nodes = mesh.getNbNodes();
     std::stringstream sstr_disp;
     sstr_disp << id << ":" << name;
 
     array =
         &(alloc<T>(sstr_disp.str(), nb_nodes, nb_component, T()));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Model::getNbIntegrationPoints(const Array<Element> & elements,
                                           const ID & fem_id) const {
   UInt nb_quad = 0;
   Array<Element>::const_iterator<Element> it = elements.begin();
   Array<Element>::const_iterator<Element> end = elements.end();
   for (; it != end; ++it) {
     const Element & el = *it;
     nb_quad +=
         getFEEngine(fem_id).getNbIntegrationPoints(el.type, el.ghost_type);
   }
   return nb_quad;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
 
 #endif /* __AKANTU_MODEL_INLINE_IMPL_CC__ */
diff --git a/src/model/non_linear_solver_linear.cc b/src/model/non_linear_solver_linear.cc
index d917106a7..8a8411b6e 100644
--- a/src/model/non_linear_solver_linear.cc
+++ b/src/model/non_linear_solver_linear.cc
@@ -1,70 +1,70 @@
 /**
  * @file   non_linear_solver_linear.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Tue Aug 25 00:57:00 2015
  *
  * @brief  Implementation of the default NonLinearSolver
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "non_linear_solver_linear.hh"
 #include "dof_manager_default.hh"
 #include "solver_callback.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolverLinear::NonLinearSolverLinear(
     DOFManagerDefault & dof_manager,
     const NonLinearSolverType & non_linear_solver_type, const ID & id,
     UInt memory_id)
     : NonLinearSolver(dof_manager, non_linear_solver_type, id, memory_id),
       dof_manager(dof_manager),
       solver(dof_manager, "J", id + ":sparse_solver", memory_id) {
 
   this->supported_type.insert(_nls_linear);
   this->checkIfTypeIsSupported();
 }
 
 /* -------------------------------------------------------------------------- */
-NonLinearSolverLinear::~NonLinearSolverLinear() {}
+NonLinearSolverLinear::~NonLinearSolverLinear() = default;
 
 /* ------------------------------------------------------------------------ */
 void NonLinearSolverLinear::solve(SolverCallback & solver_callback) {
   this->dof_manager.updateGlobalBlockedDofs();
 
   solver_callback.predictor();
 
   solver_callback.assembleResidual();
   solver_callback.assembleMatrix("J");
 
   this->solver.solve();
 
   solver_callback.corrector();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/model/non_linear_solver_lumped.cc b/src/model/non_linear_solver_lumped.cc
index a31f41548..30f02ad2e 100644
--- a/src/model/non_linear_solver_lumped.cc
+++ b/src/model/non_linear_solver_lumped.cc
@@ -1,102 +1,102 @@
 /**
  * @file   non_linear_solver_lumped.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Tue Aug 25 00:57:00 2015
  *
  * @brief  Implementation of the default NonLinearSolver
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "non_linear_solver_lumped.hh"
 #include "dof_manager_default.hh"
 #include "solver_callback.hh"
 #include "communicator.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolverLumped::NonLinearSolverLumped(
     DOFManagerDefault & dof_manager,
     const NonLinearSolverType & non_linear_solver_type, const ID & id,
     UInt memory_id)
     : NonLinearSolver(dof_manager, non_linear_solver_type, id, memory_id),
       dof_manager(dof_manager) {
   this->supported_type.insert(_nls_lumped);
   this->checkIfTypeIsSupported();
 
   this->registerParam("b_a2x", this->alpha, 1., _pat_parsmod,
                       "Conversion coefficient between x and A^{-1} b");
 }
 
 /* -------------------------------------------------------------------------- */
-NonLinearSolverLumped::~NonLinearSolverLumped() {}
+NonLinearSolverLumped::~NonLinearSolverLumped() = default;
 
 /* ------------------------------------------------------------------------ */
 void NonLinearSolverLumped::solve(SolverCallback & solver_callback) {
   this->dof_manager.updateGlobalBlockedDofs();
   solver_callback.predictor();
 
   auto & x = this->dof_manager.getGlobalSolution();
   const auto & b = this->dof_manager.getResidual();
 
   x.resize(b.size());
 
   this->dof_manager.updateGlobalBlockedDofs();
   const Array<bool> & blocked_dofs = this->dof_manager.getGlobalBlockedDOFs();
 
   solver_callback.assembleResidual();
 
   const auto & A = this->dof_manager.getLumpedMatrix("M");
   // alpha is the conversion factor from from force/mass to acceleration needed
   // in model coupled with atomistic \todo find a way to define alpha per dof
   // type
 
   this->solveLumped(A, x, b, blocked_dofs, alpha);
   this->dof_manager.splitSolutionPerDOFs();
 
   solver_callback.corrector();
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLinearSolverLumped::solveLumped(const Array<Real> & A, Array<Real> & x,
                                         const Array<Real> & b,
                                         const Array<bool> & blocked_dofs,
                                         Real alpha) {
   auto A_it = A.begin();
   auto x_it = x.begin();
   auto x_end = x.end();
   auto b_it = b.begin();
   auto blocked_it = blocked_dofs.begin();
 
   for (; x_it != x_end; ++x_it, ++b_it, ++A_it, ++blocked_it) {
     if (!(*blocked_it)) {
       *x_it = alpha *(*b_it / *A_it);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/model/non_linear_solver_newton_raphson.cc b/src/model/non_linear_solver_newton_raphson.cc
index 2c4c41af3..57aa6e026 100644
--- a/src/model/non_linear_solver_newton_raphson.cc
+++ b/src/model/non_linear_solver_newton_raphson.cc
@@ -1,185 +1,185 @@
 /**
  * @file   non_linear_solver_newton_raphson.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Tue Aug 25 00:57:00 2015
  *
  * @brief  Implementation of the default NonLinearSolver
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "non_linear_solver_newton_raphson.hh"
 #include "dof_manager_default.hh"
 #include "solver_callback.hh"
 #include "communicator.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolverNewtonRaphson::NonLinearSolverNewtonRaphson(
     DOFManagerDefault & dof_manager,
     const NonLinearSolverType & non_linear_solver_type, const ID & id,
     UInt memory_id)
     : NonLinearSolver(dof_manager, non_linear_solver_type, id, memory_id),
       dof_manager(dof_manager),
       solver(dof_manager, "J", id + ":sparse_solver", memory_id), n_iter(0),
       error(0.), converged(false) {
 
   this->supported_type.insert(_nls_newton_raphson_modified);
   this->supported_type.insert(_nls_newton_raphson);
   this->supported_type.insert(_nls_linear);
 
   this->checkIfTypeIsSupported();
 
   this->registerParam("threshold", convergence_criteria, 1e-10, _pat_parsmod,
                       "Threshold to consider results as converged");
   this->registerParam("convergence_type", convergence_criteria_type,
                       _scc_solution, _pat_parsmod,
                       "Type of convergence criteria");
   this->registerParam("max_iterations", max_iterations, 10, _pat_parsmod,
                       "Max number of iterations");
   this->registerParam("error", error, _pat_readable, "Last reached error");
   this->registerParam("nb_iterations", n_iter, _pat_readable,
                       "Last reached number of iterations");
   this->registerParam("converged", converged, _pat_readable,
                       "Did last solve converged");
   this->registerParam("force_linear_recompute", force_linear_recompute, true,
                       _pat_modifiable,
                       "Force reassembly of the jacobian matrix");
 }
 
 /* -------------------------------------------------------------------------- */
-NonLinearSolverNewtonRaphson::~NonLinearSolverNewtonRaphson() {}
+NonLinearSolverNewtonRaphson::~NonLinearSolverNewtonRaphson() = default;
 
 /* ------------------------------------------------------------------------ */
 void NonLinearSolverNewtonRaphson::solve(SolverCallback & solver_callback) {
   this->dof_manager.updateGlobalBlockedDofs();
 
   solver_callback.predictor();
 
   solver_callback.assembleResidual();
 
   if (this->non_linear_solver_type == _nls_newton_raphson_modified ||
       (this->non_linear_solver_type == _nls_linear &&
        this->force_linear_recompute)) {
     solver_callback.assembleMatrix("J");
     this->force_linear_recompute = false;
   }
 
   this->n_iter = 0;
   this->converged = false;
 
   if (this->convergence_criteria_type == _scc_residual) {
     this->converged = this->testConvergence(this->dof_manager.getResidual());
 
     if (this->converged)
       return;
   }
 
   do {
     if (this->non_linear_solver_type == _nls_newton_raphson)
       solver_callback.assembleMatrix("J");
 
     this->solver.solve();
 
     solver_callback.corrector();
 
     // EventManager::sendEvent(NonLinearSolver::AfterSparseSolve(method));
 
     if (this->convergence_criteria_type == _scc_residual) {
       solver_callback.assembleResidual();
       this->converged = this->testConvergence(this->dof_manager.getResidual());
     } else {
       this->converged =
           this->testConvergence(this->dof_manager.getGlobalSolution());
     }
 
     if (this->convergence_criteria_type == _scc_solution && !this->converged)
       solver_callback.assembleResidual();
     // this->dump();
 
     this->n_iter++;
     AKANTU_DEBUG_INFO(
         "[" << this->convergence_criteria_type << "] Convergence iteration "
             << std::setw(std::log10(this->max_iterations)) << this->n_iter
             << ": error " << this->error << (this->converged ? " < " : " > ")
             << this->convergence_criteria);
 
   } while (!this->converged && this->n_iter < this->max_iterations);
 
   // this makes sure that you have correct strains and stresses after the
   // solveStep function (e.g., for dumping)
   if (this->convergence_criteria_type == _scc_solution)
     solver_callback.assembleResidual();
 
   if (this->converged) {
     // this->sendEvent(NonLinearSolver::ConvergedEvent(method));
   } else if (this->n_iter == this->max_iterations) {
     AKANTU_CUSTOM_EXCEPTION(debug::NLSNotConvergedException(
                                 this->convergence_criteria, this->n_iter, this->error));
 
     AKANTU_DEBUG_WARNING("[" << this->convergence_criteria_type
                              << "] Convergence not reached after "
                              << std::setw(std::log10(this->max_iterations))
                              << this->n_iter << " iteration"
                              << (this->n_iter == 1 ? "" : "s") << "!");
   }
 
   return;
 }
 
 /* -------------------------------------------------------------------------- */
 bool NonLinearSolverNewtonRaphson::testConvergence(const Array<Real> & array) {
   AKANTU_DEBUG_IN();
 
   const Array<bool> & blocked_dofs = this->dof_manager.getGlobalBlockedDOFs();
 
   UInt nb_degree_of_freedoms = array.size();
 
   auto arr_it = array.begin();
   auto bld_it = blocked_dofs.begin();
 
   Real norm = 0.;
   for (UInt n = 0; n < nb_degree_of_freedoms; ++n, ++arr_it, ++bld_it) {
     bool is_local_node = this->dof_manager.isLocalOrMasterDOF(n);
     if ((! *bld_it) && is_local_node) {
       norm += *arr_it * *arr_it;
     }
   }
 
   dof_manager.getCommunicator().allReduce(norm, SynchronizerOperation::_sum);
 
   norm = std::sqrt(norm);
 
   AKANTU_DEBUG_ASSERT(!Math::isnan(norm),
                       "Something went wrong in the solve phase");
 
   this->error = norm;
 
   return (error < this->convergence_criteria);
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/model/solid_mechanics/material.cc b/src/model/solid_mechanics/material.cc
index dd99cdfa8..c08614023 100644
--- a/src/model/solid_mechanics/material.cc
+++ b/src/model/solid_mechanics/material.cc
@@ -1,1606 +1,1588 @@
 /**
  * @file   material.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue Jul 27 2010
  * @date last modification: Tue Nov 24 2015
  *
  * @brief  Implementation of the common part of the material class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "material.hh"
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Material::Material(SolidMechanicsModel & model, const ID & id)
     : Memory(id, model.getMemoryID()), Parsable(_st_material, id),
       is_init(false), fem(model.getFEEngine()), finite_deformation(false),
       name(""), model(model),
       spatial_dimension(this->model.getSpatialDimension()),
       element_filter("element_filter", id, this->memory_id),
       stress("stress", *this), eigengradu("eigen_grad_u", *this),
       gradu("grad_u", *this), green_strain("green_strain", *this),
       piola_kirchhoff_2("piola_kirchhoff_2", *this),
       potential_energy("potential_energy", *this), is_non_local(false),
       use_previous_stress(false), use_previous_gradu(false),
       interpolation_inverse_coordinates("interpolation inverse coordinates",
                                         *this),
       interpolation_points_matrices("interpolation points matrices", *this) {
   AKANTU_DEBUG_IN();
 
   /// for each connectivity types allocate the element filer array of the
   /// material
   element_filter.initialize(model.getMesh(),
                             _spatial_dimension = spatial_dimension);
   // model.getMesh().initElementTypeMapArray(element_filter, 1,
   // spatial_dimension,
   //                                         false, _ek_regular);
 
   this->initialize();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Material::Material(SolidMechanicsModel & model, UInt dim, const Mesh & mesh,
                    FEEngine & fe_engine, const ID & id)
     : Memory(id, model.getMemoryID()), Parsable(_st_material, id),
       is_init(false), fem(model.getFEEngine()), finite_deformation(false),
       name(""), model(model), spatial_dimension(dim),
       element_filter("element_filter", id, this->memory_id),
       stress("stress", *this, dim, fe_engine, this->element_filter),
       eigengradu("eigen_grad_u", *this, dim, fe_engine, this->element_filter),
       gradu("gradu", *this, dim, fe_engine, this->element_filter),
       green_strain("green_strain", *this, dim, fe_engine, this->element_filter),
       piola_kirchhoff_2("poila_kirchhoff_2", *this, dim, fe_engine,
                         this->element_filter),
       potential_energy("potential_energy", *this, dim, fe_engine,
                        this->element_filter),
       is_non_local(false), use_previous_stress(false),
       use_previous_gradu(false),
       interpolation_inverse_coordinates("interpolation inverse_coordinates",
                                         *this, dim, fe_engine,
                                         this->element_filter),
       interpolation_points_matrices("interpolation points matrices", *this, dim,
                                     fe_engine, this->element_filter) {
 
   AKANTU_DEBUG_IN();
   element_filter.initialize(mesh, _spatial_dimension = spatial_dimension);
   // mesh.initElementTypeMapArray(element_filter, 1, spatial_dimension, false,
   //                              _ek_regular);
 
   this->initialize();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Material::~Material() = default;
 
 /* -------------------------------------------------------------------------- */
 void Material::initialize() {
   registerParam("rho", rho, Real(0.), _pat_parsable | _pat_modifiable,
                 "Density");
   registerParam("name", name, std::string(), _pat_parsable | _pat_readable);
   registerParam("finite_deformation", finite_deformation, false,
                 _pat_parsable | _pat_readable, "Is finite deformation");
   registerParam("inelastic_deformation", inelastic_deformation, false,
                 _pat_internal, "Is inelastic deformation");
 
   /// allocate gradu stress for local elements
   eigengradu.initialize(spatial_dimension * spatial_dimension);
   gradu.initialize(spatial_dimension * spatial_dimension);
   stress.initialize(spatial_dimension * spatial_dimension);
 
   potential_energy.initialize(1);
 
   this->model.registerEventHandler(*this);
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::initMaterial() {
   AKANTU_DEBUG_IN();
 
   if (finite_deformation) {
     this->piola_kirchhoff_2.initialize(spatial_dimension * spatial_dimension);
     if (use_previous_stress)
       this->piola_kirchhoff_2.initializeHistory();
     this->green_strain.initialize(spatial_dimension * spatial_dimension);
   }
 
   if (use_previous_stress)
     this->stress.initializeHistory();
   if (use_previous_gradu)
     this->gradu.initializeHistory();
 
-  for (std::map<ID, InternalField<Real> *>::iterator it =
-           internal_vectors_real.begin();
+  for (auto it = internal_vectors_real.begin();
        it != internal_vectors_real.end(); ++it)
     it->second->resize();
 
-  for (std::map<ID, InternalField<UInt> *>::iterator it =
-           internal_vectors_uint.begin();
+  for (auto it = internal_vectors_uint.begin();
        it != internal_vectors_uint.end(); ++it)
     it->second->resize();
 
-  for (std::map<ID, InternalField<bool> *>::iterator it =
-           internal_vectors_bool.begin();
+  for (auto it = internal_vectors_bool.begin();
        it != internal_vectors_bool.end(); ++it)
     it->second->resize();
 
   is_init = true;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::savePreviousState() {
   AKANTU_DEBUG_IN();
 
-  for (std::map<ID, InternalField<Real> *>::iterator it =
-           internal_vectors_real.begin();
+  for (auto it = internal_vectors_real.begin();
        it != internal_vectors_real.end(); ++it) {
     if (it->second->hasHistory())
       it->second->saveCurrentValues();
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Compute  the  residual  by  assembling  @f$\int_{e}  \sigma_e  \frac{\partial
  * \varphi}{\partial X} dX @f$
  *
  * @param[in] displacements nodes displacements
  * @param[in] ghost_type compute the residual for _ghost or _not_ghost element
  */
 // void Material::updateResidual(GhostType ghost_type) {
 //   AKANTU_DEBUG_IN();
 
 //   computeAllStresses(ghost_type);
 //   assembleResidual(ghost_type);
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 void Material::assembleInternalForces(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   if (!finite_deformation) {
 
-    Array<Real> & internal_force =
-        const_cast<Array<Real> &>(model.getInternalForce());
+    auto & internal_force = const_cast<Array<Real> &>(model.getInternalForce());
 
     Mesh & mesh = fem.getMesh();
     Mesh::type_iterator it =
         element_filter.firstType(spatial_dimension, ghost_type);
     Mesh::type_iterator last_type =
         element_filter.lastType(spatial_dimension, ghost_type);
     for (; it != last_type; ++it) {
       Array<UInt> & elem_filter = element_filter(*it, ghost_type);
       UInt nb_element = elem_filter.size();
       if (nb_element) {
         const Array<Real> & shapes_derivatives =
             fem.getShapesDerivatives(*it, ghost_type);
 
         UInt size_of_shapes_derivatives = shapes_derivatives.getNbComponent();
         UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(*it);
         UInt nb_quadrature_points = fem.getNbIntegrationPoints(*it, ghost_type);
 
         /// compute @f$\sigma \frac{\partial \varphi}{\partial X}@f$ by
         /// @f$\mathbf{B}^t \mathbf{\sigma}_q@f$
         Array<Real> * sigma_dphi_dx =
             new Array<Real>(nb_element * nb_quadrature_points,
                             size_of_shapes_derivatives, "sigma_x_dphi_/_dX");
 
         Array<Real> * shapesd_filtered =
             new Array<Real>(0, size_of_shapes_derivatives, "filtered shapesd");
 
         FEEngine::filterElementalData(mesh, shapes_derivatives,
                                       *shapesd_filtered, *it, ghost_type,
                                       elem_filter);
 
         Array<Real> & stress_vect = this->stress(*it, ghost_type);
 
         Array<Real>::matrix_iterator sigma =
             stress_vect.begin(spatial_dimension, spatial_dimension);
         Array<Real>::matrix_iterator B =
             shapesd_filtered->begin(spatial_dimension, nb_nodes_per_element);
         Array<Real>::matrix_iterator Bt_sigma_it =
             sigma_dphi_dx->begin(spatial_dimension, nb_nodes_per_element);
 
         for (UInt q = 0; q < nb_element * nb_quadrature_points;
              ++q, ++sigma, ++B, ++Bt_sigma_it)
           Bt_sigma_it->mul<false, false>(*sigma, *B);
 
         delete shapesd_filtered;
 
         /**
          * compute @f$\int \sigma  * \frac{\partial \varphi}{\partial X}dX@f$ by
          * @f$ \sum_q \mathbf{B}^t
          * \mathbf{\sigma}_q \overline w_q J_q@f$
          */
         Array<Real> * int_sigma_dphi_dx = new Array<Real>(
             nb_element, nb_nodes_per_element * spatial_dimension,
             "int_sigma_x_dphi_/_dX");
 
         fem.integrate(*sigma_dphi_dx, *int_sigma_dphi_dx,
                       size_of_shapes_derivatives, *it, ghost_type, elem_filter);
         delete sigma_dphi_dx;
 
         /// assemble
         model.getDOFManager().assembleElementalArrayLocalArray(
             *int_sigma_dphi_dx, internal_force, *it, ghost_type, -1,
             elem_filter);
         delete int_sigma_dphi_dx;
       }
     }
   } else {
     switch (spatial_dimension) {
     case 1:
       this->assembleInternalForces<1>(ghost_type);
       break;
     case 2:
       this->assembleInternalForces<2>(ghost_type);
       break;
     case 3:
       this->assembleInternalForces<3>(ghost_type);
       break;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Compute  the  stress from the gradu
  *
  * @param[in] current_position nodes postition + displacements
  * @param[in] ghost_type compute the residual for _ghost or _not_ghost element
  */
 void Material::computeAllStresses(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   for (const auto & type :
        element_filter.elementTypes(spatial_dimension, ghost_type)) {
     Array<UInt> & elem_filter = element_filter(type, ghost_type);
 
     if (elem_filter.size() == 0)
       continue;
     Array<Real> & gradu_vect = gradu(type, ghost_type);
 
     /// compute @f$\nabla u@f$
     fem.gradientOnIntegrationPoints(model.getDisplacement(), gradu_vect,
                                     spatial_dimension, type, ghost_type,
                                     elem_filter);
 
     gradu_vect -= eigengradu(type, ghost_type);
 
     /// compute @f$\mathbf{\sigma}_q@f$ from @f$\nabla u@f$
     computeStress(type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::computeAllCauchyStresses(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(finite_deformation, "The Cauchy stress can only be "
                                           "computed if you are working in "
                                           "finite deformation.");
 
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     switch (spatial_dimension) {
     case 1:
       this->computeCauchyStress<1>(type, ghost_type);
       break;
     case 2:
       this->computeCauchyStress<2>(type, ghost_type);
       break;
     case 3:
       this->computeCauchyStress<3>(type, ghost_type);
       break;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::computeCauchyStress(ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Array<Real>::matrix_iterator gradu_it =
       this->gradu(el_type, ghost_type).begin(dim, dim);
 
   Array<Real>::matrix_iterator gradu_end =
       this->gradu(el_type, ghost_type).end(dim, dim);
 
   Array<Real>::matrix_iterator piola_it =
       this->piola_kirchhoff_2(el_type, ghost_type).begin(dim, dim);
 
   Array<Real>::matrix_iterator stress_it =
       this->stress(el_type, ghost_type).begin(dim, dim);
 
   Matrix<Real> F_tensor(dim, dim);
 
   for (; gradu_it != gradu_end; ++gradu_it, ++piola_it, ++stress_it) {
     Matrix<Real> & grad_u = *gradu_it;
     Matrix<Real> & piola = *piola_it;
     Matrix<Real> & sigma = *stress_it;
 
     gradUToF<dim>(grad_u, F_tensor);
     this->computeCauchyStressOnQuad<dim>(F_tensor, piola, sigma);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::setToSteadyState(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   const Array<Real> & displacement = model.getDisplacement();
 
   // resizeInternalArray(gradu);
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     Array<UInt> & elem_filter = element_filter(type, ghost_type);
     Array<Real> & gradu_vect = gradu(type, ghost_type);
 
     /// compute @f$\nabla u@f$
     fem.gradientOnIntegrationPoints(displacement, gradu_vect, spatial_dimension,
                                     type, ghost_type, elem_filter);
 
     setToSteadyState(type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Compute  the stiffness  matrix by  assembling @f$\int_{\omega}  B^t  \times D
  * \times B d\omega @f$
  *
  * @param[in] current_position nodes postition + displacements
  * @param[in] ghost_type compute the residual for _ghost or _not_ghost element
  */
 void Material::assembleStiffnessMatrix(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     if (finite_deformation) {
       switch (spatial_dimension) {
       case 1: {
         assembleStiffnessMatrixNL<1>(type, ghost_type);
         assembleStiffnessMatrixL2<1>(type, ghost_type);
         break;
       }
       case 2: {
         assembleStiffnessMatrixNL<2>(type, ghost_type);
         assembleStiffnessMatrixL2<2>(type, ghost_type);
         break;
       }
       case 3: {
         assembleStiffnessMatrixNL<3>(type, ghost_type);
         assembleStiffnessMatrixL2<3>(type, ghost_type);
         break;
       }
       }
     } else {
       switch (spatial_dimension) {
       case 1: {
         assembleStiffnessMatrix<1>(type, ghost_type);
         break;
       }
       case 2: {
         assembleStiffnessMatrix<2>(type, ghost_type);
         break;
       }
       case 3: {
         assembleStiffnessMatrix<3>(type, ghost_type);
         break;
       }
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::assembleStiffnessMatrix(const ElementType & type,
                                        GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Array<UInt> & elem_filter = element_filter(type, ghost_type);
   if (elem_filter.size()) {
 
     const Array<Real> & shapes_derivatives =
         fem.getShapesDerivatives(type, ghost_type);
 
     Array<Real> & gradu_vect = gradu(type, ghost_type);
 
     UInt nb_element = elem_filter.size();
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
     UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
     gradu_vect.resize(nb_quadrature_points * nb_element);
 
     fem.gradientOnIntegrationPoints(model.getDisplacement(), gradu_vect, dim,
                                     type, ghost_type, elem_filter);
 
     UInt tangent_size = getTangentStiffnessVoigtSize(dim);
 
     Array<Real> * tangent_stiffness_matrix = new Array<Real>(
         nb_element * nb_quadrature_points, tangent_size * tangent_size,
         "tangent_stiffness_matrix");
 
     tangent_stiffness_matrix->clear();
 
     computeTangentModuli(type, *tangent_stiffness_matrix, ghost_type);
 
     Array<Real> * shapesd_filtered = new Array<Real>(
         nb_element, dim * nb_nodes_per_element, "filtered shapesd");
 
     FEEngine::filterElementalData(fem.getMesh(), shapes_derivatives,
                                   *shapesd_filtered, type, ghost_type,
                                   elem_filter);
 
     /// compute @f$\mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
     UInt bt_d_b_size = dim * nb_nodes_per_element;
 
     Array<Real> * bt_d_b =
         new Array<Real>(nb_element * nb_quadrature_points,
                         bt_d_b_size * bt_d_b_size, "B^t*D*B");
 
     Matrix<Real> B(tangent_size, dim * nb_nodes_per_element);
     Matrix<Real> Bt_D(dim * nb_nodes_per_element, tangent_size);
 
     Array<Real>::matrix_iterator shapes_derivatives_filtered_it =
         shapesd_filtered->begin(dim, nb_nodes_per_element);
 
     Array<Real>::matrix_iterator Bt_D_B_it =
         bt_d_b->begin(dim * nb_nodes_per_element, dim * nb_nodes_per_element);
 
     Array<Real>::matrix_iterator D_it =
         tangent_stiffness_matrix->begin(tangent_size, tangent_size);
 
     Array<Real>::matrix_iterator D_end =
         tangent_stiffness_matrix->end(tangent_size, tangent_size);
 
     for (; D_it != D_end;
          ++D_it, ++Bt_D_B_it, ++shapes_derivatives_filtered_it) {
       Matrix<Real> & D = *D_it;
       Matrix<Real> & Bt_D_B = *Bt_D_B_it;
 
       VoigtHelper<dim>::transferBMatrixToSymVoigtBMatrix(
           *shapes_derivatives_filtered_it, B, nb_nodes_per_element);
       Bt_D.mul<true, false>(B, D);
       Bt_D_B.mul<false, false>(Bt_D, B);
     }
 
     delete tangent_stiffness_matrix;
     delete shapesd_filtered;
 
     /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
     Array<Real> * K_e =
         new Array<Real>(nb_element, bt_d_b_size * bt_d_b_size, "K_e");
 
     fem.integrate(*bt_d_b, *K_e, bt_d_b_size * bt_d_b_size, type, ghost_type,
                   elem_filter);
 
     delete bt_d_b;
 
     model.getDOFManager().assembleElementalMatricesToMatrix(
         "K", "displacement", *K_e, type, ghost_type, _symmetric, elem_filter);
     delete K_e;
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::assembleStiffnessMatrixNL(const ElementType & type,
                                          GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   const Array<Real> & shapes_derivatives =
       fem.getShapesDerivatives(type, ghost_type);
 
   Array<UInt> & elem_filter = element_filter(type, ghost_type);
   // Array<Real> & gradu_vect = delta_gradu(type, ghost_type);
 
   UInt nb_element = elem_filter.size();
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
   // gradu_vect.resize(nb_quadrature_points * nb_element);
 
   // fem.gradientOnIntegrationPoints(model.getIncrement(), gradu_vect,
   //        dim, type, ghost_type, &elem_filter);
 
   Array<Real> * shapes_derivatives_filtered = new Array<Real>(
       nb_element * nb_quadrature_points, dim * nb_nodes_per_element,
       "shapes derivatives filtered");
 
   Array<Real>::const_matrix_iterator shapes_derivatives_it =
       shapes_derivatives.begin(spatial_dimension, nb_nodes_per_element);
 
   Array<Real>::matrix_iterator shapes_derivatives_filtered_it =
       shapes_derivatives_filtered->begin(spatial_dimension,
                                          nb_nodes_per_element);
   UInt * elem_filter_val = elem_filter.storage();
   for (UInt e = 0; e < nb_element; ++e, ++elem_filter_val)
     for (UInt q = 0; q < nb_quadrature_points;
          ++q, ++shapes_derivatives_filtered_it)
       *shapes_derivatives_filtered_it =
           shapes_derivatives_it[*elem_filter_val * nb_quadrature_points + q];
 
   /// compute @f$\mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   UInt bt_s_b_size = dim * nb_nodes_per_element;
 
   Array<Real> * bt_s_b = new Array<Real>(nb_element * nb_quadrature_points,
                                          bt_s_b_size * bt_s_b_size, "B^t*D*B");
 
   UInt piola_matrix_size = getCauchyStressMatrixSize(dim);
 
   Matrix<Real> B(piola_matrix_size, bt_s_b_size);
   Matrix<Real> Bt_S(bt_s_b_size, piola_matrix_size);
   Matrix<Real> S(piola_matrix_size, piola_matrix_size);
 
   shapes_derivatives_filtered_it = shapes_derivatives_filtered->begin(
       spatial_dimension, nb_nodes_per_element);
 
   Array<Real>::matrix_iterator Bt_S_B_it =
       bt_s_b->begin(bt_s_b_size, bt_s_b_size);
   Array<Real>::matrix_iterator Bt_S_B_end =
       bt_s_b->end(bt_s_b_size, bt_s_b_size);
 
   Array<Real>::matrix_iterator piola_it =
       piola_kirchhoff_2(type, ghost_type).begin(dim, dim);
 
   for (; Bt_S_B_it != Bt_S_B_end;
        ++Bt_S_B_it, ++shapes_derivatives_filtered_it, ++piola_it) {
     Matrix<Real> & Bt_S_B = *Bt_S_B_it;
     Matrix<Real> & Piola_kirchhoff_matrix = *piola_it;
 
     setCauchyStressMatrix<dim>(Piola_kirchhoff_matrix, S);
     VoigtHelper<dim>::transferBMatrixToBNL(*shapes_derivatives_filtered_it, B,
                                            nb_nodes_per_element);
     Bt_S.mul<true, false>(B, S);
     Bt_S_B.mul<false, false>(Bt_S, B);
   }
 
   delete shapes_derivatives_filtered;
 
   /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   Array<Real> * K_e =
       new Array<Real>(nb_element, bt_s_b_size * bt_s_b_size, "K_e");
 
   fem.integrate(*bt_s_b, *K_e, bt_s_b_size * bt_s_b_size, type, ghost_type,
                 elem_filter);
 
   delete bt_s_b;
 
   model.getDOFManager().assembleElementalMatricesToMatrix(
       "K", "displacement", *K_e, type, ghost_type, _symmetric, elem_filter);
 
   delete K_e;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::assembleStiffnessMatrixL2(const ElementType & type,
                                          GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   const Array<Real> & shapes_derivatives =
       fem.getShapesDerivatives(type, ghost_type);
 
   Array<UInt> & elem_filter = element_filter(type, ghost_type);
   Array<Real> & gradu_vect = gradu(type, ghost_type);
 
   UInt nb_element = elem_filter.size();
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
   gradu_vect.resize(nb_quadrature_points * nb_element);
 
   fem.gradientOnIntegrationPoints(model.getDisplacement(), gradu_vect, dim,
                                   type, ghost_type, elem_filter);
 
   UInt tangent_size = getTangentStiffnessVoigtSize(dim);
 
   Array<Real> * tangent_stiffness_matrix =
       new Array<Real>(nb_element * nb_quadrature_points,
                       tangent_size * tangent_size, "tangent_stiffness_matrix");
 
   tangent_stiffness_matrix->clear();
 
   computeTangentModuli(type, *tangent_stiffness_matrix, ghost_type);
 
   Array<Real> * shapes_derivatives_filtered = new Array<Real>(
       nb_element * nb_quadrature_points, dim * nb_nodes_per_element,
       "shapes derivatives filtered");
 
   Array<Real>::const_matrix_iterator shapes_derivatives_it =
       shapes_derivatives.begin(spatial_dimension, nb_nodes_per_element);
 
   Array<Real>::matrix_iterator shapes_derivatives_filtered_it =
       shapes_derivatives_filtered->begin(spatial_dimension,
                                          nb_nodes_per_element);
   UInt * elem_filter_val = elem_filter.storage();
   for (UInt e = 0; e < nb_element; ++e, ++elem_filter_val)
     for (UInt q = 0; q < nb_quadrature_points;
          ++q, ++shapes_derivatives_filtered_it)
       *shapes_derivatives_filtered_it =
           shapes_derivatives_it[*elem_filter_val * nb_quadrature_points + q];
 
   /// compute @f$\mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   UInt bt_d_b_size = dim * nb_nodes_per_element;
 
   Array<Real> * bt_d_b = new Array<Real>(nb_element * nb_quadrature_points,
                                          bt_d_b_size * bt_d_b_size, "B^t*D*B");
 
   Matrix<Real> B(tangent_size, dim * nb_nodes_per_element);
   Matrix<Real> B2(tangent_size, dim * nb_nodes_per_element);
   Matrix<Real> Bt_D(dim * nb_nodes_per_element, tangent_size);
 
   shapes_derivatives_filtered_it = shapes_derivatives_filtered->begin(
       spatial_dimension, nb_nodes_per_element);
 
   Array<Real>::matrix_iterator Bt_D_B_it =
       bt_d_b->begin(dim * nb_nodes_per_element, dim * nb_nodes_per_element);
 
   Array<Real>::matrix_iterator grad_u_it = gradu_vect.begin(dim, dim);
 
   Array<Real>::matrix_iterator D_it =
       tangent_stiffness_matrix->begin(tangent_size, tangent_size);
   Array<Real>::matrix_iterator D_end =
       tangent_stiffness_matrix->end(tangent_size, tangent_size);
 
   for (; D_it != D_end;
        ++D_it, ++Bt_D_B_it, ++shapes_derivatives_filtered_it, ++grad_u_it) {
     Matrix<Real> & grad_u = *grad_u_it;
     Matrix<Real> & D = *D_it;
     Matrix<Real> & Bt_D_B = *Bt_D_B_it;
 
     // transferBMatrixToBL1<dim > (*shapes_derivatives_filtered_it, B,
     // nb_nodes_per_element);
     VoigtHelper<dim>::transferBMatrixToSymVoigtBMatrix(
         *shapes_derivatives_filtered_it, B, nb_nodes_per_element);
     VoigtHelper<dim>::transferBMatrixToBL2(*shapes_derivatives_filtered_it,
                                            grad_u, B2, nb_nodes_per_element);
     B += B2;
     Bt_D.mul<true, false>(B, D);
     Bt_D_B.mul<false, false>(Bt_D, B);
   }
 
   delete tangent_stiffness_matrix;
   delete shapes_derivatives_filtered;
 
   /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   Array<Real> * K_e =
       new Array<Real>(nb_element, bt_d_b_size * bt_d_b_size, "K_e");
 
   fem.integrate(*bt_d_b, *K_e, bt_d_b_size * bt_d_b_size, type, ghost_type,
                 elem_filter);
 
   delete bt_d_b;
 
   model.getDOFManager().assembleElementalMatricesToMatrix(
       "K", "displacement", *K_e, type, ghost_type, _symmetric, elem_filter);
   delete K_e;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::assembleInternalForces(GhostType ghost_type) {
 
   AKANTU_DEBUG_IN();
 
   Array<Real> & internal_force = model.getInternalForce();
 
   Mesh & mesh = fem.getMesh();
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     const Array<Real> & shapes_derivatives =
         fem.getShapesDerivatives(type, ghost_type);
 
     Array<UInt> & elem_filter = element_filter(type, ghost_type);
     if (elem_filter.size() == 0)
       continue;
     UInt size_of_shapes_derivatives = shapes_derivatives.getNbComponent();
     UInt nb_element = elem_filter.size();
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
     UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
     Array<Real> * shapesd_filtered = new Array<Real>(
         nb_element, size_of_shapes_derivatives, "filtered shapesd");
 
     FEEngine::filterElementalData(mesh, shapes_derivatives, *shapesd_filtered,
                                   type, ghost_type, elem_filter);
 
     Array<Real>::matrix_iterator shapes_derivatives_filtered_it =
         shapesd_filtered->begin(dim, nb_nodes_per_element);
 
     // Set stress vectors
 
     UInt stress_size = getTangentStiffnessVoigtSize(dim);
 
     // Set matrices B and BNL*
     UInt bt_s_size = dim * nb_nodes_per_element;
 
     Array<Real> * bt_s =
         new Array<Real>(nb_element * nb_quadrature_points, bt_s_size, "B^t*S");
 
     Array<Real>::matrix_iterator grad_u_it =
         this->gradu(type, ghost_type).begin(dim, dim);
 
     Array<Real>::matrix_iterator grad_u_end =
         this->gradu(type, ghost_type).end(dim, dim);
 
     Array<Real>::matrix_iterator stress_it =
         this->piola_kirchhoff_2(type, ghost_type).begin(dim, dim);
 
     shapes_derivatives_filtered_it =
         shapesd_filtered->begin(dim, nb_nodes_per_element);
 
     Array<Real>::matrix_iterator bt_s_it = bt_s->begin(bt_s_size, 1);
 
     Matrix<Real> S_vect(stress_size, 1);
     Matrix<Real> B_tensor(stress_size, bt_s_size);
     Matrix<Real> B2_tensor(stress_size, bt_s_size);
 
     for (; grad_u_it != grad_u_end; ++grad_u_it, ++stress_it,
                                     ++shapes_derivatives_filtered_it,
                                     ++bt_s_it) {
       Matrix<Real> & grad_u = *grad_u_it;
       Matrix<Real> & r_it = *bt_s_it;
       Matrix<Real> & S_it = *stress_it;
 
       setCauchyStressArray<dim>(S_it, S_vect);
       VoigtHelper<dim>::transferBMatrixToSymVoigtBMatrix(
           *shapes_derivatives_filtered_it, B_tensor, nb_nodes_per_element);
       VoigtHelper<dim>::transferBMatrixToBL2(*shapes_derivatives_filtered_it,
                                              grad_u, B2_tensor,
                                              nb_nodes_per_element);
 
       B_tensor += B2_tensor;
 
       r_it.mul<true, false>(B_tensor, S_vect);
     }
 
     delete shapesd_filtered;
 
     /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
     Array<Real> * r_e = new Array<Real>(nb_element, bt_s_size, "r_e");
 
     fem.integrate(*bt_s, *r_e, bt_s_size, type, ghost_type, elem_filter);
 
     delete bt_s;
 
     model.getDOFManager().assembleElementalArrayLocalArray(
         *r_e, internal_force, type, ghost_type, -1., elem_filter);
     delete r_e;
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::computeAllStressesFromTangentModuli(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     switch (spatial_dimension) {
     case 1: {
       computeAllStressesFromTangentModuli<1>(type, ghost_type);
       break;
     }
     case 2: {
       computeAllStressesFromTangentModuli<2>(type, ghost_type);
       break;
     }
     case 3: {
       computeAllStressesFromTangentModuli<3>(type, ghost_type);
       break;
     }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::computeAllStressesFromTangentModuli(const ElementType & type,
                                                    GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   const Array<Real> & shapes_derivatives =
       fem.getShapesDerivatives(type, ghost_type);
   Array<UInt> & elem_filter = element_filter(type, ghost_type);
   Array<Real> & gradu_vect = gradu(type, ghost_type);
 
   UInt nb_element = elem_filter.size();
   if (nb_element) {
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
     UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
     gradu_vect.resize(nb_quadrature_points * nb_element);
 
     Array<Real> & disp = model.getDisplacement();
 
     fem.gradientOnIntegrationPoints(disp, gradu_vect, dim, type, ghost_type,
                                     elem_filter);
 
     UInt tangent_moduli_size = getTangentStiffnessVoigtSize(dim);
 
     Array<Real> * tangent_moduli_tensors = new Array<Real>(
         nb_element * nb_quadrature_points,
         tangent_moduli_size * tangent_moduli_size, "tangent_moduli_tensors");
 
     tangent_moduli_tensors->clear();
     computeTangentModuli(type, *tangent_moduli_tensors, ghost_type);
 
     Array<Real> * shapesd_filtered = new Array<Real>(
         nb_element, dim * nb_nodes_per_element, "filtered shapesd");
 
     FEEngine::filterElementalData(fem.getMesh(), shapes_derivatives,
                                   *shapesd_filtered, type, ghost_type,
                                   elem_filter);
 
     Array<Real> filtered_u(nb_element,
                            nb_nodes_per_element * spatial_dimension);
 
     FEEngine::extractNodalToElementField(fem.getMesh(), disp, filtered_u, type,
                                          ghost_type, elem_filter);
 
     /// compute @f$\mathbf{D} \mathbf{B} \mathbf{u}@f$
     Array<Real>::matrix_iterator shapes_derivatives_filtered_it =
         shapesd_filtered->begin(dim, nb_nodes_per_element);
 
     Array<Real>::matrix_iterator D_it =
         tangent_moduli_tensors->begin(tangent_moduli_size, tangent_moduli_size);
     Array<Real>::matrix_iterator sigma_it =
         stress(type, ghost_type).begin(spatial_dimension, spatial_dimension);
     Array<Real>::vector_iterator u_it =
         filtered_u.begin(spatial_dimension * nb_nodes_per_element);
 
     Matrix<Real> B(tangent_moduli_size,
                    spatial_dimension * nb_nodes_per_element);
     Vector<Real> Bu(tangent_moduli_size);
     Vector<Real> DBu(tangent_moduli_size);
 
     for (UInt e = 0; e < nb_element; ++e, ++u_it) {
       for (UInt q = 0; q < nb_quadrature_points;
            ++q, ++D_it, ++shapes_derivatives_filtered_it, ++sigma_it) {
         Vector<Real> & u = *u_it;
         Matrix<Real> & sigma = *sigma_it;
         Matrix<Real> & D = *D_it;
 
         VoigtHelper<dim>::transferBMatrixToSymVoigtBMatrix(
             *shapes_derivatives_filtered_it, B, nb_nodes_per_element);
 
         Bu.mul<false>(B, u);
         DBu.mul<false>(D, Bu);
 
         // Voigt notation to full symmetric tensor
         for (UInt i = 0; i < dim; ++i)
           sigma(i, i) = DBu(i);
         if (dim == 2) {
           sigma(0, 1) = sigma(1, 0) = DBu(2);
         } else if (dim == 3) {
           sigma(1, 2) = sigma(2, 1) = DBu(3);
           sigma(0, 2) = sigma(2, 0) = DBu(4);
           sigma(0, 1) = sigma(1, 0) = DBu(5);
         }
       }
     }
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::computePotentialEnergyByElements() {
   AKANTU_DEBUG_IN();
 
   for (auto type : element_filter.elementTypes(spatial_dimension, _not_ghost)) {
     computePotentialEnergy(type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::computePotentialEnergy(ElementType, GhostType) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Real Material::getPotentialEnergy() {
   AKANTU_DEBUG_IN();
   Real epot = 0.;
 
   computePotentialEnergyByElements();
 
   /// integrate the potential energy for each type of elements
   for (auto type : element_filter.elementTypes(spatial_dimension, _not_ghost)) {
     epot += fem.integrate(potential_energy(type, _not_ghost), type, _not_ghost,
                           element_filter(type, _not_ghost));
   }
 
   AKANTU_DEBUG_OUT();
   return epot;
 }
 
 /* -------------------------------------------------------------------------- */
 Real Material::getPotentialEnergy(ElementType & type, UInt index) {
   AKANTU_DEBUG_IN();
   Real epot = 0.;
 
   Vector<Real> epot_on_quad_points(fem.getNbIntegrationPoints(type));
 
   computePotentialEnergyByElement(type, index, epot_on_quad_points);
 
   epot = fem.integrate(epot_on_quad_points, type, element_filter(type)(index));
 
   AKANTU_DEBUG_OUT();
   return epot;
 }
 
 /* -------------------------------------------------------------------------- */
 Real Material::getEnergy(std::string type) {
   AKANTU_DEBUG_IN();
   if (type == "potential")
     return getPotentialEnergy();
   AKANTU_DEBUG_OUT();
   return 0.;
 }
 
 /* -------------------------------------------------------------------------- */
 Real Material::getEnergy(std::string energy_id, ElementType type, UInt index) {
   AKANTU_DEBUG_IN();
   if (energy_id == "potential")
     return getPotentialEnergy(type, index);
   AKANTU_DEBUG_OUT();
   return 0.;
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::initElementalFieldInterpolation(
     const ElementTypeMapArray<Real> & interpolation_points_coordinates) {
   AKANTU_DEBUG_IN();
 
   this->fem.initElementalFieldInterpolationFromIntegrationPoints(
       interpolation_points_coordinates, this->interpolation_points_matrices,
       this->interpolation_inverse_coordinates, &(this->element_filter));
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::interpolateStress(ElementTypeMapArray<Real> & result,
                                  const GhostType ghost_type) {
 
   this->fem.interpolateElementalFieldFromIntegrationPoints(
       this->stress, this->interpolation_points_matrices,
       this->interpolation_inverse_coordinates, result, ghost_type,
       &(this->element_filter));
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::interpolateStressOnFacets(
     ElementTypeMapArray<Real> & result,
     ElementTypeMapArray<Real> & by_elem_result, const GhostType ghost_type) {
 
   interpolateStress(by_elem_result, ghost_type);
 
   UInt stress_size = this->stress.getNbComponent();
 
   const Mesh & mesh = this->model.getMesh();
   const Mesh & mesh_facets = mesh.getMeshFacets();
 
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     Array<UInt> & elem_fil = element_filter(type, ghost_type);
     Array<Real> & by_elem_res = by_elem_result(type, ghost_type);
     UInt nb_element = elem_fil.size();
     UInt nb_element_full = this->model.getMesh().getNbElement(type, ghost_type);
     UInt nb_interpolation_points_per_elem =
         by_elem_res.size() / nb_element_full;
 
     const Array<Element> & facet_to_element =
         mesh_facets.getSubelementToElement(type, ghost_type);
     ElementType type_facet = Mesh::getFacetType(type);
     UInt nb_facet_per_elem = facet_to_element.getNbComponent();
     UInt nb_quad_per_facet =
         nb_interpolation_points_per_elem / nb_facet_per_elem;
     Element element_for_comparison{type, 0, ghost_type};
     const Array<std::vector<Element>> * element_to_facet = nullptr;
     GhostType current_ghost_type = _casper;
     Array<Real> * result_vec = nullptr;
 
     Array<Real>::const_matrix_iterator result_it =
         by_elem_res.begin_reinterpret(
             stress_size, nb_interpolation_points_per_elem, nb_element_full);
 
     for (UInt el = 0; el < nb_element; ++el) {
       UInt global_el = elem_fil(el);
       element_for_comparison.element = global_el;
       for (UInt f = 0; f < nb_facet_per_elem; ++f) {
 
         Element facet_elem = facet_to_element(global_el, f);
         UInt global_facet = facet_elem.element;
         if (facet_elem.ghost_type != current_ghost_type) {
           current_ghost_type = facet_elem.ghost_type;
           element_to_facet = &mesh_facets.getElementToSubelement(
               type_facet, current_ghost_type);
           result_vec = &result(type_facet, current_ghost_type);
         }
 
         bool is_second_element =
             (*element_to_facet)(global_facet)[0] != element_for_comparison;
 
         for (UInt q = 0; q < nb_quad_per_facet; ++q) {
           Vector<Real> result_local(result_vec->storage() +
                                         (global_facet * nb_quad_per_facet + q) *
                                             result_vec->getNbComponent() +
                                         is_second_element * stress_size,
                                     stress_size);
 
           const Matrix<Real> & result_tmp(result_it[global_el]);
           result_local = result_tmp(f * nb_quad_per_facet + q);
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 const Array<T> &
 Material::getArray(__attribute__((unused)) const ID & vect_id,
                    __attribute__((unused)) const ElementType & type,
                    __attribute__((unused)) const GhostType & ghost_type) const {
   AKANTU_DEBUG_TO_IMPLEMENT();
   return NULL;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 Array<T> & Material::getArray(__attribute__((unused)) const ID & vect_id,
                               __attribute__((unused)) const ElementType & type,
                               __attribute__((unused))
                               const GhostType & ghost_type) {
   AKANTU_DEBUG_TO_IMPLEMENT();
   return NULL;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 const Array<Real> & Material::getArray(const ID & vect_id,
                                        const ElementType & type,
                                        const GhostType & ghost_type) const {
   std::stringstream sstr;
   std::string ghost_id = "";
   if (ghost_type == _ghost)
     ghost_id = ":ghost";
   sstr << getID() << ":" << vect_id << ":" << type << ghost_id;
 
   ID fvect_id = sstr.str();
   try {
     return Memory::getArray<Real>(fvect_id);
   } catch (debug::Exception & e) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain a vector "
                                             << vect_id << "(" << fvect_id
                                             << ") [" << e << "]");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 Array<Real> & Material::getArray(const ID & vect_id, const ElementType & type,
                                  const GhostType & ghost_type) {
   std::stringstream sstr;
   std::string ghost_id = "";
   if (ghost_type == _ghost)
     ghost_id = ":ghost";
   sstr << getID() << ":" << vect_id << ":" << type << ghost_id;
 
   ID fvect_id = sstr.str();
   try {
     return Memory::getArray<Real>(fvect_id);
   } catch (debug::Exception & e) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain a vector "
                                             << vect_id << "(" << fvect_id
                                             << ") [" << e << "]");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 const Array<UInt> & Material::getArray(const ID & vect_id,
                                        const ElementType & type,
                                        const GhostType & ghost_type) const {
   std::stringstream sstr;
   std::string ghost_id = "";
   if (ghost_type == _ghost)
     ghost_id = ":ghost";
   sstr << getID() << ":" << vect_id << ":" << type << ghost_id;
 
   ID fvect_id = sstr.str();
   try {
     return Memory::getArray<UInt>(fvect_id);
   } catch (debug::Exception & e) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain a vector "
                                             << vect_id << "(" << fvect_id
                                             << ") [" << e << "]");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 Array<UInt> & Material::getArray(const ID & vect_id, const ElementType & type,
                                  const GhostType & ghost_type) {
   std::stringstream sstr;
   std::string ghost_id = "";
   if (ghost_type == _ghost)
     ghost_id = ":ghost";
   sstr << getID() << ":" << vect_id << ":" << type << ghost_id;
 
   ID fvect_id = sstr.str();
   try {
     return Memory::getArray<UInt>(fvect_id);
   } catch (debug::Exception & e) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain a vector "
                                             << vect_id << "(" << fvect_id
                                             << ") [" << e << "]");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 const InternalField<T> & Material::getInternal(__attribute__((unused))
                                                const ID & int_id) const {
   AKANTU_DEBUG_TO_IMPLEMENT();
   return NULL;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 InternalField<T> & Material::getInternal(__attribute__((unused))
                                          const ID & int_id) {
   AKANTU_DEBUG_TO_IMPLEMENT();
   return NULL;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 const InternalField<Real> & Material::getInternal(const ID & int_id) const {
-  std::map<ID, InternalField<Real> *>::const_iterator it =
-      internal_vectors_real.find(getID() + ":" + int_id);
+  auto it = internal_vectors_real.find(getID() + ":" + int_id);
   if (it == internal_vectors_real.end()) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain an internal "
                                             << int_id << " ("
                                             << (getID() + ":" + int_id) << ")");
   }
   return *it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <> InternalField<Real> & Material::getInternal(const ID & int_id) {
-  std::map<ID, InternalField<Real> *>::iterator it =
-      internal_vectors_real.find(getID() + ":" + int_id);
+  auto it = internal_vectors_real.find(getID() + ":" + int_id);
   if (it == internal_vectors_real.end()) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain an internal "
                                             << int_id << " ("
                                             << (getID() + ":" + int_id) << ")");
   }
   return *it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 const InternalField<UInt> & Material::getInternal(const ID & int_id) const {
-  std::map<ID, InternalField<UInt> *>::const_iterator it =
-      internal_vectors_uint.find(getID() + ":" + int_id);
+  auto it = internal_vectors_uint.find(getID() + ":" + int_id);
   if (it == internal_vectors_uint.end()) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain an internal "
                                             << int_id << " ("
                                             << (getID() + ":" + int_id) << ")");
   }
   return *it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <> InternalField<UInt> & Material::getInternal(const ID & int_id) {
-  std::map<ID, InternalField<UInt> *>::iterator it =
-      internal_vectors_uint.find(getID() + ":" + int_id);
+  auto it = internal_vectors_uint.find(getID() + ":" + int_id);
   if (it == internal_vectors_uint.end()) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain an internal "
                                             << int_id << " ("
                                             << (getID() + ":" + int_id) << ")");
   }
   return *it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::addElements(const Array<Element> & elements_to_add) {
   AKANTU_DEBUG_IN();
   UInt mat_id = model.getInternalIndexFromID(getID());
   Array<Element>::const_iterator<Element> el_begin = elements_to_add.begin();
   Array<Element>::const_iterator<Element> el_end = elements_to_add.end();
   for (; el_begin != el_end; ++el_begin) {
     const Element & element = *el_begin;
     Array<UInt> & mat_indexes =
         model.getMaterialByElement(element.type, element.ghost_type);
     Array<UInt> & mat_loc_num =
         model.getMaterialLocalNumbering(element.type, element.ghost_type);
 
     UInt index =
         this->addElement(element.type, element.element, element.ghost_type);
     mat_indexes(element.element) = mat_id;
     mat_loc_num(element.element) = index;
   }
 
   this->resizeInternals();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::removeElements(const Array<Element> & elements_to_remove) {
   AKANTU_DEBUG_IN();
 
   Array<Element>::const_iterator<Element> el_begin = elements_to_remove.begin();
   Array<Element>::const_iterator<Element> el_end = elements_to_remove.end();
 
   if (el_begin == el_end)
     return;
 
   ElementTypeMapArray<UInt> material_local_new_numbering(
       "remove mat filter elem", getID(), getMemoryID());
 
   Element element;
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     GhostType ghost_type = *gt;
     element.ghost_type = ghost_type;
 
     ElementTypeMapArray<UInt>::type_iterator it =
         element_filter.firstType(_all_dimensions, ghost_type, _ek_not_defined);
     ElementTypeMapArray<UInt>::type_iterator end =
         element_filter.lastType(_all_dimensions, ghost_type, _ek_not_defined);
 
     for (; it != end; ++it) {
       ElementType type = *it;
       element.type = type;
 
       Array<UInt> & elem_filter = this->element_filter(type, ghost_type);
       Array<UInt> & mat_loc_num =
           this->model.getMaterialLocalNumbering(type, ghost_type);
 
       if (!material_local_new_numbering.exists(type, ghost_type))
         material_local_new_numbering.alloc(elem_filter.size(), 1, type,
                                            ghost_type);
       Array<UInt> & mat_renumbering =
           material_local_new_numbering(type, ghost_type);
 
       UInt nb_element = elem_filter.size();
       Array<UInt> elem_filter_tmp;
 
       UInt new_id = 0;
       for (UInt el = 0; el < nb_element; ++el) {
         element.element = elem_filter(el);
 
         if (std::find(el_begin, el_end, element) == el_end) {
           elem_filter_tmp.push_back(element.element);
 
           mat_renumbering(el) = new_id;
           mat_loc_num(element.element) = new_id;
           ++new_id;
         } else {
           mat_renumbering(el) = UInt(-1);
         }
       }
 
       elem_filter.resize(elem_filter_tmp.size());
       elem_filter.copy(elem_filter_tmp);
     }
   }
 
-  for (std::map<ID, InternalField<Real> *>::iterator it =
-           internal_vectors_real.begin();
+  for (auto it = internal_vectors_real.begin();
        it != internal_vectors_real.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 
-  for (std::map<ID, InternalField<UInt> *>::iterator it =
-           internal_vectors_uint.begin();
+  for (auto it = internal_vectors_uint.begin();
        it != internal_vectors_uint.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 
-  for (std::map<ID, InternalField<bool> *>::iterator it =
-           internal_vectors_bool.begin();
+  for (auto it = internal_vectors_bool.begin();
        it != internal_vectors_bool.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::resizeInternals() {
   AKANTU_DEBUG_IN();
-  for (std::map<ID, InternalField<Real> *>::iterator it =
-           internal_vectors_real.begin();
+  for (auto it = internal_vectors_real.begin();
        it != internal_vectors_real.end(); ++it)
     it->second->resize();
 
-  for (std::map<ID, InternalField<UInt> *>::iterator it =
-           internal_vectors_uint.begin();
+  for (auto it = internal_vectors_uint.begin();
        it != internal_vectors_uint.end(); ++it)
     it->second->resize();
 
-  for (std::map<ID, InternalField<bool> *>::iterator it =
-           internal_vectors_bool.begin();
+  for (auto it = internal_vectors_bool.begin();
        it != internal_vectors_bool.end(); ++it)
     it->second->resize();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::onElementsAdded(const Array<Element> &,
                                const NewElementsEvent &) {
   this->resizeInternals();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::onElementsRemoved(
     const Array<Element> & element_list,
     const ElementTypeMapArray<UInt> & new_numbering,
     __attribute__((unused)) const RemovedElementsEvent & event) {
   UInt my_num = model.getInternalIndexFromID(getID());
 
   ElementTypeMapArray<UInt> material_local_new_numbering(
       "remove mat filter elem", getID(), getMemoryID());
 
   Array<Element>::const_iterator<Element> el_begin = element_list.begin();
   Array<Element>::const_iterator<Element> el_end = element_list.end();
 
   for (ghost_type_t::iterator g = ghost_type_t::begin();
        g != ghost_type_t::end(); ++g) {
     GhostType gt = *g;
 
     ElementTypeMapArray<UInt>::type_iterator it =
         new_numbering.firstType(_all_dimensions, gt, _ek_not_defined);
     ElementTypeMapArray<UInt>::type_iterator end =
         new_numbering.lastType(_all_dimensions, gt, _ek_not_defined);
     for (; it != end; ++it) {
       ElementType type = *it;
       if (element_filter.exists(type, gt) && element_filter(type, gt).size()) {
         Array<UInt> & elem_filter = element_filter(type, gt);
 
         Array<UInt> & mat_indexes = this->model.getMaterialByElement(*it, gt);
         Array<UInt> & mat_loc_num =
             this->model.getMaterialLocalNumbering(*it, gt);
         UInt nb_element = this->model.getMesh().getNbElement(type, gt);
 
         // all materials will resize of the same size...
         mat_indexes.resize(nb_element);
         mat_loc_num.resize(nb_element);
 
         if (!material_local_new_numbering.exists(type, gt))
           material_local_new_numbering.alloc(elem_filter.size(), 1, type, gt);
 
         Array<UInt> & mat_renumbering = material_local_new_numbering(type, gt);
         const Array<UInt> & renumbering = new_numbering(type, gt);
         Array<UInt> elem_filter_tmp;
         UInt ni = 0;
         Element el{type, 0, gt};
 
         for (UInt i = 0; i < elem_filter.size(); ++i) {
           el.element = elem_filter(i);
           if (std::find(el_begin, el_end, el) == el_end) {
             UInt new_el = renumbering(el.element);
             AKANTU_DEBUG_ASSERT(
                 new_el != UInt(-1),
                 "A not removed element as been badly renumbered");
             elem_filter_tmp.push_back(new_el);
             mat_renumbering(i) = ni;
 
             mat_indexes(new_el) = my_num;
             mat_loc_num(new_el) = ni;
             ++ni;
           } else {
             mat_renumbering(i) = UInt(-1);
           }
         }
 
         elem_filter.resize(elem_filter_tmp.size());
         elem_filter.copy(elem_filter_tmp);
       }
     }
   }
 
-  for (std::map<ID, InternalField<Real> *>::iterator it =
-           internal_vectors_real.begin();
+  for (auto it = internal_vectors_real.begin();
        it != internal_vectors_real.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 
-  for (std::map<ID, InternalField<UInt> *>::iterator it =
-           internal_vectors_uint.begin();
+  for (auto it = internal_vectors_uint.begin();
        it != internal_vectors_uint.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 
-  for (std::map<ID, InternalField<bool> *>::iterator it =
-           internal_vectors_bool.begin();
+  for (auto it = internal_vectors_bool.begin();
        it != internal_vectors_bool.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::beforeSolveStep() { this->savePreviousState(); }
 
 /* -------------------------------------------------------------------------- */
 void Material::afterSolveStep() {
   for (auto & type : element_filter.elementTypes(_all_dimensions, _not_ghost,
                                                  _ek_not_defined)) {
     this->updateEnergies(type, _not_ghost);
   }
 }
 /* -------------------------------------------------------------------------- */
 void Material::onDamageIteration() { this->savePreviousState(); }
 
 /* -------------------------------------------------------------------------- */
 void Material::onDamageUpdate() {
   ElementTypeMapArray<UInt>::type_iterator it = this->element_filter.firstType(
       _all_dimensions, _not_ghost, _ek_not_defined);
   ElementTypeMapArray<UInt>::type_iterator end =
       element_filter.lastType(_all_dimensions, _not_ghost, _ek_not_defined);
 
   for (; it != end; ++it) {
     this->updateEnergiesAfterDamage(*it, _not_ghost);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::onDump() {
   if (this->isFiniteDeformation())
     this->computeAllCauchyStresses(_not_ghost);
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
-  std::string type = getID().substr(getID().find_last_of(":") + 1);
+  std::string type = getID().substr(getID().find_last_of(':') + 1);
 
   stream << space << "Material " << type << " [" << std::endl;
   Parsable::printself(stream, indent);
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 /// extrapolate internal values
 void Material::extrapolateInternal(const ID & id, const Element & element,
                                    __attribute__((unused))
                                    const Matrix<Real> & point,
                                    Matrix<Real> & extrapolated) {
   if (this->isInternal<Real>(id, element.kind())) {
     UInt nb_element =
         this->element_filter(element.type, element.ghost_type).size();
     const ID name = this->getID() + ":" + id;
     UInt nb_quads =
         this->internal_vectors_real[name]->getFEEngine().getNbIntegrationPoints(
             element.type, element.ghost_type);
     const Array<Real> & internal =
         this->getArray<Real>(id, element.type, element.ghost_type);
     UInt nb_component = internal.getNbComponent();
     Array<Real>::const_matrix_iterator internal_it =
         internal.begin_reinterpret(nb_component, nb_quads, nb_element);
     Element local_element = this->convertToLocalElement(element);
 
     /// instead of really extrapolating, here the value of the first GP
     /// is copied into the result vector. This works only for linear
     /// elements
     /// @todo extrapolate!!!!
     AKANTU_DEBUG_WARNING("This is a fix, values are not truly extrapolated");
 
     const Matrix<Real> & values = internal_it[local_element.element];
     UInt index = 0;
     Vector<Real> tmp(nb_component);
     for (UInt j = 0; j < values.cols(); ++j) {
       tmp = values(j);
       if (tmp.norm() > 0) {
         index = j;
         break;
       }
     }
 
     for (UInt i = 0; i < extrapolated.size(); ++i) {
       extrapolated(i) = values(index);
     }
   } else {
     Matrix<Real> default_values(extrapolated.rows(), extrapolated.cols(), 0.);
     extrapolated = default_values;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::applyEigenGradU(const Matrix<Real> & prescribed_eigen_grad_u,
                                const GhostType ghost_type) {
 
   for (auto && type : element_filter.elementTypes(_all_dimensions, _not_ghost,
                                                   _ek_not_defined)) {
     if (!element_filter(type, ghost_type).size())
       continue;
     auto eigen_it = this->eigengradu(type, ghost_type)
                         .begin(spatial_dimension, spatial_dimension);
     auto eigen_end = this->eigengradu(type, ghost_type)
                          .end(spatial_dimension, spatial_dimension);
     for (; eigen_it != eigen_end; ++eigen_it) {
       auto & current_eigengradu = *eigen_it;
       current_eigengradu = prescribed_eigen_grad_u;
     }
   }
 }
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/material_inline_impl.cc b/src/model/solid_mechanics/material_inline_impl.cc
index 1a572ff5e..d4c4937c0 100644
--- a/src/model/solid_mechanics/material_inline_impl.cc
+++ b/src/model/solid_mechanics/material_inline_impl.cc
@@ -1,464 +1,463 @@
 /**
  * @file   material_inline_impl.cc
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue Jul 27 2010
  * @date last modification: Wed Nov 25 2015
  *
  * @brief  Implementation of the inline functions of the class material
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_INLINE_IMPL_CC__
 #define __AKANTU_MATERIAL_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline UInt Material::addElement(const ElementType & type, UInt element,
                                  const GhostType & ghost_type) {
   Array<UInt> & el_filter = this->element_filter(type, ghost_type);
   el_filter.push_back(element);
   return el_filter.size() - 1;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Material::addElement(const Element & element) {
   return this->addElement(element.type, element.element, element.ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Material::getTangentStiffnessVoigtSize(UInt dim) const {
   return (dim * (dim - 1) / 2 + dim);
 }
 /* -------------------------------------------------------------------------- */
 inline UInt Material::getCauchyStressMatrixSize(UInt dim) const {
   return (dim * dim);
 }
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void Material::gradUToF(const Matrix<Real> & grad_u, Matrix<Real> & F) {
   AKANTU_DEBUG_ASSERT(F.size() >= grad_u.size() && grad_u.size() == dim * dim,
                       "The dimension of the tensor F should be greater or "
                       "equal to the dimension of the tensor grad_u.");
 
   F.eye();
 
   for (UInt i = 0; i < dim; ++i)
     for (UInt j = 0; j < dim; ++j)
       F(i, j) += grad_u(i, j);
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void Material::computeCauchyStressOnQuad(const Matrix<Real> & F,
                                                 const Matrix<Real> & piola,
                                                 Matrix<Real> & sigma,
                                                 const Real & C33) const {
 
   Real J = F.det() * sqrt(C33);
 
   Matrix<Real> F_S(dim, dim);
   F_S.mul<false, false>(F, piola);
   Real constant = J ? 1. / J : 0;
   sigma.mul<false, true>(F_S, F, constant);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Material::rightCauchy(const Matrix<Real> & F, Matrix<Real> & C) {
   C.mul<true, false>(F, F);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Material::leftCauchy(const Matrix<Real> & F, Matrix<Real> & B) {
   B.mul<false, true>(F, F);
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void Material::gradUToEpsilon(const Matrix<Real> & grad_u,
                                      Matrix<Real> & epsilon) {
   for (UInt i = 0; i < dim; ++i)
     for (UInt j = 0; j < dim; ++j)
       epsilon(i, j) = 0.5 * (grad_u(i, j) + grad_u(j, i));
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void Material::gradUToGreenStrain(const Matrix<Real> & grad_u,
                                          Matrix<Real> & epsilon) {
   epsilon.mul<true, false>(grad_u, grad_u, .5);
 
   for (UInt i = 0; i < dim; ++i)
     for (UInt j = 0; j < dim; ++j)
       epsilon(i, j) += 0.5 * (grad_u(i, j) + grad_u(j, i));
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Material::stressToVonMises(const Matrix<Real> & stress) {
   // compute deviatoric stress
   UInt dim = stress.cols();
   Matrix<Real> deviatoric_stress =
       Matrix<Real>::eye(dim, -1. * stress.trace() / 3.);
 
   for (UInt i = 0; i < dim; ++i)
     for (UInt j = 0; j < dim; ++j)
       deviatoric_stress(i, j) += stress(i, j);
 
   // return Von Mises stress
   return std::sqrt(3. * deviatoric_stress.doubleDot(deviatoric_stress) / 2.);
 }
 
 /* ---------------------------------------------------------------------------*/
 template <UInt dim>
 inline void Material::setCauchyStressArray(const Matrix<Real> & S_t,
                                            Matrix<Real> & sigma_voight) {
   AKANTU_DEBUG_IN();
   sigma_voight.clear();
   // see Finite ekement formulations for large deformation dynamic analysis,
   // Bathe et al. IJNME vol 9, 1975, page 364 ^t\tau
 
   /*
    * 1d: [ s11 ]'
    * 2d: [ s11 s22 s12 ]'
    * 3d: [ s11 s22 s33 s23 s13 s12 ]
    */
   for (UInt i = 0; i < dim; ++i) // diagonal terms
     sigma_voight(i, 0) = S_t(i, i);
 
   for (UInt i = 1; i < dim; ++i) // term s12 in 2D and terms s23 s13 in 3D
     sigma_voight(dim + i - 1, 0) = S_t(dim - i - 1, dim - 1);
 
   for (UInt i = 2; i < dim; ++i) // term s13 in 3D
     sigma_voight(dim + i, 0) = S_t(0, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void Material::setCauchyStressMatrix(const Matrix<Real> & S_t,
                                             Matrix<Real> & sigma) {
   AKANTU_DEBUG_IN();
 
   sigma.clear();
 
   /// see Finite ekement formulations for large deformation dynamic analysis,
   /// Bathe et al. IJNME vol 9, 1975, page 364 ^t\tau
   for (UInt i = 0; i < dim; ++i) {
     for (UInt m = 0; m < dim; ++m) {
       for (UInt n = 0; n < dim; ++n) {
         sigma(i * dim + m, i * dim + n) = S_t(m, n);
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 inline Element
 Material::convertToLocalElement(const Element & global_element) const {
   UInt ge = global_element.element;
 #ifndef AKANTU_NDEBUG
   UInt model_mat_index = this->model.getMaterialByElement(
       global_element.type, global_element.ghost_type)(ge);
 
   UInt mat_index = this->model.getMaterialIndex(this->name);
   AKANTU_DEBUG_ASSERT(model_mat_index == mat_index,
                       "Conversion of a global  element in a local element for "
                       "the wrong material "
                           << this->name << std::endl);
 #endif
   UInt le = this->model.getMaterialLocalNumbering(
       global_element.type, global_element.ghost_type)(ge);
 
   Element tmp_quad{global_element.type, le, global_element.ghost_type};
   return tmp_quad;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Element
 Material::convertToGlobalElement(const Element & local_element) const {
   UInt le = local_element.element;
   UInt ge =
       this->element_filter(local_element.type, local_element.ghost_type)(le);
 
   Element tmp_quad{local_element.type, ge, local_element.ghost_type};
   return tmp_quad;
 }
 
 /* -------------------------------------------------------------------------- */
 inline IntegrationPoint
 Material::convertToLocalPoint(const IntegrationPoint & global_point) const {
   const FEEngine & fem = this->model.getFEEngine();
   UInt nb_quad = fem.getNbIntegrationPoints(global_point.type);
   Element el =
       this->convertToLocalElement(static_cast<const Element &>(global_point));
   IntegrationPoint tmp_quad(el, global_point.num_point, nb_quad);
   return tmp_quad;
 }
 
 /* -------------------------------------------------------------------------- */
 inline IntegrationPoint
 Material::convertToGlobalPoint(const IntegrationPoint & local_point) const {
   const FEEngine & fem = this->model.getFEEngine();
   UInt nb_quad = fem.getNbIntegrationPoints(local_point.type);
   Element el =
       this->convertToGlobalElement(static_cast<const Element &>(local_point));
   IntegrationPoint tmp_quad(el, local_point.num_point, nb_quad);
   return tmp_quad;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Material::getNbData(const Array<Element> & elements,
                                 const SynchronizationTag & tag) const {
   if (tag == _gst_smm_stress) {
     return (this->isFiniteDeformation() ? 3 : 1) * spatial_dimension *
            spatial_dimension * sizeof(Real) *
            this->getModel().getNbIntegrationPoints(elements);
   }
   return 0;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Material::packData(CommunicationBuffer & buffer,
                                const Array<Element> & elements,
                                const SynchronizationTag & tag) const {
   if (tag == _gst_smm_stress) {
     if (this->isFiniteDeformation()) {
       packElementDataHelper(piola_kirchhoff_2, buffer, elements);
       packElementDataHelper(gradu, buffer, elements);
     }
     packElementDataHelper(stress, buffer, elements);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Material::unpackData(CommunicationBuffer & buffer,
                                  const Array<Element> & elements,
                                  const SynchronizationTag & tag) {
   if (tag == _gst_smm_stress) {
     if (this->isFiniteDeformation()) {
       unpackElementDataHelper(piola_kirchhoff_2, buffer, elements);
       unpackElementDataHelper(gradu, buffer, elements);
     }
     unpackElementDataHelper(stress, buffer, elements);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Parameter & Material::getParam(const ID & param) const {
   try {
     return get(param);
   } catch (...) {
     AKANTU_EXCEPTION("No parameter " << param << " in the material "
                                      << getID());
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Material::setParam(const ID & param, T value) {
   try {
     set<T>(param, value);
   } catch (...) {
     AKANTU_EXCEPTION("No parameter " << param << " in the material "
                                      << getID());
   }
   updateInternalParameters();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Material::packElementDataHelper(
     const ElementTypeMapArray<T> & data_to_pack, CommunicationBuffer & buffer,
     const Array<Element> & elements, const ID & fem_id) const {
   DataAccessor::packElementalDataHelper<T>(data_to_pack, buffer, elements, true,
                                            model.getFEEngine(fem_id));
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Material::unpackElementDataHelper(
     ElementTypeMapArray<T> & data_to_unpack, CommunicationBuffer & buffer,
     const Array<Element> & elements, const ID & fem_id) {
   DataAccessor::unpackElementalDataHelper<T>(data_to_unpack, buffer, elements,
                                              true, model.getFEEngine(fem_id));
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void Material::registerInternal<Real>(InternalField<Real> & vect) {
   internal_vectors_real[vect.getID()] = &vect;
 }
 
 template <>
 inline void Material::registerInternal<UInt>(InternalField<UInt> & vect) {
   internal_vectors_uint[vect.getID()] = &vect;
 }
 
 template <>
 inline void Material::registerInternal<bool>(InternalField<bool> & vect) {
   internal_vectors_bool[vect.getID()] = &vect;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void Material::unregisterInternal<Real>(InternalField<Real> & vect) {
   internal_vectors_real.erase(vect.getID());
 }
 
 template <>
 inline void Material::unregisterInternal<UInt>(InternalField<UInt> & vect) {
   internal_vectors_uint.erase(vect.getID());
 }
 
 template <>
 inline void Material::unregisterInternal<bool>(InternalField<bool> & vect) {
   internal_vectors_bool.erase(vect.getID());
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline bool Material::isInternal(__attribute__((unused)) const ID & id,
                                  __attribute__((unused)) const ElementKind & element_kind) const {
   AKANTU_DEBUG_TO_IMPLEMENT();
 }
 
 template <>
 inline bool Material::isInternal<Real>(const ID & id,
                                        const ElementKind & element_kind) const {
-  std::map<ID, InternalField<Real> *>::const_iterator internal_array =
-      internal_vectors_real.find(this->getID() + ":" + id);
+  auto internal_array = internal_vectors_real.find(this->getID() + ":" + id);
 
   if (internal_array == internal_vectors_real.end() ||
       internal_array->second->getElementKind() != element_kind)
     return false;
   return true;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline ElementTypeMap<UInt>
 Material::getInternalDataPerElem(const ID & field_id,
                                  const ElementKind & element_kind) const {
 
   if (!this->template isInternal<T>(field_id, element_kind))
     AKANTU_EXCEPTION("Cannot find internal field " << id << " in material "
                                                    << this->name);
 
   const InternalField<T> & internal_field =
       this->template getInternal<T>(field_id);
   const FEEngine & fe_engine = internal_field.getFEEngine();
   UInt nb_data_per_quad = internal_field.getNbComponent();
 
   ElementTypeMap<UInt> res;
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
-    typedef typename InternalField<T>::type_iterator type_iterator;
+    using type_iterator = typename InternalField<T>::type_iterator;
     type_iterator tit = internal_field.firstType(*gt);
     type_iterator tend = internal_field.lastType(*gt);
 
     for (; tit != tend; ++tit) {
       UInt nb_quadrature_points = fe_engine.getNbIntegrationPoints(*tit, *gt);
       res(*tit, *gt) = nb_data_per_quad * nb_quadrature_points;
     }
   }
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Material::flattenInternal(const std::string & field_id,
                                ElementTypeMapArray<T> & internal_flat,
                                const GhostType ghost_type,
                                ElementKind element_kind) const {
 
   if (!this->template isInternal<T>(field_id, element_kind))
     AKANTU_EXCEPTION("Cannot find internal field " << id << " in material "
                                                    << this->name);
 
   const InternalField<T> & internal_field =
       this->template getInternal<T>(field_id);
 
   const FEEngine & fe_engine = internal_field.getFEEngine();
   const Mesh & mesh = fe_engine.getMesh();
 
-  typedef typename InternalField<T>::filter_type_iterator type_iterator;
+  using type_iterator = typename InternalField<T>::filter_type_iterator;
   type_iterator tit = internal_field.filterFirstType(ghost_type);
   type_iterator tend = internal_field.filterLastType(ghost_type);
 
   for (; tit != tend; ++tit) {
     ElementType type = *tit;
 
     const Array<Real> & src_vect = internal_field(type, ghost_type);
     const Array<UInt> & filter = internal_field.getFilter(type, ghost_type);
 
     // total number of elements in the corresponding mesh
     UInt nb_element_dst = mesh.getNbElement(type, ghost_type);
     // number of element in the internal field
     UInt nb_element_src = filter.size();
     // number of quadrature points per elem
     UInt nb_quad_per_elem = fe_engine.getNbIntegrationPoints(type);
     // number of data per quadrature point
     UInt nb_data_per_quad = internal_field.getNbComponent();
 
     if (!internal_flat.exists(type, ghost_type)) {
       internal_flat.alloc(nb_element_dst * nb_quad_per_elem, nb_data_per_quad,
                           type, ghost_type);
     }
 
     if (nb_element_src == 0)
       continue;
 
     // number of data per element
     UInt nb_data = nb_quad_per_elem * nb_data_per_quad;
 
     Array<Real> & dst_vect = internal_flat(type, ghost_type);
     dst_vect.resize(nb_element_dst * nb_quad_per_elem);
 
     Array<UInt>::const_scalar_iterator it = filter.begin();
     Array<UInt>::const_scalar_iterator end = filter.end();
 
     Array<Real>::const_vector_iterator it_src =
         src_vect.begin_reinterpret(nb_data, nb_element_src);
     Array<Real>::vector_iterator it_dst =
         dst_vect.begin_reinterpret(nb_data, nb_element_dst);
 
     for (; it != end; ++it, ++it_src) {
       it_dst[*it] = *it_src;
     }
   }
 }
 
 } // akantu
 
 #endif /* __AKANTU_MATERIAL_INLINE_IMPL_CC__ */
diff --git a/src/model/solid_mechanics/material_selector.hh b/src/model/solid_mechanics/material_selector.hh
index 6759d1967..9271e92b9 100644
--- a/src/model/solid_mechanics/material_selector.hh
+++ b/src/model/solid_mechanics/material_selector.hh
@@ -1,142 +1,142 @@
 /**
  * @file   material_selector.hh
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Thu Dec 17 2015
  *
  * @brief  class describing how to choose a material for a given element
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_SELECTOR_HH__
 #define __AKANTU_MATERIAL_SELECTOR_HH__
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 class SolidMechanicsModel;
 
 /**
  * main class to assign same or different materials for different
  * elements
  */
 class MaterialSelector {
 public:
-  MaterialSelector() : fallback_value(0) {}
-  virtual ~MaterialSelector() {}
+  MaterialSelector() = default;
+  virtual ~MaterialSelector() = default;
   virtual UInt operator()(__attribute__((unused)) const Element & element) {
     return fallback_value;
   }
 
   void setFallback(UInt f) { fallback_value = f; }
 
 protected:
-  UInt fallback_value;
+  UInt fallback_value{0};
 };
 
 /* -------------------------------------------------------------------------- */
 /**
  * class that assigns the first material to regular elements by default
  */
 class DefaultMaterialSelector : public MaterialSelector {
 public:
   explicit DefaultMaterialSelector(const ElementTypeMapArray<UInt> & material_index)
       : material_index(material_index) {}
 
   UInt operator()(const Element & element) override {
     if (not material_index.exists(element.type, element.ghost_type))
       return fallback_value;
 
     const auto & mat_indexes = material_index(element.type, element.ghost_type);
     if (element.element < mat_indexes.size()) {
       auto && tmp_mat = mat_indexes(element.element);
       if (tmp_mat != UInt(-1))
         return tmp_mat;
     }
 
     return fallback_value;
   }
 
 private:
   const ElementTypeMapArray<UInt> & material_index;
 };
 
 /* -------------------------------------------------------------------------- */
 /**
  * Use elemental data to assign materials
  */
 template <typename T>
 class ElementDataMaterialSelector : public MaterialSelector {
 public:
   ElementDataMaterialSelector(const ElementTypeMapArray<T> & element_data,
                               const SolidMechanicsModel & model,
                               UInt first_index = 1)
       : element_data(element_data), model(model), first_index(first_index) {}
 
   inline T elementData(const Element & element) {
     DebugLevel dbl = debug::getDebugLevel();
     debug::setDebugLevel(dblError);
     T data = element_data(element.type, element.ghost_type)(element.element);
     debug::setDebugLevel(dbl);
     return data;
   }
 
   inline UInt operator()(const Element & element) override {
     return MaterialSelector::operator()(element);
   }
 
 protected:
   /// list of element with the specified data (i.e. tag value)
   const ElementTypeMapArray<T> & element_data;
 
   /// the model that the materials belong
   const SolidMechanicsModel & model;
 
   /// first material index: equal to 1 if none specified
   UInt first_index;
 };
 
 /* -------------------------------------------------------------------------- */
 /**
  * class to use mesh data information to assign different materials
  * where name is the tag value: tag_0, tag_1
  */
 template <typename T>
 class MeshDataMaterialSelector : public ElementDataMaterialSelector<T> {
 public:
   MeshDataMaterialSelector(const std::string & name,
                            const SolidMechanicsModel & model,
                            UInt first_index = 1);
 };
 
 } // namespace akantu
 
 #endif /* __AKANTU_MATERIAL_SELECTOR_HH__ */
diff --git a/src/model/solid_mechanics/materials/internal_field.hh b/src/model/solid_mechanics/materials/internal_field.hh
index 96df05f34..75d8254b2 100644
--- a/src/model/solid_mechanics/materials/internal_field.hh
+++ b/src/model/solid_mechanics/materials/internal_field.hh
@@ -1,257 +1,258 @@
 /**
  * @file   internal_field.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Material internal properties
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "element_type_map.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_INTERNAL_FIELD_HH__
 #define __AKANTU_INTERNAL_FIELD_HH__
 
 namespace akantu {
 
 class Material;
 class FEEngine;
 
 /**
  * class for the internal fields of materials
  * to store values for each quadrature
  */
 template <typename T> class InternalField : public ElementTypeMapArray<T> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   InternalField(const ID & id, Material & material);
   ~InternalField() override;
 
   /// This constructor is only here to let cohesive elements compile
   InternalField(const ID & id, Material & material, FEEngine & fem,
                 const ElementTypeMapArray<UInt> & element_filter);
 
   /// More general constructor
   InternalField(const ID & id, Material & material, UInt dim, FEEngine & fem,
                 const ElementTypeMapArray<UInt> & element_filter);
 
   InternalField(const ID & id, const InternalField<T> & other);
 
 private:
   InternalField operator=(__attribute__((unused))
                           const InternalField & other){};
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// function to reset the FEEngine for the internal field
   virtual void setFEEngine(FEEngine & fe_engine);
 
   /// function to reset the element kind for the internal
   virtual void setElementKind(ElementKind element_kind);
 
   /// initialize the field to a given number of component
   virtual void initialize(UInt nb_component);
 
   /// activate the history of this field
   virtual void initializeHistory();
 
   /// resize the arrays and set the new element to 0
   virtual void resize();
 
   /// set the field to a given value v
   virtual void setDefaultValue(const T & v);
 
   /// reset all the fields to the default value
   virtual void reset();
 
   /// save the current values in the history
   virtual void saveCurrentValues();
 
   /// remove the quadrature points corresponding to suppressed elements
   virtual void
   removeIntegrationPoints(const ElementTypeMapArray<UInt> & new_numbering);
 
   /// print the content
   void printself(std::ostream & stream, int indent = 0) const override;
 
   /// get the default value
   inline operator T() const;
 
   virtual FEEngine & getFEEngine() { return *fem; }
 
   virtual const FEEngine & getFEEngine() const { return *fem; }
 
   /// AKANTU_GET_MACRO(FEEngine, *fem, FEEngine &);
 
 protected:
   /// initialize the arrays in the ElementTypeMapArray<T>
   void internalInitialize(UInt nb_component);
 
   /// set the values for new internals
   virtual void setArrayValues(T * begin, T * end);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
-  typedef typename ElementTypeMapArray<T>::type_iterator type_iterator;
-  typedef typename ElementTypeMapArray<UInt>::type_iterator filter_type_iterator;
+  using type_iterator = typename ElementTypeMapArray<T>::type_iterator;
+  using filter_type_iterator =
+      typename ElementTypeMapArray<UInt>::type_iterator;
 
   /// get the type iterator on all types contained in the internal field
   type_iterator firstType(const GhostType & ghost_type = _not_ghost) const {
     return ElementTypeMapArray<T>::firstType(this->spatial_dimension, ghost_type,
                                              this->element_kind);
   }
 
   /// get the type iterator on the last type contained in the internal field
   type_iterator lastType(const GhostType & ghost_type = _not_ghost) const {
     return ElementTypeMapArray<T>::lastType(this->spatial_dimension, ghost_type,
                                             this->element_kind);
   }
 
     /// get the type iterator on all types contained in the internal field
   filter_type_iterator filterFirstType(const GhostType & ghost_type = _not_ghost) const {
     return this->element_filter.firstType(this->spatial_dimension, ghost_type,
                            this->element_kind);
   }
 
   /// get the type iterator on the last type contained in the internal field
   filter_type_iterator filterLastType(const GhostType & ghost_type = _not_ghost) const {
     return this->element_filter.lastType(this->spatial_dimension, ghost_type,
                           this->element_kind);
   }
 
   /// get the array for a given type of the element_filter
   const Array<UInt> getFilter(const ElementType & type,
                               const GhostType & ghost_type = _not_ghost) const {
     return this->element_filter(type, ghost_type);
   }
 
   /// get the Array corresponding to the type en ghost_type specified
   virtual Array<T> & operator()(const ElementType & type,
                                 const GhostType & ghost_type = _not_ghost) {
     return ElementTypeMapArray<T>::operator()(type, ghost_type);
   }
 
   virtual const Array<T> &
   operator()(const ElementType & type,
              const GhostType & ghost_type = _not_ghost) const {
     return ElementTypeMapArray<T>::operator()(type, ghost_type);
   }
 
   virtual Array<T> & previous(const ElementType & type,
                               const GhostType & ghost_type = _not_ghost) {
     AKANTU_DEBUG_ASSERT(previous_values != nullptr,
                         "The history of the internal "
                             << this->getID() << " has not been activated");
     return this->previous_values->operator()(type, ghost_type);
   }
 
   virtual const Array<T> &
   previous(const ElementType & type,
            const GhostType & ghost_type = _not_ghost) const {
     AKANTU_DEBUG_ASSERT(previous_values != nullptr,
                         "The history of the internal "
                             << this->getID() << " has not been activated");
     return this->previous_values->operator()(type, ghost_type);
   }
 
   virtual InternalField<T> & previous() {
     AKANTU_DEBUG_ASSERT(previous_values != nullptr,
                         "The history of the internal "
                             << this->getID() << " has not been activated");
     return *(this->previous_values);
   }
 
   virtual const InternalField<T> & previous() const {
     AKANTU_DEBUG_ASSERT(previous_values != nullptr,
                         "The history of the internal "
                             << this->getID() << " has not been activated");
     return *(this->previous_values);
   }
 
   /// check if the history is used or not
   bool hasHistory() const { return (previous_values != nullptr); }
 
   /// get the kind treated by the internal
   const ElementKind & getElementKind() const { return element_kind; }
 
   /// return the number of components
   UInt getNbComponent() const { return nb_component; }
 
   /// return the spatial dimension corresponding to the internal element type
   /// loop filter
   UInt getSpatialDimension() const { return this->spatial_dimension; }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// the material for which this is an internal parameter
   Material & material;
 
   /// the fem containing the mesh and the element informations
   FEEngine * fem;
 
   /// Element filter if needed
   const ElementTypeMapArray<UInt> & element_filter;
 
   /// default value
   T default_value;
 
   /// spatial dimension of the element to consider
   UInt spatial_dimension;
 
   /// ElementKind of the element to consider
   ElementKind element_kind;
 
   /// Number of component of the internal field
   UInt nb_component;
 
   /// Is the field initialized
   bool is_init;
 
   /// previous values
   InternalField<T> * previous_values;
 };
 
 /// standard output stream operator
 template <typename T>
 inline std::ostream & operator<<(std::ostream & stream,
                                  const InternalField<T> & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // akantu
 
 #endif /* __AKANTU_INTERNAL_FIELD_HH__ */
diff --git a/src/model/solid_mechanics/materials/material_damage/material_damage.hh b/src/model/solid_mechanics/materials/material_damage/material_damage.hh
index 3671ba428..475c6d0b5 100644
--- a/src/model/solid_mechanics/materials/material_damage/material_damage.hh
+++ b/src/model/solid_mechanics/materials/material_damage/material_damage.hh
@@ -1,113 +1,112 @@
 /**
  * @file   material_damage.hh
  *
  * @author Marion Estelle Chambart <marion.chambart@epfl.ch>
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Sat Jul 11 2015
  *
  * @brief  Material isotropic elastic
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "material_elastic.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_DAMAGE_HH__
 #define __AKANTU_MATERIAL_DAMAGE_HH__
 
 namespace akantu {
 template <UInt spatial_dimension,
           template <UInt> class Parent = MaterialElastic>
 class MaterialDamage : public Parent<spatial_dimension> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   MaterialDamage(SolidMechanicsModel & model, const ID & id = "");
-
-  virtual ~MaterialDamage(){};
+  ~MaterialDamage() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
-  virtual void initMaterial();
+  void initMaterial() override;
 
   /// compute the tangent stiffness matrix for an element type
-  virtual void computeTangentModuli(const ElementType & el_type,
-                                    Array<Real> & tangent_matrix,
-                                    GhostType ghost_type = _not_ghost);
-  virtual bool hasStiffnessMatrixChanged() { return true; }
+  void computeTangentModuli(const ElementType & el_type,
+                            Array<Real> & tangent_matrix,
+                            GhostType ghost_type = _not_ghost) override;
+  bool hasStiffnessMatrixChanged() override { return true; }
 
 protected:
   /// update the dissipated energy, must be called after the stress have been
   /// computed
-  virtual void updateEnergies(ElementType el_type, GhostType ghost_type);
+  void updateEnergies(ElementType el_type, GhostType ghost_type) override;
 
   /// compute the tangent stiffness matrix for a given quadrature point
   inline void computeTangentModuliOnQuad(Matrix<Real> & tangent, Real & dam);
 
   /* ------------------------------------------------------------------------ */
   /* DataAccessor inherited members                                           */
   /* ------------------------------------------------------------------------ */
 public:
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// give the dissipated energy for the time step
   Real getDissipatedEnergy() const;
 
-  virtual Real getEnergy(std::string type);
-  virtual Real getEnergy(std::string energy_id, ElementType type, UInt index) {
+  Real getEnergy(std::string type) override;
+  Real getEnergy(std::string energy_id, ElementType type, UInt index) override {
     return Parent<spatial_dimension>::getEnergy(energy_id, type, index);
   };
 
   AKANTU_GET_MACRO_NOT_CONST(Damage, damage, ElementTypeMapArray<Real> &);
   AKANTU_GET_MACRO(Damage, damage, const ElementTypeMapArray<Real> &);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Damage, damage, Real)
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// damage internal variable
   InternalField<Real> damage;
 
   /// dissipated energy
   InternalField<Real> dissipated_energy;
 
   /// contain the current value of @f$ \int_0^{\epsilon}\sigma(\omega)d\omega
   /// @f$ the dissipated energy
   InternalField<Real> int_sigma;
 };
 
 } // akantu
 
 #include "material_damage_tmpl.hh"
 
 #endif /* __AKANTU_MATERIAL_DAMAGE_HH__ */
diff --git a/src/model/solid_mechanics/materials/material_damage/material_marigo.hh b/src/model/solid_mechanics/materials/material_damage/material_marigo.hh
index 450eb7354..39cb01c1e 100644
--- a/src/model/solid_mechanics/materials/material_damage/material_marigo.hh
+++ b/src/model/solid_mechanics/materials/material_damage/material_marigo.hh
@@ -1,124 +1,124 @@
 /**
  * @file   material_marigo.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: Fri Jun 18 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Marigo damage law
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "material.hh"
 #include "material_damage.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_MARIGO_HH__
 #define __AKANTU_MATERIAL_MARIGO_HH__
 
 namespace akantu {
 
 /**
  * Material marigo
  *
  * parameters in the material files :
  *   - Yd  : (default: 50)
  *   - Sd  : (default: 5000)
  *   - Ydrandomness  : (default:0)
  */
 template <UInt spatial_dimension>
 class MaterialMarigo : public MaterialDamage<spatial_dimension> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   MaterialMarigo(SolidMechanicsModel & model, const ID & id = "");
-
-  virtual ~MaterialMarigo(){};
+  ~MaterialMarigo() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
-  void initMaterial();
+  void initMaterial() override;
 
-  virtual void updateInternalParameters();
+  void updateInternalParameters() 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;
 
 protected:
   /// constitutive law for a given quadrature point
   inline void computeStressOnQuad(Matrix<Real> & grad_u, Matrix<Real> & sigma,
                                   Real & dam, Real & Y, Real & Ydq);
 
   inline void computeDamageAndStressOnQuad(Matrix<Real> & sigma, Real & dam,
                                            Real & Y, Real & Ydq);
 
   /* ------------------------------------------------------------------------ */
   /* DataAccessor inherited members                                           */
   /* ------------------------------------------------------------------------ */
 public:
-  inline virtual UInt getNbData(const Array<Element> & elements,
-                                const SynchronizationTag & tag) const;
+  inline UInt getNbData(const Array<Element> & elements,
+                        const SynchronizationTag & tag) const override;
 
-  inline virtual void packData(CommunicationBuffer & buffer,
-                               const Array<Element> & elements,
-                               const SynchronizationTag & tag) const;
+  inline void packData(CommunicationBuffer & buffer,
+                       const Array<Element> & elements,
+                       const SynchronizationTag & tag) const override;
 
-  inline virtual void unpackData(CommunicationBuffer & buffer,
-                                 const Array<Element> & elements,
-                                 const SynchronizationTag & tag);
+  inline void unpackData(CommunicationBuffer & buffer,
+                         const Array<Element> & elements,
+                         const SynchronizationTag & tag) override;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// resistance to damage
   RandomInternalField<Real> Yd;
 
   /// damage threshold
   Real Sd;
 
   /// critical epsilon when the material is considered as broken
   Real epsilon_c;
 
   Real Yc;
 
   bool damage_in_y;
   bool yc_limit;
 };
 
 } // akantu
 
 #include "material_marigo_inline_impl.cc"
 
 #endif /* __AKANTU_MATERIAL_MARIGO_HH__ */
diff --git a/src/model/solid_mechanics/materials/material_damage/material_marigo_non_local.hh b/src/model/solid_mechanics/materials/material_damage/material_marigo_non_local.hh
index ff8e06591..b9085cdf5 100644
--- a/src/model/solid_mechanics/materials/material_damage/material_marigo_non_local.hh
+++ b/src/model/solid_mechanics/materials/material_damage/material_marigo_non_local.hh
@@ -1,93 +1,94 @@
 /**
  * @file   material_marigo_non_local.hh
  *
  * @author Marion Estelle Chambart <marion.chambart@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Marigo non-local description
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "material_damage_non_local.hh"
 #include "material_marigo.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_MARIGO_NON_LOCAL_HH__
 #define __AKANTU_MATERIAL_MARIGO_NON_LOCAL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 
 /**
  * Material Marigo
  *
  * parameters in the material files :
  */
 template <UInt spatial_dimension>
 class MaterialMarigoNonLocal
     : public MaterialDamageNonLocal<spatial_dimension,
                                     MaterialMarigo<spatial_dimension>> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   typedef MaterialDamageNonLocal<spatial_dimension,
                                  MaterialMarigo<spatial_dimension>>
       MaterialMarigoNonLocalParent;
   MaterialMarigoNonLocal(SolidMechanicsModel & model, const ID & id = "");
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 protected:
   void registerNonLocalVariables() override;
 
   /// constitutive law
-  void computeStress(ElementType el_type, GhostType ghost_type = _not_ghost);
+  void computeStress(ElementType el_type,
+                     GhostType ghost_type = _not_ghost) override;
 
   void computeNonLocalStress(ElementType type,
-                             GhostType ghost_type = _not_ghost);
+                             GhostType ghost_type = _not_ghost) override;
 
 private:
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Y, Y, Real);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   InternalField<Real> Y;
   InternalField<Real> Ynl;
 };
 
 } // namespace akantu
 
 #endif /* __AKANTU_MATERIAL_MARIGO_NON_LOCAL_HH__ */
diff --git a/src/model/solid_mechanics/materials/material_damage/material_mazars.hh b/src/model/solid_mechanics/materials/material_damage/material_mazars.hh
index 871748cb5..40d5d4358 100644
--- a/src/model/solid_mechanics/materials/material_damage/material_mazars.hh
+++ b/src/model/solid_mechanics/materials/material_damage/material_mazars.hh
@@ -1,125 +1,125 @@
 /**
  * @file   material_mazars.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: Fri Jun 18 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Material Following the Mazars law for damage evolution
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "material.hh"
 #include "material_damage.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_MAZARS_HH__
 #define __AKANTU_MATERIAL_MAZARS_HH__
 
 namespace akantu {
 
 /**
  * Material Mazars
  *
  * parameters in the material files :
  *   - rho  : density (default: 0)
  *   - E    : Young's modulus (default: 0)
  *   - nu   : Poisson's ratio (default: 1/2)
  *   - K0   : Damage threshold
  *   - At   : Parameter damage traction 1
  *   - Bt   : Parameter damage traction 2
  *   - Ac   : Parameter damage compression 1
  *   - Bc   : Parameter damage compression 2
  *   - beta : Parameter for shear
  */
 template <UInt spatial_dimension>
 class MaterialMazars : public MaterialDamage<spatial_dimension> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   MaterialMazars(SolidMechanicsModel & model, const ID & id = "");
-
-  virtual ~MaterialMazars(){};
+  ~MaterialMazars() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// 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;
 
 protected:
   /// constitutive law for a given quadrature point
   inline void computeStressOnQuad(const Matrix<Real> & grad_u,
                                   Matrix<Real> & sigma, Real & damage,
                                   Real & Ehat);
 
   inline void computeDamageAndStressOnQuad(const Matrix<Real> & grad_u,
                                            Matrix<Real> & sigma, Real & damage,
                                            Real & Ehat);
 
   inline void computeDamageOnQuad(const Real & epsilon_equ,
                                   const Matrix<Real> & sigma,
                                   const Vector<Real> & epsilon_princ,
                                   Real & dam);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// damage threshold
   RandomInternalField<Real> K0;
   /// parameter damage traction 1
   Real At;
   /// parameter damage traction 2
   Real Bt;
   /// parameter damage compression 1
   Real Ac;
   /// parameter damage compression 2
   Real Bc;
   /// parameter for shear
   Real beta;
 
   /// specify the variable to average false = ehat, true = damage (only valid
   /// for non local version)
   bool damage_in_compute_stress;
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 #include "material_mazars_inline_impl.cc"
 
 } // namespace akantu
 
 #endif /* __AKANTU_MATERIAL_MAZARS_HH__ */
diff --git a/src/model/solid_mechanics/materials/material_elastic.hh b/src/model/solid_mechanics/materials/material_elastic.hh
index 791043bf6..a8c7c5b84 100644
--- a/src/model/solid_mechanics/materials/material_elastic.hh
+++ b/src/model/solid_mechanics/materials/material_elastic.hh
@@ -1,158 +1,158 @@
 /**
  * @file   material_elastic.hh
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Sun Nov 15 2015
  *
  * @brief  Material isotropic elastic
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "material_thermal.hh"
 #include "plane_stress_toolbox.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_ELASTIC_HH__
 #define __AKANTU_MATERIAL_ELASTIC_HH__
 
 namespace akantu {
 
 /**
  * Material elastic isotropic
  *
  * parameters in the material files :
  *   - E   : Young's modulus (default: 0)
  *   - nu  : Poisson's ratio (default: 1/2)
  *   - Plane_Stress : if 0: plane strain, else: plane stress (default: 0)
  */
 template <UInt spatial_dimension>
 class MaterialElastic
   : public PlaneStressToolbox<spatial_dimension,
                               MaterialThermal<spatial_dimension>> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 private:
   typedef PlaneStressToolbox<spatial_dimension,
                              MaterialThermal<spatial_dimension>>
   Parent;
 
 public:
   MaterialElastic(SolidMechanicsModel & model, const ID & id = "");
   MaterialElastic(SolidMechanicsModel & model, UInt dim, const Mesh & mesh,
                   FEEngine & fe_engine, const ID & id = "");
 
-  ~MaterialElastic() override {}
+  ~MaterialElastic() override = default;
 
 protected:
   void initialize();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   void initMaterial() override;
 
   /// constitutive law for all element of a type
   void computeStress(ElementType el_type,
                              GhostType ghost_type = _not_ghost) override;
 
   /// compute the tangent stiffness matrix for an element type
   void computeTangentModuli(const ElementType & el_type,
                             Array<Real> & tangent_matrix,
                             GhostType ghost_type = _not_ghost) override;
 
   /// compute the elastic potential energy
   void computePotentialEnergy(ElementType el_type,
                               GhostType ghost_type = _not_ghost) override;
 
   void
   computePotentialEnergyByElement(ElementType type, UInt index,
                                   Vector<Real> & epot_on_quad_points) override;
 
   /// compute the p-wave speed in the material
   Real getPushWaveSpeed(const Element & element) const override;
 
   /// compute the s-wave speed in the material
   Real getShearWaveSpeed(const Element & element) const override;
 
 protected:
   /// constitutive law for a given quadrature point
   inline void computeStressOnQuad(const Matrix<Real> & grad_u,
                                   Matrix<Real> & sigma,
                                   const Real sigma_th = 0) const;
 
   /// compute the tangent stiffness matrix for an element
   inline void computeTangentModuliOnQuad(Matrix<Real> & tangent) const;
 
   /// recompute the lame coefficient if E or nu changes
   void updateInternalParameters() override;
 
   static inline void computePotentialEnergyOnQuad(const Matrix<Real> & grad_u,
                                                   const Matrix<Real> & sigma,
                                                   Real & epot);
 
   bool hasStiffnessMatrixChanged() override {
     return (! was_stiffness_assembled);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get first Lame constant
   AKANTU_GET_MACRO(Lambda, lambda, Real);
 
   /// get second Lame constant
   AKANTU_GET_MACRO(Mu, mu, Real);
 
   /// get bulk modulus
   AKANTU_GET_MACRO(Kappa, kpa, Real);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// First Lamé coefficient
   Real lambda;
 
   /// Second Lamé coefficient (shear modulus)
   Real mu;
 
   /// Bulk modulus
   Real kpa;
 
   /// defines if the stiffness was computed
   bool was_stiffness_assembled;
 };
 
 }  // akantu
 
 #include "material_elastic_inline_impl.cc"
 
 #endif /* __AKANTU_MATERIAL_ELASTIC_HH__ */
diff --git a/src/model/solid_mechanics/materials/material_elastic_linear_anisotropic.hh b/src/model/solid_mechanics/materials/material_elastic_linear_anisotropic.hh
index 24f87cef8..8369e75e3 100644
--- a/src/model/solid_mechanics/materials/material_elastic_linear_anisotropic.hh
+++ b/src/model/solid_mechanics/materials/material_elastic_linear_anisotropic.hh
@@ -1,128 +1,128 @@
 /**
  * @file   material_elastic_linear_anisotropic.hh
  *
  * @author Till Junge <till.junge@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Aug 18 2015
  *
  * @brief  Orthotropic elastic material
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "material.hh"
 #include "material_elastic.hh"
 #include <vector>
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_ELASTIC_LINEAR_ANISOTROPIC_HH__
 #define __AKANTU_MATERIAL_ELASTIC_LINEAR_ANISOTROPIC_HH__
 
 namespace akantu {
 
 /**
  * General linear anisotropic elastic material
  * The only constraint on the elastic tensor is that it can be represented
  * as a symmetric 6x6 matrix (3D) or 3x3 (2D).
  *
  * parameters in the material files :
  *   - rho  : density (default: 0)
  *   - C_ij  : entry on the stiffness
  */
 template <UInt Dim>
 class MaterialElasticLinearAnisotropic : public virtual Material {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   MaterialElasticLinearAnisotropic(SolidMechanicsModel & model,
                                    const ID & id = "", bool symmetric = true);
 
-  ~MaterialElasticLinearAnisotropic();
+  ~MaterialElasticLinearAnisotropic() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
-  virtual void initMaterial();
+  void initMaterial() override;
 
   /// constitutive law for all element of a type
-  virtual void computeStress(ElementType el_type,
-                             GhostType ghost_type = _not_ghost);
+  void computeStress(ElementType el_type,
+                     GhostType ghost_type = _not_ghost) override;
 
   /// compute the tangent stiffness matrix for an element type
   void computeTangentModuli(const ElementType & el_type,
                             Array<Real> & tangent_matrix,
-                            GhostType ghost_type = _not_ghost);
+                            GhostType ghost_type = _not_ghost) override;
 
-  virtual void updateInternalParameters();
+  void updateInternalParameters() override;
 
-  virtual bool hasStiffnessMatrixChanged() {
+  bool hasStiffnessMatrixChanged() override {
     return (! was_stiffness_assembled);
   }
 
 protected:
   // compute C from Cprime
   void rotateCprime();
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// compute max wave celerity
-  virtual Real getCelerity(const Element & element) const;
+  Real getCelerity(const Element & element) const override;
 
   AKANTU_GET_MACRO(VoigtStiffness, C, Matrix<Real>);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
-  typedef VoigtHelper<Dim> voigt_h;
+  using voigt_h = VoigtHelper<1U>;
 
   /// direction matrix and vectors
   std::vector<Vector<Real> *> dir_vecs;
 
   Matrix<Real> rot_mat;
   /// Elastic stiffness tensor in material frame and full vectorised notation
   Matrix<Real> Cprime;
   /// Elastic stiffness tensor in voigt notation
   Matrix<Real> C;
   /// eigenvalues of stiffness tensor
   Vector<Real> eigC;
 
   bool symmetric;
 
   /// viscous proportion
   Real alpha;
 
   /// defines if the stiffness was computed
   bool was_stiffness_assembled;
 };
 } // akantu
 
 #endif /* __AKANTU_MATERIAL_ELASTIC_LINEAR_ANISOTROPIC_HH__ */
diff --git a/src/model/solid_mechanics/materials/material_elastic_orthotropic.cc b/src/model/solid_mechanics/materials/material_elastic_orthotropic.cc
index 5b81ee1fe..2ed201e57 100644
--- a/src/model/solid_mechanics/materials/material_elastic_orthotropic.cc
+++ b/src/model/solid_mechanics/materials/material_elastic_orthotropic.cc
@@ -1,213 +1,212 @@
 /**
  * @file   material_elastic_orthotropic.cc
  *
  * @author Till Junge <till.junge@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Orthotropic elastic material
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #include "material_elastic_orthotropic.hh"
 #include "solid_mechanics_model.hh"
 #include <algorithm>
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template<UInt Dim>
 MaterialElasticOrthotropic<Dim>::MaterialElasticOrthotropic(SolidMechanicsModel & model,
                                                             const ID & id)  :
   Material(model, id),
   MaterialElasticLinearAnisotropic<Dim>(model, id) {
   AKANTU_DEBUG_IN();
   this->registerParam("E1",   E1  , Real(0.), _pat_parsmod, "Young's modulus (n1)");
   this->registerParam("E2",   E2  , Real(0.), _pat_parsmod, "Young's modulus (n2)");
   this->registerParam("nu12", nu12, Real(0.), _pat_parsmod, "Poisson's ratio (12)");
   this->registerParam("G12",  G12 , Real(0.), _pat_parsmod, "Shear modulus (12)");
 
   if (Dim > 2) {
     this->registerParam("E3"  , E3  , Real(0.), _pat_parsmod, "Young's modulus (n3)");
     this->registerParam("nu13", nu13, Real(0.), _pat_parsmod, "Poisson's ratio (13)");
     this->registerParam("nu23", nu23, Real(0.), _pat_parsmod, "Poisson's ratio (23)");
     this->registerParam("G13" , G13 , Real(0.), _pat_parsmod, "Shear modulus (13)");
     this->registerParam("G23" , G23 , Real(0.), _pat_parsmod, "Shear modulus (23)");
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
-template<UInt Dim>
-MaterialElasticOrthotropic<Dim>::~MaterialElasticOrthotropic() {
-}
+template <UInt Dim>
+MaterialElasticOrthotropic<Dim>::~MaterialElasticOrthotropic() = default;
 
 /* -------------------------------------------------------------------------- */
 template<UInt Dim>
 void MaterialElasticOrthotropic<Dim>::initMaterial() {
   AKANTU_DEBUG_IN();
   Material::initMaterial();
 
   updateInternalParameters();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real vector_norm(Vector<Real> & vec) {
   Real norm = 0;
   for (UInt i = 0 ;  i < vec.size() ; ++i) {
     norm += vec(i)*vec(i);
   }
   return std::sqrt(norm);
 }
 
 /* -------------------------------------------------------------------------- */
 template<UInt Dim>
 void MaterialElasticOrthotropic<Dim>::updateInternalParameters() {
   /* 1) construction of temporary material frame stiffness tensor------------ */
   // http://solidmechanics.org/Text/Chapter3_2/Chapter3_2.php#Sect3_2_13
   Real nu21 = nu12 * E2 / E1;
   Real nu31 = nu13 * E3 / E1;
   Real nu32 = nu23 * E3 / E2;
 
   // Full (i.e. dim^2 by dim^2) stiffness tensor in material frame
   if (Dim == 1) {
     AKANTU_DEBUG_ERROR("Dimensions 1 not implemented: makes no sense to have orthotropy for 1D");
   }
 
   Real Gamma;
 
   if (Dim == 3)
     Gamma = 1/(1 - nu12 * nu21 - nu23 * nu32 - nu31 * nu13 - 2 * nu21 * nu32 * nu13);
 
   if (Dim == 2)
     Gamma = 1/(1 - nu12 * nu21);
 
   // Lamé's first parameters
   this->Cprime(0, 0) = E1 * (1 - nu23 * nu32) * Gamma;
   this->Cprime(1, 1) = E2 * (1 - nu13 * nu31) * Gamma;
   if (Dim == 3)
     this->Cprime(2, 2) = E3 * (1 - nu12 * nu21) * Gamma;
 
   // normalised poisson's ratio's
   this->Cprime(1, 0) = this->Cprime(0, 1) = E1 * (nu21 + nu31 * nu23) * Gamma;
   if (Dim == 3) {
     this->Cprime(2, 0) = this->Cprime(0, 2) = E1 * (nu31 + nu21 * nu32) * Gamma;
     this->Cprime(2, 1) = this->Cprime(1, 2) = E2 * (nu32 + nu12 * nu31) * Gamma;
   }
 
   // Lamé's second parameters (shear moduli)
   if (Dim == 3) {
     this->Cprime(3, 3) = G23;
     this->Cprime(4, 4) = G13;
     this->Cprime(5, 5) = G12;
   }
   else
     this->Cprime(2, 2) = G12;
 
 
   /* 1) rotation of C into the global frame */
   this->rotateCprime();
   this->C.eig(this->eigC);
 
 }
 
 /* -------------------------------------------------------------------------- */
 
 template<UInt dim>
 inline void MaterialElasticOrthotropic<dim>::computePotentialEnergyOnQuad(const Matrix<Real> & grad_u,
                                                                const Matrix<Real> & sigma,
                                                                Real & epot) {
   epot = .5 * sigma.doubleDot(grad_u);
 }
 
 /* -------------------------------------------------------------------------- */
 template<UInt spatial_dimension>
 void MaterialElasticOrthotropic<spatial_dimension>::computePotentialEnergy(ElementType el_type,
                                                                            GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Material::computePotentialEnergy(el_type, ghost_type);
   
   AKANTU_DEBUG_ASSERT(!this->finite_deformation,"finite deformation not possible in material orthotropic (TO BE IMPLEMENTED)");
 
 
   if(ghost_type != _not_ghost) return;
   Array<Real>::scalar_iterator epot = this->potential_energy(el_type, ghost_type).begin();
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
 
   computePotentialEnergyOnQuad(grad_u, sigma, *epot);
   ++epot;
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template<UInt spatial_dimension>
 void MaterialElasticOrthotropic<spatial_dimension>::computePotentialEnergyByElement(ElementType type, UInt index,
 										    Vector<Real> & epot_on_quad_points) {
 
   AKANTU_DEBUG_ASSERT(!this->finite_deformation,"finite deformation not possible in material orthotropic (TO BE IMPLEMENTED)");
 
   Array<Real>::matrix_iterator gradu_it =
     this->gradu(type).begin(spatial_dimension,
                              spatial_dimension);
   Array<Real>::matrix_iterator gradu_end =
     this->gradu(type).begin(spatial_dimension,
                              spatial_dimension);
   Array<Real>::matrix_iterator stress_it =
     this->stress(type).begin(spatial_dimension,
                              spatial_dimension);
 
   UInt nb_quadrature_points = this->fem.getNbIntegrationPoints(type);
 
   gradu_it  += index*nb_quadrature_points;
   gradu_end += (index+1)*nb_quadrature_points;
   stress_it  += index*nb_quadrature_points;
 
   Real * epot_quad = epot_on_quad_points.storage();
 
   Matrix<Real> grad_u(spatial_dimension, spatial_dimension);
 
   for(;gradu_it != gradu_end; ++gradu_it, ++stress_it, ++epot_quad) {
     grad_u.copy(*gradu_it);
 
     computePotentialEnergyOnQuad(grad_u, *stress_it, *epot_quad);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 INSTANTIATE_MATERIAL(elastic_orthotropic, MaterialElasticOrthotropic);
 
 } // akantu
diff --git a/src/model/solid_mechanics/materials/material_elastic_orthotropic.hh b/src/model/solid_mechanics/materials/material_elastic_orthotropic.hh
index e0a6a4c1d..acad49ea3 100644
--- a/src/model/solid_mechanics/materials/material_elastic_orthotropic.hh
+++ b/src/model/solid_mechanics/materials/material_elastic_orthotropic.hh
@@ -1,149 +1,147 @@
 /**
  * @file   material_elastic_orthotropic.hh
  *
  * @author Till Junge <till.junge@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Orthotropic elastic material
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "material_elastic_linear_anisotropic.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_ELASTIC_ORTHOTROPIC_HH__
 #define __AKANTU_MATERIAL_ELASTIC_ORTHOTROPIC_HH__
 
 namespace akantu {
 
 /**
  * Orthotropic elastic material
  *
  * parameters in the material files :
  *   - n1   : direction of x-axis in material base, normalisation not necessary (default: {1, 0, 0})
  *   - n2   : direction of y-axis in material base, normalisation not necessary (default: {0, 1, 0})
  *   - n3   : direction of z-axis in material base, normalisation not necessary (default: {0, 0, 1})
  *   - rho  : density (default: 0)
  *   - E1   : Young's modulus along n1 (default: 0)
  *   - E2   : Young's modulus along n2 (default: 0)
  *   - E3   : Young's modulus along n3 (default: 0)
  *   - nu12 : Poisson's ratio along 12 (default: 0)
  *   - nu13 : Poisson's ratio along 13 (default: 0)
  *   - nu23 : Poisson's ratio along 23 (default: 0)
  *   - G12  : Shear modulus along 12 (default: 0)
  *   - G13  : Shear modulus along 13 (default: 0)
  *   - G23  : Shear modulus along 23 (default: 0)
  */
 
 template<UInt Dim>
 class MaterialElasticOrthotropic :
   public MaterialElasticLinearAnisotropic<Dim> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
 
   MaterialElasticOrthotropic(SolidMechanicsModel & model, const ID & id = "");
 
-  ~MaterialElasticOrthotropic();
+  ~MaterialElasticOrthotropic() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
+  void initMaterial() override;
 
-  virtual void initMaterial();
-
-  virtual void updateInternalParameters();
-
+  void updateInternalParameters() override;
 
   /// compute the elastic potential energy
-  virtual void computePotentialEnergy(ElementType el_type,
-				      GhostType ghost_type = _not_ghost);
-
-  virtual void computePotentialEnergyByElement(ElementType type, UInt index,
-					       Vector<Real> & epot_on_quad_points);
+  void computePotentialEnergy(ElementType el_type,
+                              GhostType ghost_type = _not_ghost) override;
 
+  void
+  computePotentialEnergyByElement(ElementType type, UInt index,
+                                  Vector<Real> & epot_on_quad_points) override;
 
 protected:
 
   inline void computePotentialEnergyOnQuad(const Matrix<Real> & grad_u,
 					   const Matrix<Real> & sigma,
 					   Real & epot);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   AKANTU_GET_MACRO(E1, E1, Real);
   AKANTU_GET_MACRO(E2, E2, Real);
   AKANTU_GET_MACRO(E3, E3, Real);
   AKANTU_GET_MACRO(Nu12, nu12, Real);
   AKANTU_GET_MACRO(Nu13, nu13, Real);
   AKANTU_GET_MACRO(Nu23, nu23, Real);
   AKANTU_GET_MACRO(G12, G12, Real);
   AKANTU_GET_MACRO(G13, G13, Real);
   AKANTU_GET_MACRO(G23, G23, Real);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// the n1 young modulus
   Real E1;
 
   /// the n2 young modulus
   Real E2;
 
   /// the n3 young modulus
   Real E3;
 
   /// 12 Poisson coefficient
   Real nu12;
 
   /// 13 Poisson coefficient
   Real nu13;
 
   /// 23 Poisson coefficient
   Real nu23;
 
   /// 12 shear modulus
   Real G12;
 
   /// 13 shear modulus
   Real G13;
 
   /// 23 shear modulus
   Real G23;
 };
 
 
 } // akantu
 
 #endif /* __AKANTU_MATERIAL_ELASTIC_ORTHOTROPIC_HH__ */
diff --git a/src/model/solid_mechanics/materials/material_finite_deformation/material_neohookean.cc b/src/model/solid_mechanics/materials/material_finite_deformation/material_neohookean.cc
index b9af218c6..1f2e92ac8 100644
--- a/src/model/solid_mechanics/materials/material_finite_deformation/material_neohookean.cc
+++ b/src/model/solid_mechanics/materials/material_finite_deformation/material_neohookean.cc
@@ -1,292 +1,287 @@
 /**
  * @file   material_neohookean.cc
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  *
  * @date creation: Mon Apr 08 2013
  * @date last modification: Tue Aug 04 2015
  *
  * @brief  Specialization of the material class for finite deformation
  * neo-hookean material
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "material_neohookean.hh"
 #include "solid_mechanics_model.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 MaterialNeohookean<spatial_dimension>::MaterialNeohookean(
     SolidMechanicsModel & model, const ID & id)
     : PlaneStressToolbox<spatial_dimension>(model, id) {
   AKANTU_DEBUG_IN();
 
   this->registerParam("E", E, Real(0.), _pat_parsable | _pat_modifiable,
                       "Young's modulus");
   this->registerParam("nu", nu, Real(0.5), _pat_parsable | _pat_modifiable,
                       "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->finite_deformation = true;
   this->initialize_third_axis_deformation = true;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialNeohookean<spatial_dimension>::initMaterial() {
   AKANTU_DEBUG_IN();
   PlaneStressToolbox<spatial_dimension>::initMaterial();
   if (spatial_dimension == 1)
     nu = 0.;
   this->updateInternalParameters();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <> void MaterialNeohookean<2>::initMaterial() {
   AKANTU_DEBUG_IN();
   PlaneStressToolbox<2>::initMaterial();
   this->updateInternalParameters();
 
   if (this->plane_stress)
     this->third_axis_deformation.setDefaultValue(1.);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialNeohookean<spatial_dimension>::updateInternalParameters() {
   lambda = nu * E / ((1 + nu) * (1 - 2 * nu));
   mu = E / (2 * (1 + nu));
 
   kpa = lambda + 2. / 3. * mu;
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void MaterialNeohookean<dim>::computeCauchyStressPlaneStress(
     ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   PlaneStressToolbox<dim>::computeCauchyStressPlaneStress(el_type, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void MaterialNeohookean<2>::computeCauchyStressPlaneStress(
     ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Array<Real>::matrix_iterator gradu_it =
       this->gradu(el_type, ghost_type).begin(2, 2);
 
   Array<Real>::matrix_iterator gradu_end =
       this->gradu(el_type, ghost_type).end(2, 2);
 
   Array<Real>::matrix_iterator piola_it =
       this->piola_kirchhoff_2(el_type, ghost_type).begin(2, 2);
 
   Array<Real>::matrix_iterator stress_it =
       this->stress(el_type, ghost_type).begin(2, 2);
 
   Array<Real>::const_scalar_iterator c33_it =
       this->third_axis_deformation(el_type, ghost_type).begin();
 
   Matrix<Real> F_tensor(2, 2);
 
   for (; gradu_it != gradu_end; ++gradu_it, ++piola_it, ++stress_it, ++c33_it) {
     Matrix<Real> & grad_u = *gradu_it;
     Matrix<Real> & piola = *piola_it;
     Matrix<Real> & sigma = *stress_it;
 
     gradUToF<2>(grad_u, F_tensor);
     computeCauchyStressOnQuad<2>(F_tensor, piola, sigma, *c33_it);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void MaterialNeohookean<dim>::computeStress(ElementType el_type,
                                             GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
   computeStressOnQuad(grad_u, sigma);
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void MaterialNeohookean<2>::computeStress(ElementType el_type,
                                           GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   if (this->plane_stress) {
     PlaneStressToolbox<2>::computeStress(el_type, ghost_type);
 
     Array<Real>::const_scalar_iterator c33_it =
         this->third_axis_deformation(el_type, ghost_type).begin();
 
     MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
     computeStressOnQuad(grad_u, sigma, *c33_it);
     ++c33_it;
     MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
   } else {
 
     MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
     computeStressOnQuad(grad_u, sigma);
     MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void MaterialNeohookean<dim>::computeThirdAxisDeformation(
-    __attribute__((unused)) ElementType el_type,
-    __attribute__((unused)) GhostType ghost_type) {
-  AKANTU_DEBUG_IN();
-
-  AKANTU_DEBUG_OUT();
-}
+    ElementType /*el_type*/, GhostType /*ghost_type*/) {}
 
 /* -------------------------------------------------------------------------- */
 template <>
 void MaterialNeohookean<2>::computeThirdAxisDeformation(ElementType el_type,
                                                         GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(this->plane_stress, "The third component of the strain "
                                           "can only be computed for 2D "
                                           "problems in Plane Stress!!");
 
   Array<Real>::scalar_iterator c33_it =
       this->third_axis_deformation(el_type, ghost_type).begin();
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
   computeThirdAxisDeformationOnQuad(grad_u, *c33_it);
   ++c33_it;
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialNeohookean<spatial_dimension>::computePotentialEnergy(
     ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Material::computePotentialEnergy(el_type, ghost_type);
 
   if (ghost_type != _not_ghost)
     return;
   Array<Real>::scalar_iterator epot =
       this->potential_energy(el_type, ghost_type).begin();
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type);
 
   computePotentialEnergyOnQuad(grad_u, *epot);
   ++epot;
 
   MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialNeohookean<spatial_dimension>::computeTangentModuli(
     __attribute__((unused)) const ElementType & el_type,
     Array<Real> & tangent_matrix,
     __attribute__((unused)) GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   MATERIAL_TANGENT_QUADRATURE_POINT_LOOP_BEGIN(tangent_matrix);
   computeTangentModuliOnQuad(tangent, grad_u);
   MATERIAL_TANGENT_QUADRATURE_POINT_LOOP_END;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void MaterialNeohookean<2>::computeTangentModuli(__attribute__((unused))
                                                  const ElementType & el_type,
                                                  Array<Real> & tangent_matrix,
                                                  __attribute__((unused))
                                                  GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   if (this->plane_stress) {
     PlaneStressToolbox<2>::computeStress(el_type, ghost_type);
 
     Array<Real>::const_scalar_iterator c33_it =
         this->third_axis_deformation(el_type, ghost_type).begin();
 
     MATERIAL_TANGENT_QUADRATURE_POINT_LOOP_BEGIN(tangent_matrix);
     computeTangentModuliOnQuad(tangent, grad_u, *c33_it);
     ++c33_it;
     MATERIAL_TANGENT_QUADRATURE_POINT_LOOP_END;
 
   } else {
 
     MATERIAL_TANGENT_QUADRATURE_POINT_LOOP_BEGIN(tangent_matrix);
     computeTangentModuliOnQuad(tangent, grad_u);
     MATERIAL_TANGENT_QUADRATURE_POINT_LOOP_END;
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 Real MaterialNeohookean<spatial_dimension>::getPushWaveSpeed(
     __attribute__((unused)) const Element & element) const {
   return sqrt((this->lambda + 2 * this->mu) / this->rho);
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 Real MaterialNeohookean<spatial_dimension>::getShearWaveSpeed(
     __attribute__((unused)) const Element & element) const {
   return sqrt(this->mu / this->rho);
 }
 
 /* -------------------------------------------------------------------------- */
 
 INSTANTIATE_MATERIAL(neohookean, MaterialNeohookean);
 
-} // akantu
+} // namespace akantu
diff --git a/src/model/solid_mechanics/materials/material_finite_deformation/material_neohookean.hh b/src/model/solid_mechanics/materials/material_finite_deformation/material_neohookean.hh
index a0bcbd715..ea492acf2 100644
--- a/src/model/solid_mechanics/materials/material_finite_deformation/material_neohookean.hh
+++ b/src/model/solid_mechanics/materials/material_finite_deformation/material_neohookean.hh
@@ -1,171 +1,174 @@
 /**
  * @file   material_neohookean.hh
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Oct 08 2015
  *
  * @brief  Material isotropic elastic
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "material.hh"
 #include "plane_stress_toolbox.hh"
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_NEOHOOKEAN_HH__
 #define __AKANTU_MATERIAL_NEOHOOKEAN_HH__
 
 namespace akantu {
 
 /**
  * Material elastic isotropic
  *
  * parameters in the material files :
  *   - rho : density (default: 0)
  *   - E   : Young's modulus (default: 0)
  *   - nu  : Poisson's ratio (default: 1/2)
  *   - Plane_Stress : if 0: plane strain, else: plane stress (default: 0)
  */
 template<UInt spatial_dimension>
 class MaterialNeohookean : public virtual PlaneStressToolbox<spatial_dimension> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
 
   MaterialNeohookean(SolidMechanicsModel & model, const ID & id = "");
 
-  virtual ~MaterialNeohookean() {};
+  ~MaterialNeohookean() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
 
   /// initialize the material computed parameter
-  virtual void initMaterial();
+  void initMaterial() override;
 
   /// constitutive law for all element of a type
-  virtual void computeStress(ElementType el_type, GhostType ghost_type = _not_ghost);
+  void computeStress(ElementType el_type,
+                     GhostType ghost_type = _not_ghost) override;
 
   /// Computation of the cauchy stress for plane strain materials
-  virtual void computeCauchyStressPlaneStress(ElementType el_type, GhostType ghost_type = _not_ghost);
+  void
+  computeCauchyStressPlaneStress(ElementType el_type,
+                                 GhostType ghost_type = _not_ghost) override;
 
   /// Non linear computation of the third direction strain in 2D plane stress case
-  virtual void computeThirdAxisDeformation(ElementType el_type, GhostType ghost_type = _not_ghost);
+  void computeThirdAxisDeformation(ElementType el_type,
+                                   GhostType ghost_type = _not_ghost);
 
   /// compute the elastic potential energy
-  virtual void computePotentialEnergy(ElementType el_type,
-                                      GhostType ghost_type = _not_ghost);
+  void computePotentialEnergy(ElementType el_type,
+                              GhostType ghost_type = _not_ghost) override;
 
   /// compute the tangent stiffness matrix for an element type
   void computeTangentModuli(const ElementType & el_type,
                             Array<Real> & tangent_matrix,
-                            GhostType ghost_type = _not_ghost);
+                            GhostType ghost_type = _not_ghost) override;
 
   /// compute the p-wave speed in the material
-  virtual Real getPushWaveSpeed(const Element & element) const;
+  Real getPushWaveSpeed(const Element & element) const override;
 
   /// compute the s-wave speed in the material
-  virtual Real getShearWaveSpeed(const Element & element) const;
+  Real getShearWaveSpeed(const Element & element) const override;
 
 protected:
 
   /// constitutive law for a given quadrature point
   inline void computePiolaKirchhoffOnQuad(const Matrix<Real> &E,
                                           Matrix<Real> &S);
 
   /// constitutive law for a given quadrature point (first piola)
   inline void computeFirstPiolaKirchhoffOnQuad(const Matrix<Real> &grad_u,
                                                const Matrix<Real> &S,
                                                Matrix<Real> &P);
 
   /// constitutive law for a given quadrature point
   inline void computeDeltaStressOnQuad(const Matrix<Real> & grad_u, const Matrix<Real> & grad_delta_u,
         Matrix<Real> & delta_S);
 
   /// constitutive law for a given quadrature point
   inline void computeStressOnQuad(Matrix<Real> & grad_u,
                                   Matrix<Real> & S,
                                   const Real & C33 = 1.0 );
 
   /// constitutive law for a given quadrature point
   inline void computeThirdAxisDeformationOnQuad(Matrix<Real> & grad_u, Real & c33_value);
 
   /// constitutive law for a given quadrature point
   //inline void updateStressOnQuad(const Matrix<Real> & sigma,
   //                              Matrix<Real> & cauchy_sigma);
 
   /// compute the potential energy for a quadrature point
   inline void computePotentialEnergyOnQuad(const Matrix<Real> & grad_u,
                                            Real & epot);
 
   /// compute the tangent stiffness matrix for an element
   void computeTangentModuliOnQuad(Matrix<Real> & tangent,
                                   Matrix<Real> & grad_u,
                                   const Real & C33 = 1.0 );
 
   /// recompute the lame coefficient if E or nu changes
-  virtual void updateInternalParameters();
-
+  void updateInternalParameters() override;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
 
   /// the young modulus
   Real E;
 
   /// Poisson coefficient
   Real nu;
 
   /// First Lamé coefficient
   Real lambda;
 
   /// Second Lamé coefficient (shear modulus)
   Real mu;
 
   /// Bulk modulus
   Real kpa;
 
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 #include "material_neohookean_inline_impl.cc"
 
 } // akantu
 
 #endif /* __AKANTU_MATERIAL_NEOHOOKEAN_HH__ */
diff --git a/src/model/solid_mechanics/materials/material_finite_deformation/material_neohookean_inline_impl.cc b/src/model/solid_mechanics/materials/material_finite_deformation/material_neohookean_inline_impl.cc
index e7761ae20..eb3480ba6 100644
--- a/src/model/solid_mechanics/materials/material_finite_deformation/material_neohookean_inline_impl.cc
+++ b/src/model/solid_mechanics/materials/material_finite_deformation/material_neohookean_inline_impl.cc
@@ -1,190 +1,191 @@
 /**
  * @file   material_neohookean_inline_impl.cc
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  *
  * @date creation: Mon Apr 08 2013
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Implementation of the inline functions of the material elastic
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #include <iostream>
 
-#include <cmath>
 #include "material_neohookean.hh"
+#include <cmath>
+#include <utility>
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void MaterialNeohookean<dim>::computeDeltaStressOnQuad(
     __attribute__((unused)) const Matrix<Real> & grad_u,
     __attribute__((unused)) const Matrix<Real> & grad_delta_u,
     __attribute__((unused)) Matrix<Real> & delta_S) {}
 
 //! computes the second piola kirchhoff stress, called S
 template <UInt dim>
 inline void MaterialNeohookean<dim>::computeStressOnQuad(Matrix<Real> & grad_u,
                                                          Matrix<Real> & S,
                                                          const Real & C33) {
   // Neo hookean book
   Matrix<Real> F(dim, dim);
   Matrix<Real> C(dim, dim); // Right green
   Matrix<Real> Cminus(dim, dim); // Right green
 
   this->template gradUToF<dim>(grad_u, F);
   this->rightCauchy(F, C);
   Real J = F.det() * sqrt(C33); // the term  sqrt(C33) corresponds to the off
                                 // plane strain (2D plane stress)
   //  std::cout<<"det(F) -> "<<J<<std::endl;
   Cminus.inverse(C);
 
   for (UInt i = 0; i < dim; ++i)
     for (UInt j = 0; j < dim; ++j)
       S(i, j) = (i == j) * mu + (lambda * log(J) - mu) * Cminus(i, j);
 }
 
 /* -------------------------------------------------------------------------- */
 class C33_NR : public Math::NewtonRaphsonFunctor {
 public:
   C33_NR(std::string name, const Real & lambda, const Real & mu,
          const Matrix<Real> & C)
-      : NewtonRaphsonFunctor(name), lambda(lambda), mu(mu), C(C) {}
+      : NewtonRaphsonFunctor(std::move(name)), lambda(lambda), mu(mu), C(C) {}
 
-  inline Real f(Real x) const {
+  inline Real f(Real x) const override {
     return (this->lambda / 2. *
                 (std::log(x) + std::log(this->C(0, 0) * this->C(1, 1) -
                                         Math::pow<2>(this->C(0, 1)))) +
             this->mu * (x - 1.));
   }
 
-  inline Real f_prime(Real x) const {
+  inline Real f_prime(Real x) const override {
     AKANTU_DEBUG_ASSERT(std::abs(x) > Math::getTolerance(),
                         "x is zero (x should be the off plane right Cauchy"
                             << " measure in this function so you made a mistake"
                             << " somewhere else that lead to a zero here!!!");
     return (this->lambda / (2. * x) + this->mu);
   }
 
 private:
   const Real & lambda;
   const Real & mu;
   const Matrix<Real> & C;
 };
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void MaterialNeohookean<dim>::computeThirdAxisDeformationOnQuad(
     Matrix<Real> & grad_u, Real & c33_value) {
   // Neo hookean book
   Matrix<Real> F(dim, dim);
   Matrix<Real> C(dim, dim); // Right green
 
   this->template gradUToF<dim>(grad_u, F);
   this->rightCauchy(F, C);
 
   Math::NewtonRaphson nr(1e-5, 100);
   c33_value = nr.solve(
       C33_NR("Neohookean_plan_stress", this->lambda, this->mu, C), c33_value);
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void
 MaterialNeohookean<dim>::computePiolaKirchhoffOnQuad(const Matrix<Real> & E,
                                                      Matrix<Real> & S) {
 
   Real trace = E.trace(); /// trace = (\nabla u)_{kk}
 
   /// \sigma_{ij} = \lambda * (\nabla u)_{kk} * \delta_{ij} + \mu * (\nabla
   /// u_{ij} + \nabla u_{ji})
   for (UInt i = 0; i < dim; ++i)
     for (UInt j = 0; j < dim; ++j)
       S(i, j) = (i == j) * lambda * trace + 2.0 * mu * E(i, j);
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void MaterialNeohookean<dim>::computeFirstPiolaKirchhoffOnQuad(
     const Matrix<Real> & grad_u, const Matrix<Real> & S, Matrix<Real> & P) {
 
   Matrix<Real> F(dim, dim);
   Matrix<Real> C(dim, dim); // Right green
 
   this->template gradUToF<dim>(grad_u, F);
 
   // first Piola-Kirchhoff is computed as the product of the deformation
   // gracient
   // tensor and the second Piola-Kirchhoff stress tensor
 
   P = F * S;
 }
 
 /**************************************************************************************/
 /*  Computation of the potential energy for a this neo hookean material */
 template <UInt dim>
 inline void MaterialNeohookean<dim>::computePotentialEnergyOnQuad(
     const Matrix<Real> & grad_u, Real & epot) {
   Matrix<Real> F(dim, dim);
   Matrix<Real> C(dim, dim); // Right green
 
   this->template gradUToF<dim>(grad_u, F);
   this->rightCauchy(F, C);
   Real J = F.det();
   //  std::cout<<"det(F) -> "<<J<<std::endl;
 
   epot =
       0.5 * lambda * pow(log(J), 2.) + mu * (-log(J) + 0.5 * (C.trace() - dim));
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void MaterialNeohookean<dim>::computeTangentModuliOnQuad(
     Matrix<Real> & tangent, Matrix<Real> & grad_u, const Real & C33) {
 
   // Neo hookean book
   UInt cols = tangent.cols();
   UInt rows = tangent.rows();
   Matrix<Real> F(dim, dim);
   Matrix<Real> C(dim, dim);
   Matrix<Real> Cminus(dim, dim);
   this->template gradUToF<dim>(grad_u, F);
   this->rightCauchy(F, C);
   Real J = F.det() * sqrt(C33);
   //  std::cout<<"det(F) -> "<<J<<std::endl;
   Cminus.inverse(C);
 
   for (UInt m = 0; m < rows; m++) {
     UInt i = VoigtHelper<dim>::vec[m][0];
     UInt j = VoigtHelper<dim>::vec[m][1];
     for (UInt n = 0; n < cols; n++) {
       UInt k = VoigtHelper<dim>::vec[n][0];
       UInt l = VoigtHelper<dim>::vec[n][1];
 
       // book belytchko
       tangent(m, n) = lambda * Cminus(i, j) * Cminus(k, l) +
                       (mu - lambda * log(J)) * (Cminus(i, k) * Cminus(j, l) +
                                                 Cminus(i, l) * Cminus(k, j));
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
diff --git a/src/model/solid_mechanics/materials/material_plastic/material_linear_isotropic_hardening.hh b/src/model/solid_mechanics/materials/material_plastic/material_linear_isotropic_hardening.hh
index 2ebbf5280..5b5d97dd6 100644
--- a/src/model/solid_mechanics/materials/material_plastic/material_linear_isotropic_hardening.hh
+++ b/src/model/solid_mechanics/materials/material_plastic/material_linear_isotropic_hardening.hh
@@ -1,121 +1,122 @@
 /**
  * @file   material_linear_isotropic_hardening.hh
  *
  * @author Ramin Aghababaei <ramin.aghababaei@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: Fri Jun 18 2010
  * @date last modification: Mon Jun 01 2015
  *
  * @brief  Specialization of the material class for isotropic finite deformation linear hardening plasticity
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_voigthelper.hh"
 #include "material_plastic.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_LINEAR_ISOTROPIC_HARDENING_HH__
 #define __AKANTU_MATERIAL_LINEAR_ISOTROPIC_HARDENING_HH__
 
 namespace akantu {
 
 /**
  * Material plastic with a linear evolution of the yielding stress
  */
 template <UInt spatial_dimension>
 class MaterialLinearIsotropicHardening : public MaterialPlastic<spatial_dimension> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
 
   MaterialLinearIsotropicHardening(SolidMechanicsModel & model, const ID & id = "");
   MaterialLinearIsotropicHardening(SolidMechanicsModel & model,
                                    UInt dim,
                                    const Mesh & mesh,
                                    FEEngine & fe_engine,
                                    const ID & id = "");
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// constitutive law for all element of a type
-  virtual void computeStress(ElementType el_type, GhostType ghost_type = _not_ghost);
+  void computeStress(ElementType el_type,
+                     GhostType ghost_type = _not_ghost) override;
 
   /// compute the tangent stiffness matrix for an element type
   void computeTangentModuli(const ElementType & el_type,
                             Array<Real> & tangent_matrix,
-                            GhostType ghost_type = _not_ghost);
+                            GhostType ghost_type = _not_ghost) override;
 
 protected:
   /// Infinitesimal deformations
   inline void computeStressOnQuad(const Matrix<Real> & grad_u,
                                   const Matrix<Real> & previous_grad_u,
                                   Matrix<Real> & sigma,
                                   const Matrix<Real> & previous_sigma,
                                   Matrix<Real> & inelas_strain,
                                   const Matrix<Real> & previous_inelas_strain,
                                   Real & iso_hardening,
                                   const Real & previous_iso_hardening,
                                   const Real & sigma_th,
                                   const Real & previous_sigma_th);
   /// Finite deformations
   inline void computeStressOnQuad(const Matrix<Real> & grad_u,
                                   const Matrix<Real> & previous_grad_u,
                                   Matrix<Real> & sigma,
                                   const Matrix<Real> & previous_sigma,
                                   Matrix<Real> & inelas_strain,
                                   const Matrix<Real> & previous_inelas_strain,
                                   Real & iso_hardening,
                                   const Real & previous_iso_hardening,
                                   const Real & sigma_th,
                                   const Real & previous_sigma_th,
 				  const Matrix<Real> & F_tensor);
 
   inline void computeTangentModuliOnQuad(Matrix<Real> & tangent,
                                          const Matrix<Real> & grad_u,
                                          const Matrix<Real> & previous_grad_u,
                                          const Matrix<Real> & sigma_tensor,
                                          const Matrix<Real> & previous_sigma_tensor,
                                          const Real & iso_hardening) const;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
 
 };
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 #include "material_linear_isotropic_hardening_inline_impl.cc"
 
 } // akantu
 
 #endif /* __AKANTU_MATERIAL_LINEAR_ISOTROPIC_HARDENING_HH__ */
diff --git a/src/model/solid_mechanics/materials/material_plastic/material_plastic.hh b/src/model/solid_mechanics/materials/material_plastic/material_plastic.hh
index 7830851f9..2cff5aa8d 100644
--- a/src/model/solid_mechanics/materials/material_plastic/material_plastic.hh
+++ b/src/model/solid_mechanics/materials/material_plastic/material_plastic.hh
@@ -1,142 +1,143 @@
 /**
  * @file   material_plastic.hh
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Oct 08 2015
  *
  * @brief  Common interface for plastic materials
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "material_elastic.hh"
 /* -------------------------------------------------------------------------- */
 
 
 #ifndef __AKANTU_MATERIAL_PLASTIC_HH__
 #define __AKANTU_MATERIAL_PLASTIC_HH__
 
 namespace akantu {
 
 /**
  * Parent class for the plastic constitutive laws
  * parameters in the material files :
  *   - h : Hardening parameter (default: 0)
  *   - sigmay : Yield stress
  */
 template<UInt dim>
 class MaterialPlastic : public MaterialElastic<dim> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
 
   MaterialPlastic(SolidMechanicsModel & model, const ID & id = "");
   MaterialPlastic(SolidMechanicsModel & model,
                   UInt a_dim,
                   const Mesh & mesh,
                   FEEngine & fe_engine,
                   const ID & id = "");
 
 protected:
   void initialize();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
 
   /// get the energy specifying the type for the time step
   Real getEnergy(std::string type) override;
 
   /// Compute the plastic energy
-  virtual void updateEnergies(ElementType el_type, GhostType ghost_type = _not_ghost);
+  void updateEnergies(ElementType el_type,
+                      GhostType ghost_type = _not_ghost) override;
 
   /// Compute the true potential energy
   void computePotentialEnergy(ElementType el_type, GhostType ghost_type) override;
 
 protected:
   
   /// compute the stress and inelastic strain for the quadrature point
   inline void computeStressAndInelasticStrainOnQuad(const Matrix<Real> & grad_u,
                                                     const Matrix<Real> & previous_grad_u,
                                                     Matrix<Real> & sigma,
                                                     const Matrix<Real> & previous_sigma,
                                                     Matrix<Real> & inelas_strain,
                                                     const Matrix<Real> & previous_inelas_strain,
                                                     const Matrix<Real> & delta_inelastic_strain) const;
 
   inline void computeStressAndInelasticStrainOnQuad(const Matrix<Real> & delta_grad_u,
                                                     Matrix<Real> & sigma,
                                                     const Matrix<Real> & previous_sigma,
                                                     Matrix<Real> & inelas_strain,
                                                     const Matrix<Real> & previous_inelas_strain,
                                                     const Matrix<Real> & delta_inelastic_strain) const;
 
   /// get the plastic energy for the time step
   Real getPlasticEnergy();
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// Yield stresss
   Real sigma_y;
 
   /// hardening modulus
   Real h;
 
   /// isotropic hardening, r
   InternalField<Real> iso_hardening;
 
   /// inelastic strain arrays ordered by element types (inelastic deformation)
   InternalField<Real> inelastic_strain;
 
   /// Plastic energy
   InternalField<Real> plastic_energy;
 
   /// @todo : add a coefficient beta that will multiply the plastic energy increment
   /// to compute the energy converted to heat
 
   /// Plastic energy increment
   InternalField<Real> d_plastic_energy;
 };
 
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 
 
 } // akantu
 
 #include "material_plastic_inline_impl.cc"
 #endif /* __AKANTU_MATERIAL_PLASTIC_HH__ */
diff --git a/src/model/solid_mechanics/materials/material_python/material_python.hh b/src/model/solid_mechanics/materials/material_python/material_python.hh
index 5c2832cc5..badec2b76 100644
--- a/src/model/solid_mechanics/materials/material_python/material_python.hh
+++ b/src/model/solid_mechanics/materials/material_python/material_python.hh
@@ -1,118 +1,120 @@
 /**
  * @file   material_python.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *
  * @date creation: Fri Nov 13 2015
  * @date last modification: Fri Nov 13 2015
  *
  * @brief  Python material
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /**
  * @file   material_python.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "python_functor.hh"
 /* -------------------------------------------------------------------------- */
 #include "material.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_PYTHON_HH__
 #define __AKANTU_MATERIAL_PYTHON_HH__
 
 /* -------------------------------------------------------------------------- */
 
 
 
 namespace akantu {
 
 class MaterialPython : public Material, PythonFunctor {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   MaterialPython(SolidMechanicsModel & model, PyObject * obj,
                  const ID & id = "");
 
-  virtual ~MaterialPython(){};
+  ~MaterialPython() override = default;
+  ;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   void registerInternals();
 
-  virtual 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 quad point
   template <typename it_type>
   void computeStress(Matrix<Real> & grad_u, Matrix<Real> & sigma,
                      std::vector<it_type> & internal_iterators);
 
   /// compute the tangent stiffness matrix for an element type
-  virtual void computeTangentModuli(const ElementType & el_type,
-                                    Array<Real> & tangent_matrix,
-                                    GhostType ghost_type = _not_ghost);
+  void computeTangentModuli(const ElementType & el_type,
+                            Array<Real> & tangent_matrix,
+                            GhostType ghost_type = _not_ghost) override;
 
   /// compute the push wave speed of the material
-  Real getPushWaveSpeed(const Element & element) const;
+  Real getPushWaveSpeed(const Element & element) const override;
 
 protected:
   /// update the dissipated energy, must be called after the stress have been
   /// computed
   // virtual void updateEnergies(ElementType el_type, GhostType ghost_type){};
 
   /// compute the tangent stiffness matrix for a given quadrature point
   // inline void computeTangentModuliOnQuad(Matrix<Real> & tangent, Real &
   // dam){};
 
   /* ------------------------------------------------------------------------ */
   /* DataAccessor inherited members                                           */
   /* ------------------------------------------------------------------------ */
 public:
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   // virtual Real getEnergy(std::string type){};
   // virtual Real getEnergy(std::string energy_id, ElementType type, UInt
   // index){};
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   std::map<std::string, Real> local_params;
   std::map<std::string, InternalField<Real> *> internals;
 };
 
 } // akantu
 
 #endif /* __AKANTU_MATERIAL_PYTHON_HH__ */
diff --git a/src/model/solid_mechanics/materials/material_thermal.hh b/src/model/solid_mechanics/materials/material_thermal.hh
index c9aad9194..25b829db5 100644
--- a/src/model/solid_mechanics/materials/material_thermal.hh
+++ b/src/model/solid_mechanics/materials/material_thermal.hh
@@ -1,106 +1,106 @@
 /**
  * @file   material_thermal.hh
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Aug 18 2015
  *
  * @brief  Material isotropic thermo-elastic
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "material.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_THERMAL_HH__
 #define __AKANTU_MATERIAL_THERMAL_HH__
 
 namespace akantu {
 template<UInt spatial_dimension>
 class MaterialThermal : public Material {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
 
   MaterialThermal(SolidMechanicsModel & model, const ID & id = "");
   MaterialThermal(SolidMechanicsModel & model,
                   UInt dim,
                   const Mesh & mesh,
                   FEEngine & fe_engine,
                   const ID & id = "");
 
-  ~MaterialThermal() override{};
+  ~MaterialThermal() override = default;
 
 protected:
   void initialize();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   void initMaterial() override;
 
   /// constitutive law for all element of a type
   void computeStress(ElementType el_type, GhostType ghost_type) override;
 
   /* ------------------------------------------------------------------------ */
   /* DataAccessor inherited members                                           */
   /* ------------------------------------------------------------------------ */
 public:
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
 
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// Young modulus
   Real E;
 
   /// Poisson ratio
   Real nu;
 
   /// Thermal expansion coefficient
   /// TODO : implement alpha as a matrix
   Real alpha;
 
   /// Temperature field
   InternalField<Real> delta_T;
 
   /// Current thermal stress
   InternalField<Real> sigma_th;
 
   /// Tell if we need to use the previous thermal stress
   bool use_previous_stress_thermal;
 };
 
 } // akantu
 
 #endif /* __AKANTU_MATERIAL_THERMAL_HH__ */
diff --git a/src/model/solid_mechanics/materials/material_viscoelastic/material_standard_linear_solid_deviatoric.hh b/src/model/solid_mechanics/materials/material_viscoelastic/material_standard_linear_solid_deviatoric.hh
index 9d4e4cc5d..fa82de98a 100644
--- a/src/model/solid_mechanics/materials/material_viscoelastic/material_standard_linear_solid_deviatoric.hh
+++ b/src/model/solid_mechanics/materials/material_viscoelastic/material_standard_linear_solid_deviatoric.hh
@@ -1,137 +1,135 @@
 /**
  * @file   material_standard_linear_solid_deviatoric.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Vladislav Yastrebov <vladislav.yastrebov@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Oct 08 2015
  *
- * @brief  Material Visco-elastic, based on Standard Solid rheological model, see
+ * @brief  Material Visco-elastic, based on Standard Solid rheological model,
+ * see
  * [] J.C.  Simo, T.J.R. Hughes, "Computational  Inelasticity", Springer (1998),
  * see Sections 10.2 and 10.3
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "material_elastic.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_STANDARD_LINEAR_SOLID_DEVIATORIC_HH__
 #define __AKANTU_MATERIAL_STANDARD_LINEAR_SOLID_DEVIATORIC_HH__
 
 namespace akantu {
 
 /**
  * Material standard linear solid deviatoric
  *
  *
  * @verbatim
 
              E_\inf
       ------|\/\/\|------
       |                 |
    ---|                 |---
       |                 |
       ----|\/\/\|--[|----
             E_v   \eta
 
  @endverbatim
  *
  * keyword : sls_deviatoric
  *
  * parameters in the material files :
  *   - E   : Initial Young's modulus @f$ E = E_i + E_v @f$
  *   - eta : viscosity
  *   - Ev  : stiffness of the viscous element
  */
 
-template<UInt spatial_dimension>
-class MaterialStandardLinearSolidDeviatoric : public MaterialElastic<spatial_dimension> {
+template <UInt spatial_dimension>
+class MaterialStandardLinearSolidDeviatoric
+    : public MaterialElastic<spatial_dimension> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-
-  MaterialStandardLinearSolidDeviatoric(SolidMechanicsModel & model, const ID & id = "");
-
-  virtual ~MaterialStandardLinearSolidDeviatoric() {};
+  MaterialStandardLinearSolidDeviatoric(SolidMechanicsModel & model,
+                                        const ID & id = "");
+  ~MaterialStandardLinearSolidDeviatoric() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
-  
   /// initialize the material computed parameter
-  void initMaterial();
-  
+  void initMaterial() override;
+
   /// update the internal parameters (for modifiable parameters)
-  virtual void updateInternalParameters();
+  void updateInternalParameters() override;
 
   /// set material to steady state
-  void setToSteadyState(ElementType el_type, GhostType ghost_type = _not_ghost);
+  void setToSteadyState(ElementType el_type,
+                        GhostType ghost_type = _not_ghost) 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;
 
 protected:
-
-  /// update the dissipated energy, is called after the stress have been computed
+  /// update the dissipated energy, is called after the stress have been
+  /// computed
   void updateDissipatedEnergy(ElementType el_type, GhostType ghost_type);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// give the dissipated energy for the time step
   Real getDissipatedEnergy() const;
   Real getDissipatedEnergy(ElementType type, UInt index) const;
 
   /// get the energy using an energy type string for the time step
-  virtual Real getEnergy(std::string type);
-  virtual Real getEnergy(std::string energy_id, ElementType type, UInt index);
+  Real getEnergy(std::string type) override;
+  Real getEnergy(std::string energy_id, ElementType type, UInt index) override;
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
-
   /// viscosity, viscous elastic modulus
   Real eta, Ev, E_inf;
 
   /// history of deviatoric stress
   InternalField<Real> stress_dev;
 
   /// Internal variable: history integral
   InternalField<Real> history_integral;
 
   /// Dissipated energy
   InternalField<Real> dissipated_energy;
 };
 
-} // akantu
+} // namespace akantu
 
 #endif /* __AKANTU_MATERIAL_STANDARD_LINEAR_SOLID_DEVIATORIC_HH__ */
-
-
diff --git a/src/model/solid_mechanics/materials/plane_stress_toolbox.hh b/src/model/solid_mechanics/materials/plane_stress_toolbox.hh
index 3eb0ee11b..1a1629325 100644
--- a/src/model/solid_mechanics/materials/plane_stress_toolbox.hh
+++ b/src/model/solid_mechanics/materials/plane_stress_toolbox.hh
@@ -1,106 +1,106 @@
 /**
  * @file   plane_stress_toolbox.hh
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 16 2014
  * @date last modification: Tue Aug 18 2015
  *
  * @brief  Tools to implement the plane stress behavior in a material
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_PLANE_STRESS_TOOLBOX_HH__
 #define __AKANTU_PLANE_STRESS_TOOLBOX_HH__
 
 namespace akantu {
 class SolidMechanicsModel;
 class FEEngine;
 }  // akantu
 
 
 namespace akantu {
 
 /**
  * Empty class in dimensions different from 2
  * This class is only specialized for 2D in the tmpl file
  */
 template <UInt dim, class ParentMaterial = Material>
 class PlaneStressToolbox : public ParentMaterial {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   PlaneStressToolbox(SolidMechanicsModel & model, const ID & id = "")
       : ParentMaterial(model, id) {}
   PlaneStressToolbox(SolidMechanicsModel & model, UInt spatial_dimension,
                      const Mesh & mesh, FEEngine & fe_engine,
                      const ID & id = "")
       : ParentMaterial(model, spatial_dimension, mesh, fe_engine, id) {}
 
-  ~PlaneStressToolbox() override {}
+  ~PlaneStressToolbox() override = default;
 
 protected:
   void initialize();
 
 public:
   void computeAllCauchyStresses(GhostType ghost_type = _not_ghost) override {
     AKANTU_DEBUG_IN();
 
     ParentMaterial::computeAllCauchyStresses(ghost_type);
 
     AKANTU_DEBUG_OUT();
   }
 
   virtual void computeCauchyStressPlaneStress(__attribute__((unused))
                                               ElementType el_type,
                                               __attribute__((unused))
                                               GhostType ghost_type) {
     AKANTU_DEBUG_IN();
 
     AKANTU_DEBUG_ERROR("The function \"computeCauchyStressPlaneStress\" can "
                        "only be used in 2D Plane stress problems, which means "
                        "that you made a mistake somewhere!! ");
 
     AKANTU_DEBUG_OUT();
   }
 
 protected:
   bool initialize_third_axis_deformation;
 };
 
 #define AKANTU_PLANE_STRESS_TOOL_SPEC(dim)                                     \
   template <>                                                                  \
   inline PlaneStressToolbox<dim, Material>::PlaneStressToolbox(                \
       SolidMechanicsModel & model, const ID & id)                              \
       : Material(model, id) {}
 
 AKANTU_PLANE_STRESS_TOOL_SPEC(1)
 AKANTU_PLANE_STRESS_TOOL_SPEC(3)
 
 } // namespace akantu
 
 #include "plane_stress_toolbox_tmpl.hh"
 
 #endif /* __AKANTU_PLANE_STRESS_TOOLBOX_HH__ */
diff --git a/src/model/solid_mechanics/materials/plane_stress_toolbox_tmpl.hh b/src/model/solid_mechanics/materials/plane_stress_toolbox_tmpl.hh
index e31099310..9ef31be49 100644
--- a/src/model/solid_mechanics/materials/plane_stress_toolbox_tmpl.hh
+++ b/src/model/solid_mechanics/materials/plane_stress_toolbox_tmpl.hh
@@ -1,169 +1,169 @@
 /**
  * @file   plane_stress_toolbox_tmpl.hh
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  *
  * @date creation: Tue Sep 16 2014
  * @date last modification: Tue Aug 18 2015
  *
  * @brief  2D specialization of the akantu::PlaneStressToolbox class
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_PLANE_STRESS_TOOLBOX_TMPL_HH__
 #define __AKANTU_PLANE_STRESS_TOOLBOX_TMPL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class ParentMaterial>
 class PlaneStressToolbox<2, ParentMaterial> : public ParentMaterial {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   PlaneStressToolbox(SolidMechanicsModel & model, const ID & id = "");
   PlaneStressToolbox(SolidMechanicsModel & model, UInt dim, const Mesh & mesh,
                      FEEngine & fe_engine, const ID & id = "");
 
-  ~PlaneStressToolbox() override {}
+  ~PlaneStressToolbox() override = default;
 
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(ThirdAxisDeformation,
                                          third_axis_deformation, Real);
 
 protected:
   void initialize() {
     this->registerParam("Plane_Stress", plane_stress, false, _pat_parsmod,
                         "Is plane stress");
   }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /* ------------------------------------------------------------------------ */
   void initMaterial() override {
 
     ParentMaterial::initMaterial();
     if (this->plane_stress && this->initialize_third_axis_deformation) {
       this->third_axis_deformation.initialize(1);
       this->third_axis_deformation.resize();
     }
   }
 
   /* ------------------------------------------------------------------------ */
   void computeStress(ElementType el_type, GhostType ghost_type) override {
     ParentMaterial::computeStress(el_type, ghost_type);
     if (this->plane_stress)
       computeThirdAxisDeformation(el_type, ghost_type);
   }
 
   /* ------------------------------------------------------------------------ */
   virtual void computeThirdAxisDeformation(ElementType, GhostType) {}
 
   /// Computation of Cauchy stress tensor in the case of finite deformation
   void computeAllCauchyStresses(GhostType ghost_type = _not_ghost) override {
     AKANTU_DEBUG_IN();
 
     if (this->plane_stress) {
 
       AKANTU_DEBUG_ASSERT(this->finite_deformation,
                           "The Cauchy stress can only be computed if you are "
                           "working in finite deformation.");
 
       // resizeInternalArray(stress);
 
       Mesh::type_iterator it = this->fem.getMesh().firstType(2, ghost_type);
       Mesh::type_iterator last_type =
           this->fem.getMesh().lastType(2, ghost_type);
 
       for (; it != last_type; ++it)
         this->computeCauchyStressPlaneStress(*it, ghost_type);
     } else
       ParentMaterial::computeAllCauchyStresses(ghost_type);
 
     AKANTU_DEBUG_OUT();
   }
 
   virtual void
   computeCauchyStressPlaneStress(__attribute__((unused)) ElementType el_type,
                                  __attribute__((unused))
                                  GhostType ghost_type = _not_ghost){};
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// third axis strain measure value
   InternalField<Real> third_axis_deformation;
 
   /// Plane stress or plane strain
   bool plane_stress;
 
   /// For non linear materials, the \epsilon_{zz} might be required
   bool initialize_third_axis_deformation;
 };
 
 template <class ParentMaterial>
 inline PlaneStressToolbox<2, ParentMaterial>::PlaneStressToolbox(
     SolidMechanicsModel & model, const ID & id)
     : ParentMaterial(model, id),
       third_axis_deformation("third_axis_deformation", *this),
       plane_stress(false), initialize_third_axis_deformation(false) {
 
   /// @todo Plane_Stress should not be possible to be modified after
   /// initMaterial (but before)
   this->initialize();
 }
 
 template <class ParentMaterial>
 inline PlaneStressToolbox<2, ParentMaterial>::PlaneStressToolbox(
     SolidMechanicsModel & model, UInt dim, const Mesh & mesh,
     FEEngine & fe_engine, const ID & id)
     : ParentMaterial(model, dim, mesh, fe_engine, id),
       third_axis_deformation("third_axis_deformation", *this, dim, fe_engine,
                              this->element_filter),
       plane_stress(false), initialize_third_axis_deformation(false) {
   this->initialize();
 }
 
 template <>
 inline PlaneStressToolbox<2, Material>::PlaneStressToolbox(
     SolidMechanicsModel & model, const ID & id)
     : Material(model, id),
       third_axis_deformation("third_axis_deformation", *this),
       plane_stress(false), initialize_third_axis_deformation(false) {
 
   /// @todo Plane_Stress should not be possible to be modified after
   /// initMaterial (but before)
   this->registerParam("Plane_Stress", plane_stress, false, _pat_parsmod,
                       "Is plane stress");
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_PLANE_STRESS_TOOLBOX_TMPL_HH__ */
diff --git a/src/model/solid_mechanics/materials/random_internal_field_tmpl.hh b/src/model/solid_mechanics/materials/random_internal_field_tmpl.hh
index d585c4634..a67c0a009 100644
--- a/src/model/solid_mechanics/materials/random_internal_field_tmpl.hh
+++ b/src/model/solid_mechanics/materials/random_internal_field_tmpl.hh
@@ -1,125 +1,125 @@
 /**
  * @file   random_internal_field_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Random internal material parameter implementation
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_random_generator.hh"
 #include "internal_field_tmpl.hh"
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_RANDOM_INTERNAL_FIELD_TMPL_HH__
 #define __AKANTU_RANDOM_INTERNAL_FIELD_TMPL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename T, template <typename> class BaseField,
           template <typename> class Generator>
 RandomInternalField<T, BaseField, Generator>::RandomInternalField(
     const ID & id, Material & material)
     : BaseField<T>(id, material), random_parameter(T()) {}
 
 /* -------------------------------------------------------------------------- */
 template <typename T, template <typename> class BaseField,
           template <typename> class Generator>
-RandomInternalField<T, BaseField, Generator>::~RandomInternalField() {}
+RandomInternalField<T, BaseField, Generator>::~RandomInternalField() = default;
 
 /* -------------------------------------------------------------------------- */
 template <typename T, template <typename> class BaseField,
           template <typename> class Generator>
 void RandomInternalField<T, BaseField, Generator>::initialize(
     UInt nb_component) {
   this->internalInitialize(nb_component);
 }
 
 /* ------------------------------------------------------------------------ */
 template <typename T, template <typename> class BaseField,
           template <typename> class Generator>
 void RandomInternalField<T, BaseField, Generator>::setDefaultValue(
     const T & value) {
   random_parameter.setBaseValue(value);
   this->reset();
 }
 
 /* ------------------------------------------------------------------------ */
 template <typename T, template <typename> class BaseField,
           template <typename> class Generator>
 void RandomInternalField<T, BaseField, Generator>::setRandomDistribution(
     const RandomParameter<T> & param) {
   random_parameter = param;
   this->reset();
 }
 
 /* ------------------------------------------------------------------------ */
 template <typename T, template <typename> class BaseField,
           template <typename> class Generator>
 void RandomInternalField<T, BaseField, Generator>::printself(
     std::ostream & stream, int indent) const {
   stream << "RandomInternalField [ ";
   random_parameter.printself(stream);
   stream << " ]";
 #if !defined(AKANTU_NDEBUG)
   if (AKANTU_DEBUG_TEST(dblDump)) {
     stream << std::endl;
     InternalField<T>::printself(stream, indent);
   }
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, template <typename> class BaseField,
           template <typename> class Generator>
 void RandomInternalField<T, BaseField, Generator>::setArrayValues(T * begin,
                                                                   T * end) {
   random_parameter.template setValues<Generator>(begin, end);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, template <typename> class BaseField,
           template <typename> class Generator>
 inline RandomInternalField<T, BaseField, Generator>::operator Real() const {
   return random_parameter.getBaseValue();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void ParameterTyped<RandomInternalField<Real>>::setAuto(
     const ParserParameter & in_param) {
   Parameter::setAuto(in_param);
   RandomParameter<Real> r = in_param;
   param.setRandomDistribution(r);
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
 
 #endif /* __AKANTU_RANDOM_INTERNAL_FIELD_TMPL_HH__ */
diff --git a/src/model/solid_mechanics/solid_mechanics_model.hh b/src/model/solid_mechanics/solid_mechanics_model.hh
index 495e28103..01efe638f 100644
--- a/src/model/solid_mechanics/solid_mechanics_model.hh
+++ b/src/model/solid_mechanics/solid_mechanics_model.hh
@@ -1,581 +1,581 @@
 /**
  * @file   solid_mechanics_model.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Jul 27 2010
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  Model of Solid Mechanics
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "boundary_condition.hh"
 #include "data_accessor.hh"
 #include "fe_engine.hh"
 #include "model.hh"
 #include "non_local_manager.hh"
 #include "solid_mechanics_model_event_handler.hh"
 /* -------------------------------------------------------------------------- */
 //#include "integrator_gauss.hh"
 //#include "shape_lagrange.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SOLID_MECHANICS_MODEL_HH__
 #define __AKANTU_SOLID_MECHANICS_MODEL_HH__
 
 namespace akantu {
 class Material;
 class MaterialSelector;
 class DumperIOHelper;
 class NonLocalManager;
 template <ElementKind kind, class IntegrationOrderFunctor>
 class IntegratorGauss;
 template <ElementKind kind> class ShapeLagrange;
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
 struct SolidMechanicsModelOptions : public ModelOptions {
   explicit SolidMechanicsModelOptions(
       AnalysisMethod analysis_method = _explicit_lumped_mass);
 
   template <typename... pack>
   SolidMechanicsModelOptions(use_named_args_t, pack &&... _pack);
 };
 
 /* -------------------------------------------------------------------------- */
 class SolidMechanicsModel
     : public Model,
       public DataAccessor<Element>,
       public DataAccessor<UInt>,
       public BoundaryCondition<SolidMechanicsModel>,
       public NonLocalManagerCallback,
       public EventHandlerManager<SolidMechanicsModelEventHandler> {
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   class NewMaterialElementsEvent : public NewElementsEvent {
   public:
     AKANTU_GET_MACRO_NOT_CONST(MaterialList, material, Array<UInt> &);
     AKANTU_GET_MACRO(MaterialList, material, const Array<UInt> &);
 
   protected:
     Array<UInt> material;
   };
 
   using MyFEEngineType = FEEngineTemplate<IntegratorGauss, ShapeLagrange>;
 
 protected:
   using EventManager = EventHandlerManager<SolidMechanicsModelEventHandler>;
 
 public:
   SolidMechanicsModel(Mesh & mesh, UInt spatial_dimension = _all_dimensions,
                       const ID & id = "solid_mechanics_model",
                       const MemoryID & memory_id = 0);
 
   ~SolidMechanicsModel() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   template <typename P, typename T, typename... pack>
   void initFull(named_argument::param_t<P, T &&> && first, pack &&... _pack) {
     this->initFull(SolidMechanicsModelOptions{use_named_args, first, _pack...});
   }
 
   /// initialize completely the model
   void initFull(
       const ModelOptions & options = SolidMechanicsModelOptions()) override;
 
   /// initialize the fem object needed for boundary conditions
   void initFEEngineBoundary();
 
 protected:
   /// initialize all internal arrays for materials
   virtual void initMaterials();
 
   /// initialize the model
   void initModel() override;
 
   /// function to print the containt of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
   /// get some default values for derived classes
   std::tuple<ID, TimeStepSolverType>
   getDefaultSolverID(const AnalysisMethod & method) override;
 
   /* ------------------------------------------------------------------------ */
   /* Solver interface                                                         */
   /* ------------------------------------------------------------------------ */
 public:
   /// assembles the stiffness matrix,
   virtual void assembleStiffnessMatrix();
   /// assembles the internal forces in the array internal_forces
   virtual void assembleInternalForces();
 
 protected:
   /// callback for the solver, this adds f_{ext} - f_{int} to the residual
   void assembleResidual() override;
 
   /// get the type of matrix needed
   MatrixType getMatrixType(const ID & matrix_id) override;
 
   /// callback for the solver, this assembles different matrices
   void assembleMatrix(const ID & matrix_id) override;
 
   /// callback for the solver, this assembles the stiffness matrix
   void assembleLumpedMatrix(const ID & matrix_id) override;
 
   /// callback for the solver, this is called at beginning of solve
   void predictor() override;
   /// callback for the solver, this is called at end of solve
   void corrector() override;
 
   /// callback for the solver, this is called at beginning of solve
   void beforeSolveStep() override;
   /// callback for the solver, this is called at end of solve
   void afterSolveStep() override;
 
   /// Callback for the model to instantiate the matricees when needed
   void initSolver(TimeStepSolverType time_step_solver_type,
                   NonLinearSolverType non_linear_solver_type) override;
 
 protected:
   /* ------------------------------------------------------------------------ */
   TimeStepSolverType getDefaultSolverType() const override;
   /* ------------------------------------------------------------------------ */
   ModelSolverOptions
   getDefaultSolverOptions(const TimeStepSolverType & type) const override;
 
 public:
   bool isDefaultSolverExplicit() {
     return method == _explicit_lumped_mass ||
            method == _explicit_consistent_mass;
   }
 
 protected:
   /// update the current position vector
   void updateCurrentPosition();
 
   /* ------------------------------------------------------------------------ */
   /* Materials (solid_mechanics_model_material.cc)                            */
   /* ------------------------------------------------------------------------ */
 public:
   /// register an empty material of a given type
   Material & registerNewMaterial(const ID & mat_name, const ID & mat_type,
                                  const ID & opt_param);
 
   /// reassigns materials depending on the material selector
   virtual void reassignMaterial();
 
   /// apply a constant eigen_grad_u on all quadrature points of a given material
   virtual void applyEigenGradU(const Matrix<Real> & prescribed_eigen_grad_u,
                                const ID & material_name,
                                const GhostType ghost_type = _not_ghost);
 
 protected:
   /// register a material in the dynamic database
   Material & registerNewMaterial(const ParserSection & mat_section);
 
   /// read the material files to instantiate all the materials
   void instantiateMaterials();
 
   /// set the element_id_by_material and add the elements to the good materials
   void
   assignMaterialToElements(const ElementTypeMapArray<UInt> * filter = nullptr);
 
   /* ------------------------------------------------------------------------ */
   /* Mass (solid_mechanics_model_mass.cc)                                     */
   /* ------------------------------------------------------------------------ */
 public:
   /// assemble the lumped mass matrix
   void assembleMassLumped();
 
   /// assemble the mass matrix for consistent mass resolutions
   void assembleMass();
 
 protected:
   /// assemble the lumped mass matrix for local and ghost elements
   void assembleMassLumped(GhostType ghost_type);
 
   /// assemble the mass matrix for either _ghost or _not_ghost elements
   void assembleMass(GhostType ghost_type);
 
   /// fill a vector of rho
   void computeRho(Array<Real> & rho, ElementType type, GhostType ghost_type);
 
   /// compute the kinetic energy
   Real getKineticEnergy();
   Real getKineticEnergy(const ElementType & type, UInt index);
 
   /// compute the external work (for impose displacement, the velocity should be
   /// given too)
   Real getExternalWork();
 
   /* ------------------------------------------------------------------------ */
   /* NonLocalManager inherited members                                        */
   /* ------------------------------------------------------------------------ */
 protected:
   void initializeNonLocal() override;
 
   void updateDataForNonLocalCriterion(ElementTypeMapReal & criterion) override;
 
   void computeNonLocalStresses(const GhostType & ghost_type) override;
 
   void
   insertIntegrationPointsInNeighborhoods(const GhostType & ghost_type) override;
 
   /// update the values of the non local internal
   void updateLocalInternal(ElementTypeMapReal & internal_flat,
                            const GhostType & ghost_type,
                            const ElementKind & kind) override;
 
   /// copy the results of the averaging in the materials
   void updateNonLocalInternal(ElementTypeMapReal & internal_flat,
                               const GhostType & ghost_type,
                               const ElementKind & kind) override;
 
   /* ------------------------------------------------------------------------ */
   /* Data Accessor inherited members                                          */
   /* ------------------------------------------------------------------------ */
 public:
   UInt getNbData(const Array<Element> & elements,
                  const SynchronizationTag & tag) const override;
 
   void packData(CommunicationBuffer & buffer, const Array<Element> & elements,
                 const SynchronizationTag & tag) const override;
 
   void unpackData(CommunicationBuffer & buffer, const Array<Element> & elements,
                   const SynchronizationTag & tag) override;
 
   UInt getNbData(const Array<UInt> & dofs,
                  const SynchronizationTag & tag) const override;
 
   void packData(CommunicationBuffer & buffer, const Array<UInt> & dofs,
                 const SynchronizationTag & tag) const override;
 
   void unpackData(CommunicationBuffer & buffer, const Array<UInt> & dofs,
                   const SynchronizationTag & tag) override;
 
 protected:
   void
   splitElementByMaterial(const Array<Element> & elements,
                          std::vector<Array<Element>> & elements_per_mat) const;
 
   template <typename Operation>
   void splitByMaterial(const Array<Element> & elements, Operation && op) const;
 
   /* ------------------------------------------------------------------------ */
   /* Mesh Event Handler inherited members                                     */
   /* ------------------------------------------------------------------------ */
 protected:
   void onNodesAdded(const Array<UInt> & nodes_list,
                     const NewNodesEvent & event) override;
   void onNodesRemoved(const Array<UInt> & element_list,
                       const Array<UInt> & new_numbering,
                       const RemovedNodesEvent & event) override;
   void onElementsAdded(const Array<Element> & nodes_list,
                        const NewElementsEvent & event) override;
   void onElementsRemoved(const Array<Element> & element_list,
                          const ElementTypeMapArray<UInt> & new_numbering,
                          const RemovedElementsEvent & event) override;
   void onElementsChanged(const Array<Element> &, const Array<Element> &,
                          const ElementTypeMapArray<UInt> &,
                          const ChangedElementsEvent &) override{};
 
   /* ------------------------------------------------------------------------ */
   /* Dumpable interface (kept for convenience) and dumper relative functions  */
   /* ------------------------------------------------------------------------ */
 public:
   virtual void onDump();
 
   //! decide wether a field is a material internal or not
   bool isInternal(const std::string & field_name,
                   const ElementKind & element_kind);
 #ifndef SWIG
   //! give the amount of data per element
   virtual ElementTypeMap<UInt>
   getInternalDataPerElem(const std::string & field_name,
                          const ElementKind & kind);
 
   //! flatten a given material internal field
   ElementTypeMapArray<Real> &
   flattenInternal(const std::string & field_name, const ElementKind & kind,
                   const GhostType ghost_type = _not_ghost);
   //! flatten all the registered material internals
   void flattenAllRegisteredInternals(const ElementKind & kind);
 #endif
 
   dumper::Field * createNodalFieldReal(const std::string & field_name,
                                        const std::string & group_name,
                                        bool padding_flag) override;
 
   dumper::Field * createNodalFieldBool(const std::string & field_name,
                                        const std::string & group_name,
                                        bool padding_flag) override;
 
   dumper::Field * createElementalField(const std::string & field_name,
                                        const std::string & group_name,
                                        bool padding_flag,
                                        const UInt & spatial_dimension,
                                        const ElementKind & kind) override;
 
   virtual void dump(const std::string & dumper_name);
 
   virtual void dump(const std::string & dumper_name, UInt step);
 
   virtual void dump(const std::string & dumper_name, Real time, UInt step);
 
   void dump() override;
 
   virtual void dump(UInt step);
 
   virtual void dump(Real time, UInt step);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// return the dimension of the system space
   AKANTU_GET_MACRO(SpatialDimension, Model::spatial_dimension, UInt);
 
   /// set the value of the time step
   void setTimeStep(Real time_step, const ID & solver_id = "") override;
 
   /// get the value of the conversion from forces/ mass to acceleration
   AKANTU_GET_MACRO(F_M2A, f_m2a, Real);
 
   /// set the value of the conversion from forces/ mass to acceleration
   AKANTU_SET_MACRO(F_M2A, f_m2a, Real);
 
   /// get the SolidMechanicsModel::displacement vector
   AKANTU_GET_MACRO(Displacement, *displacement, Array<Real> &);
 
   /// get the SolidMechanicsModel::previous_displacement vector
   AKANTU_GET_MACRO(PreviousDisplacement, *previous_displacement, Array<Real> &);
 
   /// get the SolidMechanicsModel::current_position vector \warn only consistent
   /// after a call to SolidMechanicsModel::updateCurrentPosition
   const Array<Real> & getCurrentPosition();
 
   /// get  the SolidMechanicsModel::increment  vector \warn  only  consistent if
   /// SolidMechanicsModel::setIncrementFlagOn has been called before
   AKANTU_GET_MACRO(Increment, *displacement_increment, Array<Real> &);
 
   /// get the lumped SolidMechanicsModel::mass vector
   AKANTU_GET_MACRO(Mass, *mass, Array<Real> &);
 
   /// get the SolidMechanicsModel::velocity vector
   AKANTU_GET_MACRO(Velocity, *velocity, Array<Real> &);
 
   /// get    the    SolidMechanicsModel::acceleration    vector,   updated    by
   /// SolidMechanicsModel::updateAcceleration
   AKANTU_GET_MACRO(Acceleration, *acceleration, Array<Real> &);
 
   /// get the SolidMechanicsModel::force vector (external forces)
   AKANTU_GET_MACRO(Force, *external_force, Array<Real> &);
 
   /// get the SolidMechanicsModel::internal_force vector (internal forces)
   AKANTU_GET_MACRO(InternalForce, *internal_force, Array<Real> &);
 
   /// get the SolidMechanicsModel::blocked_dofs vector
   AKANTU_GET_MACRO(BlockedDOFs, *blocked_dofs, Array<bool> &);
 
   /// get the value of the SolidMechanicsModel::increment_flag
   AKANTU_GET_MACRO(IncrementFlag, increment_flag, bool);
 
   /// get a particular material (by material index)
   inline Material & getMaterial(UInt mat_index);
 
   /// get a particular material (by material index)
   inline const Material & getMaterial(UInt mat_index) const;
 
   /// get a particular material (by material name)
   inline Material & getMaterial(const std::string & name);
 
   /// get a particular material (by material name)
   inline const Material & getMaterial(const std::string & name) const;
 
   /// get a particular material id from is name
   inline UInt getMaterialIndex(const std::string & name) const;
 
   /// give the number of materials
   inline UInt getNbMaterials() const { return materials.size(); }
 
   inline void setMaterialSelector(MaterialSelector & selector);
 
   /// give the material internal index from its id
   Int getInternalIndexFromID(const ID & id) const;
 
   /// compute the stable time step
   Real getStableTimeStep();
 
   /// get the energies
   Real getEnergy(const std::string & energy_id);
 
   /// compute the energy for energy
   Real getEnergy(const std::string & energy_id, const ElementType & type,
                  UInt index);
 
   /// get the FEEngine object to integrate or interpolate on the boundary
   FEEngine & getFEEngineBoundary(const ID & name = "") override;
 
   AKANTU_GET_MACRO(MaterialByElement, material_index,
                    const ElementTypeMapArray<UInt> &);
 
   /// vectors containing local material element index for each global element
   /// index
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(MaterialByElement, material_index,
                                          UInt);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(MaterialByElement, material_index, UInt);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(MaterialLocalNumbering,
                                          material_local_numbering, UInt);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(MaterialLocalNumbering,
                                    material_local_numbering, UInt);
 
   /// Access the non_local_manager interface
   AKANTU_GET_MACRO(NonLocalManager, *non_local_manager, NonLocalManager &);
 
 protected:
   friend class Material;
 
 protected:
   /// compute the stable time step
   Real getStableTimeStep(const GhostType & ghost_type);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// conversion coefficient form force/mass to acceleration
   Real f_m2a;
 
   /// displacements array
   Array<Real> * displacement;
   UInt displacement_release{0};
 
   /// displacements array at the previous time step (used in finite deformation)
   Array<Real> * previous_displacement{nullptr};
 
   /// increment of displacement
   Array<Real> * displacement_increment{nullptr};
 
   /// lumped mass array
   Array<Real> * mass{nullptr};
 
   /// Check if materials need to recompute the mass array
   bool need_to_reassemble_lumped_mass{true};
   /// Check if materials need to recompute the mass matrix
   bool need_to_reassemble_mass{true};
 
   /// velocities array
   Array<Real> * velocity{nullptr};
 
   /// accelerations array
   Array<Real> * acceleration{nullptr};
 
   /// accelerations array
   // Array<Real> * increment_acceleration;
 
   /// external forces array
   Array<Real> * external_force{nullptr};
 
   /// internal forces array
   Array<Real> * internal_force{nullptr};
 
   /// array specifing if a degree of freedom is blocked or not
   Array<bool> * blocked_dofs{nullptr};
 
   /// array of current position used during update residual
   Array<Real> * current_position{nullptr};
   UInt current_position_release{0};
 
   /// Arrays containing the material index for each element
   ElementTypeMapArray<UInt> material_index;
 
   /// Arrays containing the position in the element filter of the material
   /// (material's local numbering)
   ElementTypeMapArray<UInt> material_local_numbering;
 
 #ifdef SWIGPYTHON
 public:
 #endif
   /// list of used materials
   std::vector<std::unique_ptr<Material>> materials;
 
   /// mapping between material name and material internal id
   std::map<std::string, UInt> materials_names_to_id;
 #ifdef SWIGPYTHON
 protected:
 #endif
 
   /// class defining of to choose a material
   MaterialSelector * material_selector;
 
   /// define if it is the default selector or not
   bool is_default_material_selector;
 
   /// flag defining if the increment must be computed or not
   bool increment_flag;
 
   /// tells if the material are instantiated
   bool are_materials_instantiated;
 
   typedef std::map<std::pair<std::string, ElementKind>,
                    ElementTypeMapArray<Real> *>
       flatten_internal_map;
 
   /// map a registered internals to be flattened for dump purposes
   flatten_internal_map registered_internals;
 
   /// non local manager
   std::unique_ptr<NonLocalManager> non_local_manager;
 };
 
 /* -------------------------------------------------------------------------- */
 namespace BC {
   namespace Neumann {
-    typedef FromHigherDim FromStress;
-    typedef FromSameDim FromTraction;
+    using FromStress = FromHigherDim;
+    using FromTraction = FromSameDim;
   } // namespace Neumann
 } // namespace BC
 
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 #include "material.hh"
 #include "parser.hh"
 
 #include "solid_mechanics_model_inline_impl.cc"
 #include "solid_mechanics_model_tmpl.hh"
 /* -------------------------------------------------------------------------- */
 
 #endif /* __AKANTU_SOLID_MECHANICS_MODEL_HH__ */
diff --git a/src/model/solid_mechanics/solid_mechanics_model_cohesive/materials/cohesive_internal_field_tmpl.hh b/src/model/solid_mechanics/solid_mechanics_model_cohesive/materials/cohesive_internal_field_tmpl.hh
index b3882e1dc..0b2c80de8 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_cohesive/materials/cohesive_internal_field_tmpl.hh
+++ b/src/model/solid_mechanics/solid_mechanics_model_cohesive/materials/cohesive_internal_field_tmpl.hh
@@ -1,94 +1,95 @@
 /**
  * @file   cohesive_internal_field_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Thu Jan 21 2016
  *
  * @brief  implementation of the cohesive internal field
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_COHESIVE_INTERNAL_FIELD_TMPL_HH__
 #define __AKANTU_COHESIVE_INTERNAL_FIELD_TMPL_HH__
 
 namespace akantu {
 
 template <typename T>
 CohesiveInternalField<T>::CohesiveInternalField(const ID & id,
                                                 Material & material)
     : InternalField<T>(
           id, material, material.getModel().getFEEngine("CohesiveFEEngine"),
           dynamic_cast<MaterialCohesive &>(material).getElementFilter()) {
   this->element_kind = _ek_cohesive;
 }
 
-template <typename T> CohesiveInternalField<T>::~CohesiveInternalField() {}
+template <typename T>
+CohesiveInternalField<T>::~CohesiveInternalField() = default;
 
 template <typename T>
 void CohesiveInternalField<T>::initialize(UInt nb_component) {
   this->internalInitialize(nb_component);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 FacetInternalField<T>::FacetInternalField(const ID & id, Material & material)
     : InternalField<T>(
           id, material, material.getModel().getFEEngine("FacetsFEEngine"),
           dynamic_cast<MaterialCohesive &>(material).getFacetFilter()) {
   this->spatial_dimension -= 1;
   this->element_kind = _ek_regular;
 }
 
-template <typename T> FacetInternalField<T>::~FacetInternalField() {}
+template <typename T> FacetInternalField<T>::~FacetInternalField() = default;
 
 template <typename T>
 void FacetInternalField<T>::initialize(UInt nb_component) {
   this->internalInitialize(nb_component);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ParameterTyped<RandomInternalField<Real, FacetInternalField>>::setAuto(
     const ParserParameter & in_param) {
   Parameter::setAuto(in_param);
   RandomParameter<Real> r = in_param;
   param.setRandomDistribution(r);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ParameterTyped<RandomInternalField<Real, CohesiveInternalField>>::setAuto(
     const ParserParameter & in_param) {
   Parameter::setAuto(in_param);
   RandomParameter<Real> r = in_param;
   param.setRandomDistribution(r);
 }
 
 } // akantu
 
 #endif /* __AKANTU_COHESIVE_INTERNAL_FIELD_TMPL_HH__ */
diff --git a/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.cc b/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.cc
index b68d3dabc..9e9c3841a 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.cc
@@ -1,798 +1,797 @@
 /**
  * @file   solid_mechanics_model_cohesive.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue May 08 2012
  * @date last modification: Wed Jan 13 2016
  *
  * @brief  Solid mechanics model for cohesive elements
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "solid_mechanics_model_cohesive.hh"
 #include "aka_iterators.hh"
 #include "cohesive_element_inserter.hh"
 #include "dumpable_inline_impl.hh"
 #include "element_synchronizer.hh"
 #include "facet_synchronizer.hh"
 #include "fe_engine_template.hh"
 #include "integrator_gauss.hh"
 #include "material_cohesive.hh"
 #include "parser.hh"
 #include "shape_cohesive.hh"
 
 #include "dumpable_inline_impl.hh"
 #ifdef AKANTU_USE_IOHELPER
 #include "dumper_paraview.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 const SolidMechanicsModelCohesiveOptions
     default_solid_mechanics_model_cohesive_options(_explicit_lumped_mass,
                                                    false);
 
 /* -------------------------------------------------------------------------- */
 SolidMechanicsModelCohesive::SolidMechanicsModelCohesive(
     Mesh & mesh, UInt dim, const ID & id, const MemoryID & memory_id)
     : SolidMechanicsModel(mesh, dim, id, memory_id), tangents("tangents", id),
       facet_stress("facet_stress", id), facet_material("facet_material", id) {
   AKANTU_DEBUG_IN();
 
   delete material_selector;
   material_selector = new DefaultMaterialCohesiveSelector(*this);
 
 #if defined(AKANTU_USE_IOHELPER)
   this->mesh.registerDumper<DumperParaview>("cohesive elements", id);
   this->mesh.addDumpMeshToDumper("cohesive elements", mesh,
                                  Model::spatial_dimension, _not_ghost,
                                  _ek_cohesive);
 #endif
 
   if (this->mesh.isDistributed()) {
     /// create the distributed synchronizer for cohesive elements
     cohesive_synchronizer = std::make_unique<ElementSynchronizer>(
         mesh, "cohesive_distributed_synchronizer");
 
     auto & synchronizer = mesh.getElementSynchronizer();
     cohesive_synchronizer->split(synchronizer, [](auto && el) {
         return Mesh::getKind(el.type) == _ek_cohesive;
     });
 
     this->registerSynchronizer(*cohesive_synchronizer, _gst_material_id);
     this->registerSynchronizer(*cohesive_synchronizer, _gst_smm_stress);
     this->registerSynchronizer(*cohesive_synchronizer, _gst_smm_boundary);
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 SolidMechanicsModelCohesive::~SolidMechanicsModelCohesive() = default;
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::setTimeStep(Real time_step,
                                               const ID & solver_id) {
   SolidMechanicsModel::setTimeStep(time_step, solver_id);
 
 #if defined(AKANTU_USE_IOHELPER)
   this->mesh.getDumper("cohesive elements").setTimeStep(time_step);
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initFull(const ModelOptions & options) {
   AKANTU_DEBUG_IN();
 
-  const SolidMechanicsModelCohesiveOptions & smmc_options =
+  const auto & smmc_options =
       dynamic_cast<const SolidMechanicsModelCohesiveOptions &>(options);
 
   this->is_extrinsic = smmc_options.extrinsic;
 
   inserter = std::make_unique<CohesiveElementInserter>(
       mesh, is_extrinsic, id + ":cohesive_element_inserter");
 
   if (not mesh.isDistributed()) {
     auto & mesh_facets = inserter->getMeshFacets();
     auto & synchronizer =
         dynamic_cast<FacetSynchronizer &>(mesh_facets.getElementSynchronizer());
     this->registerSynchronizer(synchronizer, _gst_smmc_facets);
     this->registerSynchronizer(synchronizer, _gst_smmc_facets_conn);
     synchronizeGhostFacetsConnectivity();
 
     /// create the facet synchronizer for extrinsic simulations
     if (is_extrinsic) {
       facet_stress_synchronizer =
           std::make_unique<ElementSynchronizer>(mesh_facets);
 
       facet_stress_synchronizer->updateSchemes(
           [&](auto & scheme, auto & proc, auto & direction) {
             scheme.copy(const_cast<const FacetSynchronizer &>(synchronizer)
                             .getCommunications()
                             .getScheme(proc, direction));
           });
       this->registerSynchronizer(*facet_stress_synchronizer,
                                  _gst_smmc_facets_stress);
     }
   }
 
   SolidMechanicsModel::initFull(options);
 
   AKANTU_DEBUG_OUT();
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initMaterials() {
   AKANTU_DEBUG_IN();
 
   // make sure the material are instantiated
   if (!are_materials_instantiated)
     instantiateMaterials();
 
   /// find the first cohesive material
   UInt cohesive_index = 0;
 
   while ((dynamic_cast<MaterialCohesive *>(materials[cohesive_index].get()) ==
           nullptr) &&
          cohesive_index <= materials.size())
     ++cohesive_index;
 
   AKANTU_DEBUG_ASSERT(cohesive_index != materials.size(),
                       "No cohesive materials in the material input file");
 
   material_selector->setFallback(cohesive_index);
 
   // set the facet information in the material in case of dynamic insertion
   if (is_extrinsic) {
     const Mesh & mesh_facets = inserter->getMeshFacets();
     facet_material.initialize(mesh_facets, _spatial_dimension =
                                                Model::spatial_dimension - 1);
     // mesh_facets.initElementTypeMapArray(facet_material, 1,
     //                                     spatial_dimension - 1);
 
     Element element;
     for (auto ghost_type : ghost_types) {
       element.ghost_type = ghost_type;
       for (auto & type :
            mesh_facets.elementTypes(Model::spatial_dimension - 1, ghost_type)) {
         element.type = type;
         Array<UInt> & f_material = facet_material(type, ghost_type);
         UInt nb_element = mesh_facets.getNbElement(type, ghost_type);
         f_material.resize(nb_element);
         f_material.set(cohesive_index);
         for (UInt el = 0; el < nb_element; ++el) {
           element.element = el;
           UInt mat_index = (*material_selector)(element);
           f_material(el) = mat_index;
-          MaterialCohesive & mat =
-              dynamic_cast<MaterialCohesive &>(*materials[mat_index]);
+          auto & mat = dynamic_cast<MaterialCohesive &>(*materials[mat_index]);
           mat.addFacet(element);
         }
       }
     }
     SolidMechanicsModel::initMaterials();
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
     if (facet_synchronizer != nullptr)
       inserter->initParallel(facet_synchronizer, cohesive_element_synchronizer);
 //      inserter->initParallel(facet_synchronizer, synch_parallel);
 #endif
     initAutomaticInsertion();
   } else {
     // TODO think of something a bit mor consistant than just coding the first
     // thing that comes in Fabian's head....
-    typedef ParserSection::const_section_iterator const_section_iterator;
+    using const_section_iterator = ParserSection::const_section_iterator;
     std::pair<const_section_iterator, const_section_iterator> sub_sections =
         this->parser.getSubSections(_st_mesh);
 
     if (sub_sections.first != sub_sections.second) {
       std::string cohesive_surfaces =
           sub_sections.first->getParameter("cohesive_surfaces");
       this->initIntrinsicCohesiveMaterials(cohesive_surfaces);
     } else {
       this->initIntrinsicCohesiveMaterials(cohesive_index);
     }
   }
 
   AKANTU_DEBUG_OUT();
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initIntrinsicCohesiveMaterials(
-    std::string cohesive_surfaces) {
+    const std::string & cohesive_surfaces) {
 
   AKANTU_DEBUG_IN();
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   if (facet_synchronizer != nullptr)
     inserter->initParallel(facet_synchronizer, cohesive_element_synchronizer);
 //    inserter->initParallel(facet_synchronizer, synch_parallel);
 #endif
   std::istringstream split(cohesive_surfaces);
   std::string physname;
   while (std::getline(split, physname, ',')) {
     AKANTU_DEBUG_INFO(
         "Pre-inserting cohesive elements along facets from physical surface: "
         << physname);
     insertElementsFromMeshData(physname);
   }
 
   synchronizeInsertionData();
 
   SolidMechanicsModel::initMaterials();
 
   if (is_default_material_selector)
     delete material_selector;
   material_selector = new MeshDataMaterialCohesiveSelector(*this);
 
   // UInt nb_new_elements =
   inserter->insertElements();
   // if (nb_new_elements > 0) {
   //   this->reinitializeSolver();
   // }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::synchronizeInsertionData() {
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   if (facet_synchronizer != nullptr) {
     facet_synchronizer->asynchronousSynchronize(*inserter, _gst_ce_groups);
     facet_synchronizer->waitEndSynchronize(*inserter, _gst_ce_groups);
   }
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initIntrinsicCohesiveMaterials(
     UInt cohesive_index) {
 
   AKANTU_DEBUG_IN();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     Mesh::type_iterator first =
         mesh.firstType(Model::spatial_dimension, *gt, _ek_cohesive);
     Mesh::type_iterator last =
         mesh.lastType(Model::spatial_dimension, *gt, _ek_cohesive);
 
     for (; first != last; ++first) {
       Array<UInt> & mat_indexes = this->material_index(*first, *gt);
       Array<UInt> & mat_loc_num = this->material_local_numbering(*first, *gt);
       mat_indexes.set(cohesive_index);
       mat_loc_num.clear();
     }
   }
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   if (facet_synchronizer != nullptr)
     inserter->initParallel(facet_synchronizer, cohesive_element_synchronizer);
 //    inserter->initParallel(facet_synchronizer, synch_parallel);
 #endif
 
   SolidMechanicsModel::initMaterials();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Initialize the model,basically it  pre-compute the shapes, shapes derivatives
  * and jacobian
  *
  */
 void SolidMechanicsModelCohesive::initModel() {
   AKANTU_DEBUG_IN();
 
   SolidMechanicsModel::initModel();
 
   registerFEEngineObject<MyFEEngineCohesiveType>("CohesiveFEEngine", mesh,
                                                  Model::spatial_dimension);
 
   /// add cohesive type connectivity
   ElementType type = _not_defined;
 
   for (auto && type_ghost : ghost_types) {
     for (const auto & tmp_type :
          mesh.elementTypes(spatial_dimension, type_ghost)) {
       const Array<UInt> & connectivity =
           mesh.getConnectivity(tmp_type, type_ghost);
       if (connectivity.size() == 0)
         continue;
 
       type = tmp_type;
       ElementType type_facet = Mesh::getFacetType(type);
       ElementType type_cohesive = FEEngine::getCohesiveElementType(type_facet);
       mesh.addConnectivityType(type_cohesive, type_ghost);
     }
   }
 
   AKANTU_DEBUG_ASSERT(type != _not_defined, "No elements in the mesh");
 
   getFEEngine("CohesiveFEEngine").initShapeFunctions(_not_ghost);
   getFEEngine("CohesiveFEEngine").initShapeFunctions(_ghost);
 
   registerFEEngineObject<MyFEEngineFacetType>(
       "FacetsFEEngine", mesh.getMeshFacets(), Model::spatial_dimension - 1);
 
   if (is_extrinsic) {
     getFEEngine("FacetsFEEngine").initShapeFunctions(_not_ghost);
     getFEEngine("FacetsFEEngine").initShapeFunctions(_ghost);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::limitInsertion(BC::Axis axis,
                                                  Real first_limit,
                                                  Real second_limit) {
   AKANTU_DEBUG_IN();
   inserter->setLimit(axis, first_limit, second_limit);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::insertIntrinsicElements() {
   AKANTU_DEBUG_IN();
   // UInt nb_new_elements =
   inserter->insertIntrinsicElements();
   // if (nb_new_elements > 0) {
   //   this->reinitializeSolver();
   // }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::insertElementsFromMeshData(
-    std::string physname) {
+    const std::string & physname) {
   AKANTU_DEBUG_IN();
 
   UInt material_index = SolidMechanicsModel::getMaterialIndex(physname);
   inserter->insertIntrinsicElements(physname, material_index);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initAutomaticInsertion() {
   AKANTU_DEBUG_IN();
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   if (facet_stress_synchronizer != nullptr) {
     DataAccessor * data_accessor = this;
     const ElementTypeMapArray<UInt> & rank_to_element =
         synch_parallel->getPrankToElement();
 
     facet_stress_synchronizer->updateFacetStressSynchronizer(
         *inserter, rank_to_element, *data_accessor);
   }
 #endif
 
   facet_stress.initialize(inserter->getMeshFacets(),
                           _nb_component = 2 * Model::spatial_dimension *
                                           Model::spatial_dimension,
                           _spatial_dimension = Model::spatial_dimension - 1);
 
   // inserter->getMeshFacets().initElementTypeMapArray(
   //     facet_stress, 2 * spatial_dimension * spatial_dimension,
   //     spatial_dimension - 1);
 
   resizeFacetStress();
 
   /// compute normals on facets
   computeNormals();
 
   initStressInterpolation();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::updateAutomaticInsertion() {
   AKANTU_DEBUG_IN();
 
   inserter->limitCheckFacets();
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   if (facet_stress_synchronizer != nullptr) {
     DataAccessor * data_accessor = this;
     const ElementTypeMapArray<UInt> & rank_to_element =
         synch_parallel->getPrankToElement();
 
     facet_stress_synchronizer->updateFacetStressSynchronizer(
         *inserter, rank_to_element, *data_accessor);
   }
 #endif
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initStressInterpolation() {
   Mesh & mesh_facets = inserter->getMeshFacets();
 
   /// compute quadrature points coordinates on facets
   Array<Real> & position = mesh.getNodes();
 
   ElementTypeMapArray<Real> quad_facets("quad_facets", id);
   quad_facets.initialize(mesh_facets, _nb_component = Model::spatial_dimension,
                          _spatial_dimension = Model::spatial_dimension - 1);
   // mesh_facets.initElementTypeMapArray(quad_facets, Model::spatial_dimension,
   //                                     Model::spatial_dimension - 1);
 
   getFEEngine("FacetsFEEngine")
       .interpolateOnIntegrationPoints(position, quad_facets);
 
   /// compute elements quadrature point positions and build
   /// element-facet quadrature points data structure
   ElementTypeMapArray<Real> elements_quad_facets("elements_quad_facets", id);
 
   elements_quad_facets.initialize(
       mesh, _nb_component = Model::spatial_dimension,
       _spatial_dimension = Model::spatial_dimension);
   // mesh.initElementTypeMapArray(elements_quad_facets,
   // Model::spatial_dimension,
   //                              Model::spatial_dimension);
 
   for (auto elem_gt : ghost_types) {
     for (auto & type : mesh.elementTypes(Model::spatial_dimension, elem_gt)) {
       UInt nb_element = mesh.getNbElement(type, elem_gt);
       if (nb_element == 0)
         continue;
 
       /// compute elements' quadrature points and list of facet
       /// quadrature points positions by element
       Array<Element> & facet_to_element =
           mesh_facets.getSubelementToElement(type, elem_gt);
       UInt nb_facet_per_elem = facet_to_element.getNbComponent();
 
       Array<Real> & el_q_facet = elements_quad_facets(type, elem_gt);
 
       ElementType facet_type = Mesh::getFacetType(type);
 
       UInt nb_quad_per_facet =
           getFEEngine("FacetsFEEngine").getNbIntegrationPoints(facet_type);
 
       el_q_facet.resize(nb_element * nb_facet_per_elem * nb_quad_per_facet);
 
       for (UInt el = 0; el < nb_element; ++el) {
         for (UInt f = 0; f < nb_facet_per_elem; ++f) {
           Element global_facet_elem = facet_to_element(el, f);
           UInt global_facet = global_facet_elem.element;
           GhostType facet_gt = global_facet_elem.ghost_type;
           const Array<Real> & quad_f = quad_facets(facet_type, facet_gt);
 
           for (UInt q = 0; q < nb_quad_per_facet; ++q) {
             for (UInt s = 0; s < Model::spatial_dimension; ++s) {
               el_q_facet(el * nb_facet_per_elem * nb_quad_per_facet +
                              f * nb_quad_per_facet + q,
                          s) = quad_f(global_facet * nb_quad_per_facet + q, s);
             }
           }
         }
       }
     }
   }
 
   /// loop over non cohesive materials
   for (UInt m = 0; m < materials.size(); ++m) {
     try {
-      MaterialCohesive & mat __attribute__((unused)) =
+      auto & mat __attribute__((unused)) =
           dynamic_cast<MaterialCohesive &>(*materials[m]);
     } catch (std::bad_cast &) {
       /// initialize the interpolation function
       materials[m]->initElementalFieldInterpolation(elements_quad_facets);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::assembleInternalForces() {
   AKANTU_DEBUG_IN();
 
   // f_int += f_int_cohe
   for (auto & material : this->materials) {
     try {
-      MaterialCohesive & mat = dynamic_cast<MaterialCohesive &>(*material);
+      auto & mat = dynamic_cast<MaterialCohesive &>(*material);
       mat.computeTraction(_not_ghost);
     } catch (std::bad_cast & bce) {
     }
   }
 
   SolidMechanicsModel::assembleInternalForces();
 
   if (isDefaultSolverExplicit()) {
     for (auto & material : materials) {
       try {
-        MaterialCohesive & mat = dynamic_cast<MaterialCohesive &>(*material);
+        auto & mat = dynamic_cast<MaterialCohesive &>(*material);
         mat.computeEnergies();
       } catch (std::bad_cast & bce) {
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::computeNormals() {
   AKANTU_DEBUG_IN();
 
   Mesh & mesh_facets = this->inserter->getMeshFacets();
   this->getFEEngine("FacetsFEEngine")
       .computeNormalsOnIntegrationPoints(_not_ghost);
 
   /**
    *  @todo store tangents while computing normals instead of
    *  recomputing them as follows:
    */
   /* ------------------------------------------------------------------------ */
   UInt tangent_components =
       Model::spatial_dimension * (Model::spatial_dimension - 1);
 
   tangents.initialize(mesh_facets, _nb_component = tangent_components,
                       _spatial_dimension = Model::spatial_dimension - 1);
   // mesh_facets.initElementTypeMapArray(tangents, tangent_components,
   //                                     Model::spatial_dimension - 1);
 
   for (auto facet_type :
        mesh_facets.elementTypes(Model::spatial_dimension - 1)) {
     const Array<Real> & normals =
         this->getFEEngine("FacetsFEEngine")
             .getNormalsOnIntegrationPoints(facet_type);
 
     Array<Real> & tangents = this->tangents(facet_type);
 
     Math::compute_tangents(normals, tangents);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::interpolateStress() {
 
   ElementTypeMapArray<Real> by_elem_result("temporary_stress_by_facets", id);
 
   for (auto & material : materials) {
     try {
-      MaterialCohesive & mat __attribute__((unused)) =
+      auto & mat __attribute__((unused)) =
           dynamic_cast<MaterialCohesive &>(*material);
     } catch (std::bad_cast &) {
       /// interpolate stress on facet quadrature points positions
       material->interpolateStressOnFacets(facet_stress, by_elem_result);
     }
   }
 
 #if defined(AKANTU_DEBUG_TOOLS)
   debug::element_manager.printData(
       debug::_dm_model_cohesive, "Interpolated stresses before", facet_stress);
 #endif
 
   this->synchronize(_gst_smmc_facets_stress);
 
 #if defined(AKANTU_DEBUG_TOOLS)
   debug::element_manager.printData(debug::_dm_model_cohesive,
                                    "Interpolated stresses", facet_stress);
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 UInt SolidMechanicsModelCohesive::checkCohesiveStress() {
   interpolateStress();
 
   for (auto & mat : materials) {
     try {
-      MaterialCohesive & mat_cohesive = dynamic_cast<MaterialCohesive &>(*mat);
+      auto & mat_cohesive = dynamic_cast<MaterialCohesive &>(*mat);
       /// check which not ghost cohesive elements are to be created
       mat_cohesive.checkInsertion();
     } catch (std::bad_cast &) {
     }
   }
 
   /// communicate data among processors
   this->synchronize(_gst_smmc_facets);
 
   /// insert cohesive elements
   UInt nb_new_elements = inserter->insertElements();
 
   // if (nb_new_elements > 0) {
   //   this->reinitializeSolver();
   // }
 
   return nb_new_elements;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::onElementsAdded(
     const Array<Element> & element_list, const NewElementsEvent & event) {
   AKANTU_DEBUG_IN();
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   updateCohesiveSynchronizers();
 #endif
 
   SolidMechanicsModel::onElementsAdded(element_list, event);
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   if (cohesive_element_synchronizer != nullptr)
     cohesive_element_synchronizer->computeAllBufferSizes(*this);
 #endif
 
   if (is_extrinsic)
     resizeFacetStress();
 
   ///  if (method != _explicit_lumped_mass) {
   ///    this->initSolver();
   ///  }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::onNodesAdded(const Array<UInt> & new_nodes,
                                                const NewNodesEvent & event) {
   AKANTU_DEBUG_IN();
 
   // Array<UInt> nodes_list(nb_new_nodes);
 
   // for (UInt n = 0; n < nb_new_nodes; ++n)
   //   nodes_list(n) = doubled_nodes(n, 1);
   SolidMechanicsModel::onNodesAdded(new_nodes, event);
 
   UInt new_node, old_node;
 
   try {
     const auto & cohesive_event =
         dynamic_cast<const CohesiveNewNodesEvent &>(event);
     const auto & old_nodes = cohesive_event.getOldNodesList();
 
     auto copy = [this, &new_node, &old_node](auto & arr) {
       for (UInt s = 0; s < spatial_dimension; ++s) {
         arr(new_node, s) = arr(old_node, s);
       }
     };
 
     for (auto && pair : zip(new_nodes, old_nodes)) {
       std::tie(new_node, old_node) = pair;
 
       copy(*displacement);
       copy(*blocked_dofs);
 
       if (velocity)
         copy(*velocity);
 
       if (acceleration)
         copy(*acceleration);
 
       if (current_position)
         copy(*current_position);
 
       if (previous_displacement)
         copy(*previous_displacement);
     }
 
     // if (this->getDOFManager().hasMatrix("M")) {
     //   this->assembleMass(old_nodes);
     // }
 
     // if (this->getDOFManager().hasLumpedMatrix("M")) {
     //   this->assembleMassLumped(old_nodes);
     // }
 
   } catch (std::bad_cast &) {
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::onEndSolveStep(const AnalysisMethod &) {
 
   AKANTU_DEBUG_IN();
 
   /*
    * This is required because the Cauchy stress is the stress measure that
    * is used to check the insertion of cohesive elements
    */
   for (auto & mat : materials) {
     if (mat->isFiniteDeformation())
       mat->computeAllCauchyStresses(_not_ghost);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::printself(std::ostream & stream,
                                             int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "SolidMechanicsModelCohesive [" << std::endl;
 
   SolidMechanicsModel::printself(stream, indent + 1);
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::resizeFacetStress() {
   AKANTU_DEBUG_IN();
 
   Mesh & mesh_facets = inserter->getMeshFacets();
 
   for (auto && ghost_type : ghost_types) {
     for (const auto & type :
          mesh_facets.elementTypes(spatial_dimension - 1, ghost_type)) {
       UInt nb_facet = mesh_facets.getNbElement(type, ghost_type);
 
       UInt nb_quadrature_points = getFEEngine("FacetsFEEngine")
                                       .getNbIntegrationPoints(type, ghost_type);
 
       UInt new_size = nb_facet * nb_quadrature_points;
 
       facet_stress(type, ghost_type).resize(new_size);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::addDumpGroupFieldToDumper(
     const std::string & dumper_name, const std::string & field_id,
     const std::string & group_name, const ElementKind & element_kind,
     bool padding_flag) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = Model::spatial_dimension;
   ElementKind _element_kind = element_kind;
   if (dumper_name == "cohesive elements") {
     _element_kind = _ek_cohesive;
   } else if (dumper_name == "facets") {
     spatial_dimension = Model::spatial_dimension - 1;
   }
   SolidMechanicsModel::addDumpGroupFieldToDumper(dumper_name, field_id,
                                                  group_name, spatial_dimension,
                                                  _element_kind, padding_flag);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 void SolidMechanicsModelCohesive::onDump() {
   this->flattenAllRegisteredInternals(_ek_cohesive);
   SolidMechanicsModel::onDump();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.hh b/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.hh
index 776917483..6a79755c7 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.hh
+++ b/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.hh
@@ -1,349 +1,349 @@
 /**
  * @file   solid_mechanics_model_cohesive.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue May 08 2012
  * @date last modification: Mon Dec 14 2015
  *
  * @brief  Solid mechanics model for cohesive elements
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "cohesive_element_inserter.hh"
 #include "material_selector_cohesive.hh"
 #include "random_internal_field.hh" // included to have the specialization of
 #include "solid_mechanics_model.hh"
 #include "solid_mechanics_model_event_handler.hh"
 // ParameterTyped::operator Real()
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SOLID_MECHANICS_MODEL_COHESIVE_HH__
 #define __AKANTU_SOLID_MECHANICS_MODEL_COHESIVE_HH__
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 class FacetSynchronizer;
 class FacetStressSynchronizer;
 class ElementSynchronizer;
 } // namespace akantu
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 struct FacetsCohesiveIntegrationOrderFunctor {
   template <ElementType type, ElementType cohesive_type =
                                   CohesiveFacetProperty<type>::cohesive_type>
   struct _helper {
     static constexpr int get() {
       return ElementClassProperty<cohesive_type>::polynomial_degree;
     }
   };
 
   template <ElementType type> struct _helper<type, _not_defined> {
     static constexpr int get() {
       return ElementClassProperty<type>::polynomial_degree;
     }
   };
 
   template <ElementType type> static inline constexpr int getOrder() {
     return _helper<type>::get();
   }
 };
 
 namespace {
   DECLARE_NAMED_ARGUMENT(is_extrinsic);
 }
 /* -------------------------------------------------------------------------- */
 struct SolidMechanicsModelCohesiveOptions : public SolidMechanicsModelOptions {
   SolidMechanicsModelCohesiveOptions(
       AnalysisMethod analysis_method = _explicit_lumped_mass,
       bool extrinsic = false)
       : SolidMechanicsModelOptions(analysis_method), extrinsic(extrinsic) {}
 
   template <typename... pack>
   SolidMechanicsModelCohesiveOptions(use_named_args_t, pack &&... _pack)
       : SolidMechanicsModelCohesiveOptions(
             OPTIONAL_NAMED_ARG(analysis_method, _explicit_lumped_mass),
             OPTIONAL_NAMED_ARG(is_extrinsic, false)) {}
 
   bool extrinsic{false};
 };
 
 /* -------------------------------------------------------------------------- */
 /* Solid Mechanics Model for Cohesive elements                                */
 /* -------------------------------------------------------------------------- */
 
 class SolidMechanicsModelCohesive : public SolidMechanicsModel,
                                     public SolidMechanicsModelEventHandler {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   class NewCohesiveNodesEvent : public NewNodesEvent {
   public:
     AKANTU_GET_MACRO_NOT_CONST(OldNodesList, old_nodes, Array<UInt> &);
     AKANTU_GET_MACRO(OldNodesList, old_nodes, const Array<UInt> &);
 
   protected:
     Array<UInt> old_nodes;
   };
 
   typedef FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_cohesive>
       MyFEEngineCohesiveType;
   typedef FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_regular,
                            FacetsCohesiveIntegrationOrderFunctor>
       MyFEEngineFacetType;
 
   SolidMechanicsModelCohesive(Mesh & mesh,
                               UInt spatial_dimension = _all_dimensions,
                               const ID & id = "solid_mechanics_model_cohesive",
                               const MemoryID & memory_id = 0);
 
   ~SolidMechanicsModelCohesive() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// set the value of the time step
   void setTimeStep(Real time_step, const ID & solver_id = "") override;
 
   /// assemble the residual for the explicit scheme
   void assembleInternalForces() override;
 
   /// function to perform a stress check on each facet and insert
   /// cohesive elements if needed (returns the number of new cohesive
   /// elements)
   UInt checkCohesiveStress();
 
   /// interpolate stress on facets
   void interpolateStress();
 
   /// initialize the cohesive model
   void initFull(const ModelOptions & options =
                     SolidMechanicsModelCohesiveOptions()) override;
 
   template <typename P, typename T, typename... pack>
   void initFull(named_argument::param_t<P, T &&> && first, pack &&... _pack) {
     this->initFull(
         SolidMechanicsModelCohesiveOptions{use_named_args, first, _pack...});
   }
 
   /// limit the cohesive element insertion to a given area
   void limitInsertion(BC::Axis axis, Real first_limit, Real second_limit);
 
   /// update automatic insertion after a change in the element inserter
   void updateAutomaticInsertion();
 
   /// insert intrinsic cohesive elements
   void insertIntrinsicElements();
 
   // template <SolveConvergenceMethod cmethod, SolveConvergenceCriteria
   // criteria> bool solveStepCohesive(Real tolerance, Real & error, UInt
   // max_iteration = 100,
   //                        bool load_reduction = false,
   //                        Real tol_increase_factor = 1.0,
   //                        bool do_not_factorize = false);
 
 protected:
   /// initialize stress interpolation
   void initStressInterpolation();
 
   /// initialize the model
   void initModel() override;
 
   /// initialize cohesive material
   void initMaterials() override;
 
   /// init facet filters for cohesive materials
   void initFacetFilter();
 
   // synchronize facets physical data before insertion along physical surfaces
   void synchronizeInsertionData();
 
   /// function to print the contain of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
 private:
   /// initialize cohesive material with intrinsic insertion (by default)
   void initIntrinsicCohesiveMaterials(UInt cohesive_index);
 
   ///  initialize cohesive material with intrinsic insertion (if physical
   ///  surfaces are precised)
-  void initIntrinsicCohesiveMaterials(std::string cohesive_surfaces);
+  void initIntrinsicCohesiveMaterials(const std::string & cohesive_surfaces);
 
   /// insert cohesive elements along a given physical surface of the mesh
-  void insertElementsFromMeshData(std::string physical_name);
+  void insertElementsFromMeshData(const std::string & physical_name);
 
   /// initialize completely the model for extrinsic elements
   void initAutomaticInsertion();
 
   /// compute facets' normals
   void computeNormals();
 
   /// resize facet stress
   void resizeFacetStress();
 
   /// init facets_check array
   void initFacetsCheck();
 
   /* ------------------------------------------------------------------------ */
   /* Mesh Event Handler inherited members                                     */
   /* ------------------------------------------------------------------------ */
 
 protected:
   void onNodesAdded(const Array<UInt> & nodes_list,
                     const NewNodesEvent & event) override;
   void onElementsAdded(const Array<Element> & nodes_list,
                        const NewElementsEvent & event) override;
 
   /* ------------------------------------------------------------------------ */
   /* SolidMechanicsModelEventHandler inherited members                        */
   /* ------------------------------------------------------------------------ */
 public:
   void onEndSolveStep(const AnalysisMethod & method) override;
 
   /* ------------------------------------------------------------------------ */
   /* Dumpable interface                                                       */
   /* ------------------------------------------------------------------------ */
 public:
   void onDump() override;
 
   void addDumpGroupFieldToDumper(const std::string & dumper_name,
                                  const std::string & field_id,
                                  const std::string & group_name,
                                  const ElementKind & element_kind,
                                  bool padding_flag) override;
 
 public:
   /// register the tags associated with the parallel synchronizer for
   /// cohesive elements
   // void initParallel(MeshPartition * partition,
   //                DataAccessor * data_accessor = NULL,
   //                bool extrinsic = false);
 
 protected:
   void synchronizeGhostFacetsConnectivity();
 
   void updateCohesiveSynchronizers();
 
   /* ------------------------------------------------------------------------ */
   /* Data Accessor inherited members                                          */
   /* ------------------------------------------------------------------------ */
 public:
   UInt getNbData(const Array<Element> & elements,
                  const SynchronizationTag & tag) const override;
 
   void packData(CommunicationBuffer & buffer, const Array<Element> & elements,
                 const SynchronizationTag & tag) const override;
 
   void unpackData(CommunicationBuffer & buffer, const Array<Element> & elements,
                   const SynchronizationTag & tag) override;
 
 protected:
   UInt getNbQuadsForFacetCheck(const Array<Element> & elements) const;
 
   template <typename T>
   void packFacetStressDataHelper(const ElementTypeMapArray<T> & data_to_pack,
                                  CommunicationBuffer & buffer,
                                  const Array<Element> & elements) const;
 
   template <typename T>
   void unpackFacetStressDataHelper(ElementTypeMapArray<T> & data_to_unpack,
                                    CommunicationBuffer & buffer,
                                    const Array<Element> & elements) const;
 
   template <typename T, bool pack_helper>
   void packUnpackFacetStressDataHelper(ElementTypeMapArray<T> & data_to_pack,
                                        CommunicationBuffer & buffer,
                                        const Array<Element> & element) const;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get facet mesh
   AKANTU_GET_MACRO(MeshFacets, mesh.getMeshFacets(), const Mesh &);
 
   /// get stress on facets vector
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(StressOnFacets, facet_stress, Real);
 
   /// get facet material
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(FacetMaterial, facet_material, UInt);
 
   /// get facet material
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(FacetMaterial, facet_material, UInt);
 
   /// get facet material
   AKANTU_GET_MACRO(FacetMaterial, facet_material,
                    const ElementTypeMapArray<UInt> &);
 
   /// @todo THIS HAS TO BE CHANGED
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Tangents, tangents, Real);
 
   /// get element inserter
   AKANTU_GET_MACRO_NOT_CONST(ElementInserter, *inserter,
                              CohesiveElementInserter &);
 
   /// get is_extrinsic boolean
   AKANTU_GET_MACRO(IsExtrinsic, is_extrinsic, bool);
 
   /// get cohesive elements synchronizer
   AKANTU_GET_MACRO(CohesiveSynchronizer, *cohesive_synchronizer,
                    const ElementSynchronizer &);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// @todo store tangents when normals are computed:
   ElementTypeMapArray<Real> tangents;
 
   /// stress on facets on the two sides by quadrature point
   ElementTypeMapArray<Real> facet_stress;
 
   /// material to use if a cohesive element is created on a facet
   ElementTypeMapArray<UInt> facet_material;
 
   bool is_extrinsic;
 
   /// cohesive element inserter
   std::unique_ptr<CohesiveElementInserter> inserter;
 
   /// facet stress synchronizer
   std::unique_ptr<ElementSynchronizer> facet_stress_synchronizer;
 
   /// cohesive elements synchronizer
   std::unique_ptr<ElementSynchronizer> cohesive_synchronizer;
 
   /// global connectivity
   ElementTypeMapArray<UInt> * global_connectivity;
 };
 
 } // namespace akantu
 
 #include "solid_mechanics_model_cohesive_inline_impl.cc"
 #include "solid_mechanics_model_cohesive_parallel_inline_impl.cc"
 
 #endif /* __AKANTU_SOLID_MECHANICS_MODEL_COHESIVE_HH__ */
diff --git a/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive_parallel.cc b/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive_parallel.cc
index 7dbc2a198..78d1cfaa1 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive_parallel.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive_parallel.cc
@@ -1,397 +1,397 @@
 /**
  * @file   solid_mechanics_model_cohesive_parallel.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  *
  * @brief  Functions for parallel cohesive elements
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "element_synchronizer.hh"
 #include "solid_mechanics_model_cohesive.hh"
 #include "solid_mechanics_model_tmpl.hh"
 #include "communicator.hh"
 /* -------------------------------------------------------------------------- */
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::synchronizeGhostFacetsConnectivity() {
   AKANTU_DEBUG_IN();
 
   const Communicator & comm = mesh.getCommunicator();
   Int psize = comm.getNbProc();
 
   if (psize > 1) {
 
     /// get global connectivity for not ghost facets
     global_connectivity =
         new ElementTypeMapArray<UInt>("global_connectivity", id);
 
     auto & mesh_facets = inserter->getMeshFacets();
 
     global_connectivity->initialize(
         mesh_facets, _spatial_dimension = spatial_dimension - 1,
         _with_nb_element = true, _with_nb_nodes_per_element = true,
         _element_kind = _ek_regular,
         _ghost_type = _not_ghost);
 
     mesh_facets.getGlobalConnectivity(*global_connectivity);
 
     /// communicate
     synchronize(_gst_smmc_facets_conn);
 
     /// flip facets
     MeshUtils::flipFacets(mesh_facets, *global_connectivity, _ghost);
 
     delete global_connectivity;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::updateCohesiveSynchronizers() {
   /// update synchronizers if needed
 
   if (not mesh.isDistributed())
     return;
 
   auto & mesh_facets = inserter->getMeshFacets();
   auto & facet_synchronizer = mesh_facets.getElementSynchronizer();
   const auto & cfacet_synchronizer = facet_synchronizer;
 
   // update the cohesive element synchronizer
   cohesive_synchronizer->updateSchemes(
       [&](auto && scheme, auto && proc, auto && direction) {
         auto & facet_scheme =
             cfacet_synchronizer.getCommunications().getScheme(proc, direction);
 
         for (auto && facet : facet_scheme) {
           const auto & connected_elements = mesh_facets.getElementToSubelement(
               facet.type,
               facet.ghost_type)(facet.element); // slow access here
           const auto & cohesive_element = connected_elements[1];
 
           auto && cohesive_type = FEEngine::getCohesiveElementType(facet.type);
           auto old_nb_cohesive_elements =
               mesh.getNbElement(cohesive_type, facet.ghost_type);
           old_nb_cohesive_elements -=
             mesh.getData<UInt>("facet_to_double", facet.type,
                                facet.ghost_type).size();
 
           if (cohesive_element.kind() == _ek_cohesive and
               cohesive_element.element >= old_nb_cohesive_elements) {
             scheme.push_back(cohesive_element);
           }
         }
       });
 
   const auto & comm = mesh.getCommunicator();
   auto && my_rank = comm.whoAmI();
 
   // update the facet stress synchronizer
   facet_stress_synchronizer->updateSchemes([&](auto && scheme, auto && proc,
                                                auto && /*direction*/) {
     auto it_element = scheme.begin();
     for (auto && element : scheme) {
       auto && facet_check = inserter->getCheckFacets(
           element.type, element.ghost_type)(element.element); // slow access
                                                               // here
 
       if (facet_check) {
         auto && connected_elements = mesh_facets.getElementToSubelement(
             element.type, element.ghost_type)(element.element); // slow access
                                                                 // here
         auto && rank_left = facet_synchronizer.getRank(connected_elements[0]);
         auto && rank_right = facet_synchronizer.getRank(connected_elements[1]);
 
         // keep element if the element is still a boundary element between two
         // processors
         if ((rank_left == Int(proc) and rank_right == my_rank) or
             (rank_left == my_rank and rank_right == Int(proc))) {
           *it_element = element;
           ++it_element;
         }
       }
     }
     scheme.resize(it_element - scheme.begin());
   });
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void SolidMechanicsModelCohesive::packFacetStressDataHelper(
     const ElementTypeMapArray<T> & data_to_pack, CommunicationBuffer & buffer,
     const Array<Element> & elements) const {
   packUnpackFacetStressDataHelper<T, true>(
       const_cast<ElementTypeMapArray<T> &>(data_to_pack), buffer, elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void SolidMechanicsModelCohesive::unpackFacetStressDataHelper(
     ElementTypeMapArray<T> & data_to_unpack, CommunicationBuffer & buffer,
     const Array<Element> & elements) const {
   packUnpackFacetStressDataHelper<T, false>(data_to_unpack, buffer, elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, bool pack_helper>
 void SolidMechanicsModelCohesive::packUnpackFacetStressDataHelper(
     ElementTypeMapArray<T> & data_to_pack, CommunicationBuffer & buffer,
     const Array<Element> & elements) const {
   ElementType current_element_type = _not_defined;
   GhostType current_ghost_type = _casper;
   UInt nb_quad_per_elem = 0;
   UInt sp2 = spatial_dimension * spatial_dimension;
   UInt nb_component = sp2 * 2;
-  bool element_rank = 0;
+  bool element_rank = false;
   Mesh & mesh_facets = inserter->getMeshFacets();
 
   Array<T> * vect = nullptr;
   Array<std::vector<Element>> * element_to_facet = nullptr;
 
   auto & fe_engine = this->getFEEngine("FacetsFEEngine");
   for (auto && el : elements) {
     if (el.type != current_element_type ||
         el.ghost_type != current_ghost_type) {
       current_element_type = el.type;
       current_ghost_type = el.ghost_type;
       vect = &data_to_pack(el.type, el.ghost_type);
 
       element_to_facet =
           &(mesh_facets.getElementToSubelement(el.type, el.ghost_type));
 
       nb_quad_per_elem =
           fe_engine.getNbIntegrationPoints(el.type, el.ghost_type);
     }
 
     if (pack_helper)
       element_rank =
           (*element_to_facet)(el.element)[0].ghost_type != _not_ghost;
     else
       element_rank =
           (*element_to_facet)(el.element)[0].ghost_type == _not_ghost;
 
     for (UInt q = 0; q < nb_quad_per_elem; ++q) {
       Vector<T> data(vect->storage() +
                          (el.element * nb_quad_per_elem + q) * nb_component +
                          element_rank * sp2,
                      sp2);
 
       if (pack_helper)
         buffer << data;
       else
         buffer >> data;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 UInt SolidMechanicsModelCohesive::getNbQuadsForFacetCheck(
     const Array<Element> & elements) const {
   UInt nb_quads = 0;
   UInt nb_quad_per_facet = 0;
 
   ElementType current_element_type = _not_defined;
   GhostType current_ghost_type = _casper;
   auto & fe_engine = this->getFEEngine("FacetsFEEngine");
   for(auto & el : elements) {
     if (el.type != current_element_type ||
         el.ghost_type != current_ghost_type) {
       current_element_type = el.type;
       current_ghost_type = el.ghost_type;
 
       nb_quad_per_facet = fe_engine
                               .getNbIntegrationPoints(el.type, el.ghost_type);
     }
 
     nb_quads += nb_quad_per_facet;
   }
 
   return nb_quads;
 }
 
 /* -------------------------------------------------------------------------- */
 UInt SolidMechanicsModelCohesive::getNbData(
     const Array<Element> & elements, const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
   if (elements.size() == 0)
     return 0;
 
   /// regular element case
   if (elements(0).kind() == _ek_regular) {
 
     switch (tag) {
     case _gst_smmc_facets: {
       size += elements.size() * sizeof(bool);
       break;
     }
     case _gst_smmc_facets_conn: {
       UInt nb_nodes = Mesh::getNbNodesPerElementList(elements);
       size += nb_nodes * sizeof(UInt);
       break;
     }
     case _gst_smmc_facets_stress: {
       UInt nb_quads = getNbQuadsForFacetCheck(elements);
       size += nb_quads * spatial_dimension * spatial_dimension * sizeof(Real);
       break;
     }
     default: { size += SolidMechanicsModel::getNbData(elements, tag); }
     }
   }
   /// cohesive element case
   else if (elements(0).kind() == _ek_cohesive) {
 
     switch (tag) {
     case _gst_material_id: {
       size += elements.size() * sizeof(UInt);
       break;
     }
     case _gst_smm_boundary: {
       UInt nb_nodes_per_element = 0;
 
       for (auto && el : elements) {
         nb_nodes_per_element += Mesh::getNbNodesPerElement(el.type);
       }
 
       // force, displacement, boundary
       size += nb_nodes_per_element * spatial_dimension *
               (2 * sizeof(Real) + sizeof(bool));
       break;
     }
     default:
       break;
     }
 
     if (tag != _gst_material_id && tag != _gst_smmc_facets) {
       splitByMaterial(elements, [&](auto && mat, auto && elements) {
         size += mat.getNbData(elements, tag);
       });
     }
   }
 
   AKANTU_DEBUG_OUT();
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::packData(
     CommunicationBuffer & buffer, const Array<Element> & elements,
     const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   if (elements.size() == 0)
     return;
 
   if (elements(0).kind() == _ek_regular) {
     switch (tag) {
     case _gst_smmc_facets: {
       packElementalDataHelper(inserter->getInsertionFacetsByElement(), buffer,
                               elements, false, getFEEngine());
       break;
     }
     case _gst_smmc_facets_conn: {
       packElementalDataHelper(*global_connectivity, buffer, elements, false,
                               getFEEngine());
       break;
     }
     case _gst_smmc_facets_stress: {
       packFacetStressDataHelper(facet_stress, buffer, elements);
       break;
     }
     default: { SolidMechanicsModel::packData(buffer, elements, tag); }
     }
   } else if (elements(0).kind() == _ek_cohesive) {
     switch (tag) {
     case _gst_material_id: {
       packElementalDataHelper(material_index, buffer, elements, false,
                               getFEEngine("CohesiveFEEngine"));
       break;
     }
     case _gst_smm_boundary: {
       packNodalDataHelper(*internal_force, buffer, elements, mesh);
       packNodalDataHelper(*velocity, buffer, elements, mesh);
       packNodalDataHelper(*blocked_dofs, buffer, elements, mesh);
       break;
     }
     default: {}
     }
 
     if (tag != _gst_material_id && tag != _gst_smmc_facets) {
       splitByMaterial(elements, [&](auto && mat, auto && elements) {
         mat.packData(buffer, elements, tag);
       });
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::unpackData(CommunicationBuffer & buffer,
                                              const Array<Element> & elements,
                                              const SynchronizationTag & tag) {
   AKANTU_DEBUG_IN();
 
   if (elements.size() == 0)
     return;
 
   if (elements(0).kind() == _ek_regular) {
     switch (tag) {
     case _gst_smmc_facets: {
       unpackElementalDataHelper(inserter->getInsertionFacetsByElement(), buffer,
                                 elements, false, getFEEngine());
       break;
     }
     case _gst_smmc_facets_conn: {
       unpackElementalDataHelper(*global_connectivity, buffer, elements, false,
                                 getFEEngine());
       break;
     }
     case _gst_smmc_facets_stress: {
       unpackFacetStressDataHelper(facet_stress, buffer, elements);
       break;
     }
     default: { SolidMechanicsModel::unpackData(buffer, elements, tag); }
     }
   } else if (elements(0).kind() == _ek_cohesive) {
     switch (tag) {
     case _gst_material_id: {
       unpackElementalDataHelper(material_index, buffer, elements, false,
                                 getFEEngine("CohesiveFEEngine"));
       break;
     }
     case _gst_smm_boundary: {
       unpackNodalDataHelper(*internal_force, buffer, elements, mesh);
       unpackNodalDataHelper(*velocity, buffer, elements, mesh);
       unpackNodalDataHelper(*blocked_dofs, buffer, elements, mesh);
       break;
     }
     default: {}
     }
 
     if (tag != _gst_material_id && tag != _gst_smmc_facets) {
       splitByMaterial(elements, [&](auto && mat, auto && elements) {
         mat.unpackData(buffer, elements, tag);
       });
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/solid_mechanics_model_event_handler.hh b/src/model/solid_mechanics/solid_mechanics_model_event_handler.hh
index a51786740..c59446298 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_event_handler.hh
+++ b/src/model/solid_mechanics/solid_mechanics_model_event_handler.hh
@@ -1,127 +1,127 @@
 /**
  * @file   solid_mechanics_model_event_handler.hh
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri Dec 18 2015
  *
  * @brief  EventHandler implementation for SolidMechanicsEvents
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SOLID_MECHANICS_MODEL_EVENT_HANDLER_HH__
 #define __AKANTU_SOLID_MECHANICS_MODEL_EVENT_HANDLER_HH__
 
 namespace akantu {
 
 /// akantu::SolidMechanicsModelEvent is the base event for model
 namespace SolidMechanicsModelEvent {
 struct BeforeSolveStepEvent {
   BeforeSolveStepEvent(AnalysisMethod & method) : method(method) {}
   AnalysisMethod method;
 };
 struct AfterSolveStepEvent {
   AfterSolveStepEvent(AnalysisMethod & method) : method(method) {}
   AnalysisMethod method;
 };
 struct BeforeDumpEvent {
-  BeforeDumpEvent() {}
+  BeforeDumpEvent() = default;
 };
 struct BeginningOfDamageIterationEvent {
-  BeginningOfDamageIterationEvent() {}
+  BeginningOfDamageIterationEvent() = default;
 };
 struct AfterDamageEvent {
-  AfterDamageEvent() {}
+  AfterDamageEvent() = default;
 };
 }
 
 /// akantu::SolidMechanicsModelEvent
 class SolidMechanicsModelEventHandler {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-  virtual ~SolidMechanicsModelEventHandler(){};
+  virtual ~SolidMechanicsModelEventHandler() = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 protected:
   /// Send what is before the solve step to the beginning of solve step through
   /// EventManager
   inline void
   sendEvent(const SolidMechanicsModelEvent::BeforeSolveStepEvent & event) {
     onBeginningSolveStep(event.method);
   }
   /// Send what is after the solve step to the end of solve step through
   /// EventManager
   inline void
   sendEvent(const SolidMechanicsModelEvent::AfterSolveStepEvent & event) {
     onEndSolveStep(event.method);
   }
   /// Send what is before dump to current dump through EventManager
   inline void
   sendEvent(__attribute__((unused))
             const SolidMechanicsModelEvent::BeforeDumpEvent & event) {
     onDump();
   }
   /// Send what is at the beginning of damage iteration to Damage iteration
   /// through EventManager
   inline void sendEvent(
       __attribute__((unused))
       const SolidMechanicsModelEvent::BeginningOfDamageIterationEvent & event) {
     onDamageIteration();
   }
   /// Send what is after damage for the damage update through EventManager
   inline void
   sendEvent(__attribute__((unused))
             const SolidMechanicsModelEvent::AfterDamageEvent & event) {
     onDamageUpdate();
   }
 
   template <class EventHandler> friend class EventHandlerManager;
 
   /* ------------------------------------------------------------------------ */
   /* Interface                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// function to implement to react on akantu::BeforeSolveStepEvent
   virtual void onBeginningSolveStep(__attribute__((unused))
                                     const AnalysisMethod & method) {}
   /// function to implement to react on akantu::AfterSolveStepEvent
   virtual void onEndSolveStep(__attribute__((unused))
                               const AnalysisMethod & method) {}
   /// function to implement to react on akantu::BeforeDumpEvent
   virtual void onDump() {}
   /// function to implement to react on akantu::BeginningOfDamageIterationEvent
   virtual void onDamageIteration() {}
   /// function to implement to react on akantu::AfterDamageEvent
   virtual void onDamageUpdate() {}
 };
 
 } // akantu
 
 #endif /* __AKANTU_SOLID_MECHANICS_MODEL_EVENT_HANDLER_HH__ */
diff --git a/src/model/solid_mechanics/solid_mechanics_model_inline_impl.cc b/src/model/solid_mechanics/solid_mechanics_model_inline_impl.cc
index 6adc2fee1..e38d5e5d5 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_inline_impl.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_inline_impl.cc
@@ -1,125 +1,123 @@
 /**
  * @file   solid_mechanics_model_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Aug 04 2010
  * @date last modification: Wed Nov 18 2015
  *
  * @brief  Implementation of the inline functions of the SolidMechanicsModel
  * class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "aka_named_argument.hh"
 #include "material_selector.hh"
 #include "material_selector_tmpl.hh"
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SOLID_MECHANICS_MODEL_INLINE_IMPL_CC__
 #define __AKANTU_SOLID_MECHANICS_MODEL_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline SolidMechanicsModelOptions::SolidMechanicsModelOptions(
     AnalysisMethod analysis_method)
     : ModelOptions(analysis_method) {}
 
 /* -------------------------------------------------------------------------- */
 template <typename... pack>
 SolidMechanicsModelOptions::SolidMechanicsModelOptions(use_named_args_t,
                                                        pack &&... _pack)
     : SolidMechanicsModelOptions(
           OPTIONAL_NAMED_ARG(analysis_method, _explicit_lumped_mass)) {}
 
 /* -------------------------------------------------------------------------- */
 inline Material & SolidMechanicsModel::getMaterial(UInt mat_index) {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG_ASSERT(mat_index < materials.size(),
                       "The model " << id << " has no material no "
                                    << mat_index);
   AKANTU_DEBUG_OUT();
   return *materials[mat_index];
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Material & SolidMechanicsModel::getMaterial(UInt mat_index) const {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG_ASSERT(mat_index < materials.size(),
                       "The model " << id << " has no material no "
                                    << mat_index);
   AKANTU_DEBUG_OUT();
   return *materials[mat_index];
 }
 
 /* -------------------------------------------------------------------------- */
 inline Material & SolidMechanicsModel::getMaterial(const std::string & name) {
   AKANTU_DEBUG_IN();
   std::map<std::string, UInt>::const_iterator it =
       materials_names_to_id.find(name);
   AKANTU_DEBUG_ASSERT(it != materials_names_to_id.end(),
                       "The model " << id << " has no material named " << name);
   AKANTU_DEBUG_OUT();
   return *materials[it->second];
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt
 SolidMechanicsModel::getMaterialIndex(const std::string & name) const {
   AKANTU_DEBUG_IN();
-  std::map<std::string, UInt>::const_iterator it =
-      materials_names_to_id.find(name);
+  auto it = materials_names_to_id.find(name);
   AKANTU_DEBUG_ASSERT(it != materials_names_to_id.end(),
                       "The model " << id << " has no material named " << name);
   AKANTU_DEBUG_OUT();
   return it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Material &
 SolidMechanicsModel::getMaterial(const std::string & name) const {
   AKANTU_DEBUG_IN();
-  std::map<std::string, UInt>::const_iterator it =
-      materials_names_to_id.find(name);
+  auto it = materials_names_to_id.find(name);
   AKANTU_DEBUG_ASSERT(it != materials_names_to_id.end(),
                       "The model " << id << " has no material named " << name);
   AKANTU_DEBUG_OUT();
   return *materials[it->second];
 }
 
 /* -------------------------------------------------------------------------- */
 inline void
 SolidMechanicsModel::setMaterialSelector(MaterialSelector & selector) {
   if (is_default_material_selector)
     delete material_selector;
   material_selector = &selector;
   is_default_material_selector = false;
 }
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
 
 #endif /* __AKANTU_SOLID_MECHANICS_MODEL_INLINE_IMPL_CC__ */
diff --git a/src/model/solid_mechanics/solid_mechanics_model_mass.cc b/src/model/solid_mechanics/solid_mechanics_model_mass.cc
index 9cce541a0..792a26cb2 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_mass.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_mass.cc
@@ -1,159 +1,159 @@
 /**
  * @file   solid_mechanics_model_mass.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Oct 05 2010
  * @date last modification: Fri Oct 16 2015
  *
  * @brief  function handling mass computation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "integrator_gauss.hh"
 #include "material.hh"
 #include "model_solver.hh"
 #include "shape_lagrange.hh"
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 class ComputeRhoFunctor {
 public:
   explicit ComputeRhoFunctor(const SolidMechanicsModel & model)
       : model(model){};
 
   void operator()(Matrix<Real> & rho, const Element & element) const {
     const Array<UInt> & mat_indexes =
         model.getMaterialByElement(element.type, element.ghost_type);
     Real mat_rho =
         model.getMaterial(mat_indexes(element.element)).getParam("rho");
     rho.set(mat_rho);
   }
 
 private:
   const SolidMechanicsModel & model;
 };
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleMassLumped() {
   AKANTU_DEBUG_IN();
 
   if(not need_to_reassemble_lumped_mass) return;
 
   UInt nb_nodes = mesh.getNbNodes();
 
   if (this->mass == nullptr) {
     std::stringstream sstr_mass;
     sstr_mass << id << ":mass";
     mass =
         &(alloc<Real>(sstr_mass.str(), nb_nodes, Model::spatial_dimension, 0));
   } else {
     mass->clear();
   }
 
   if (!this->getDOFManager().hasLumpedMatrix("M")) {
     this->getDOFManager().getNewLumpedMatrix("M");
   }
 
   this->getDOFManager().clearLumpedMatrix("M");
 
   assembleMassLumped(_not_ghost);
   assembleMassLumped(_ghost);
 
   this->getDOFManager().getLumpedMatrixPerDOFs("displacement", "M",
                                                *(this->mass));
 
 /// for not connected nodes put mass to one in order to avoid
 #if !defined(AKANTU_NDEBUG)
   bool has_unconnected_nodes = false;
   auto mass_it =
       mass->begin_reinterpret(mass->size() * mass->getNbComponent());
   auto mass_end =
       mass->end_reinterpret(mass->size() * mass->getNbComponent());
   for (; mass_it != mass_end; ++mass_it) {
     if (std::abs(*mass_it) < std::numeric_limits<Real>::epsilon() ||
         Math::isnan(*mass_it)) {
       has_unconnected_nodes = true;
       break;
     }
   }
 
   if (has_unconnected_nodes)
     AKANTU_DEBUG_WARNING("There are nodes that seem to not be connected to any "
                          "elements, beware that they have lumped mass of 0.");
 #endif
 
   this->synchronize(_gst_smm_mass);
 
   need_to_reassemble_lumped_mass = false;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleMass() {
   AKANTU_DEBUG_IN();
 
   if(not need_to_reassemble_mass) return;
 
   this->getDOFManager().clearMatrix("M");
   assembleMass(_not_ghost);
 
   need_to_reassemble_mass = false;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleMassLumped(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
-  MyFEEngineType & fem = getFEEngineClass<MyFEEngineType>();
+  auto & fem = getFEEngineClass<MyFEEngineType>();
   ComputeRhoFunctor compute_rho(*this);
 
   for (auto type : mesh.elementTypes(Model::spatial_dimension, ghost_type)) {
     fem.assembleFieldLumped(compute_rho, "M", "displacement",
                             this->getDOFManager(), type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleMass(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
-  MyFEEngineType & fem = getFEEngineClass<MyFEEngineType>();
+  auto & fem = getFEEngineClass<MyFEEngineType>();
   ComputeRhoFunctor compute_rho(*this);
 
   for (auto type : mesh.elementTypes(Model::spatial_dimension, ghost_type)) {
     fem.assembleFieldMatrix(compute_rho, "M", "displacement",
                             this->getDOFManager(), type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/src/model/solver_callback.cc b/src/model/solver_callback.cc
index 406ebb202..c6445e416 100644
--- a/src/model/solver_callback.cc
+++ b/src/model/solver_callback.cc
@@ -1,53 +1,53 @@
 /**
  * @file   solver_callback.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Mar  2 12:47:17 2016
  *
  * @brief  Default behavior of solver_callbacks
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "solver_callback.hh"
 #include "dof_manager.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 SolverCallback::SolverCallback(DOFManager & dof_manager)
     : sc_dof_manager(&dof_manager) {}
 
 /* -------------------------------------------------------------------------- */
-SolverCallback::SolverCallback() : sc_dof_manager(nullptr) {}
+SolverCallback::SolverCallback() {}
 
 /* -------------------------------------------------------------------------- */
 SolverCallback::~SolverCallback() = default;
 
 /* -------------------------------------------------------------------------- */
 void SolverCallback::setDOFManager(DOFManager & dof_manager) {
   this->sc_dof_manager = &dof_manager;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/model/solver_callback.hh b/src/model/solver_callback.hh
index 583ede8d1..9ab943c99 100644
--- a/src/model/solver_callback.hh
+++ b/src/model/solver_callback.hh
@@ -1,92 +1,92 @@
 /**
  * @file   solver_callback.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Tue Sep 15 22:45:27 2015
  *
  * @brief  Class defining the interface for non_linear_solver callbacks
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SOLVER_CALLBACK_HH__
 #define __AKANTU_SOLVER_CALLBACK_HH__
 
 namespace akantu {
 class DOFManager;
 }
 
 namespace akantu {
 
 class SolverCallback {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   explicit SolverCallback(DOFManager & dof_manager);
   explicit SolverCallback();
   /* ------------------------------------------------------------------------ */
   virtual ~SolverCallback();
 
 protected:
   void setDOFManager(DOFManager & dof_manager);
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the type of matrix needed
   virtual MatrixType getMatrixType(const ID &) = 0;
 
   /// callback to assemble a Matrix
   virtual void assembleMatrix(const ID &) = 0;
 
   /// callback to assemble a lumped Matrix
   virtual void assembleLumpedMatrix(const ID &) = 0;
 
   /// callback to assemble the residual (rhs)
   virtual void assembleResidual() = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Dynamic simulations part                                                 */
   /* ------------------------------------------------------------------------ */
   /// callback for the predictor (in case of dynamic simulation)
   virtual void predictor() { }
 
   /// callback for the corrector (in case of dynamic simulation)
   virtual void corrector() { }
 
   /* ------------------------------------------------------------------------ */
   /* management callbacks                                                     */
   /* ------------------------------------------------------------------------ */
   virtual void beforeSolveStep() { };
   virtual void afterSolveStep() { };
 protected:
   /// DOFManager prefixed to avoid collision in multiple inheritance cases
-  DOFManager * sc_dof_manager;
+  DOFManager * sc_dof_manager{nullptr};
 };
 
 } // namespace akantu
 
 #endif /* __AKANTU_SOLVER_CALLBACK_HH__ */
diff --git a/src/model/time_step_solvers/time_step_solver_default.hh b/src/model/time_step_solvers/time_step_solver_default.hh
index e77633ca1..239c17c5e 100644
--- a/src/model/time_step_solvers/time_step_solver_default.hh
+++ b/src/model/time_step_solvers/time_step_solver_default.hh
@@ -1,111 +1,111 @@
 /**
  * @file   time_step_solver_default.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Mon Aug 24 17:10:29 2015
  *
  * @brief  Default implementation for the time stepper
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "integration_scheme.hh"
 #include "time_step_solver.hh"
 /* -------------------------------------------------------------------------- */
 #include <map>
 #include <set>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_TIME_STEP_SOLVER_DEFAULT_HH__
 #define __AKANTU_TIME_STEP_SOLVER_DEFAULT_HH__
 
 namespace akantu {
 class DOFManagerDefault;
 }
 
 namespace akantu {
 
 class TimeStepSolverDefault : public TimeStepSolver {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   TimeStepSolverDefault(DOFManagerDefault & dof_manager,
                         const TimeStepSolverType & type,
                         NonLinearSolver & non_linear_solver, const ID & id,
                         UInt memory_id);
 
   ~TimeStepSolverDefault() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// registers an integration scheme for a given dof
   void setIntegrationScheme(const ID & dof_id,
                             const IntegrationSchemeType & type,
                             IntegrationScheme::SolutionType solution_type =
                                 IntegrationScheme::_not_defined) override;
   bool hasIntegrationScheme(const ID & dof_id) const override;
 
   /// implementation of the TimeStepSolver::predictor()
   void predictor() override;
   /// implementation of the TimeStepSolver::corrector()
   void corrector() override;
   /// implementation of the TimeStepSolver::assembleMatrix()
   void assembleMatrix(const ID & matrix_id) override;
   /// implementation of the TimeStepSolver::assembleResidual()
   void assembleResidual() override;
 
   /// implementation of the generic TimeStepSolver::solveStep()
   void solveStep(SolverCallback & solver_callback) override;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   typedef std::map<ID, std::unique_ptr<IntegrationScheme>>
       DOFsIntegrationSchemes;
   typedef std::map<ID, IntegrationScheme::SolutionType>
       DOFsIntegrationSchemesSolutionTypes;
-  typedef std::set<ID> DOFsIntegrationSchemesOwner;
+  using DOFsIntegrationSchemesOwner = std::set<ID>;
 
   /// DOFManager with its real type
   DOFManagerDefault & dof_manager;
 
   /// Underlying integration scheme per dof, \todo check what happens in dynamic
   /// in case of coupled equations
   DOFsIntegrationSchemes integration_schemes;
 
   /// defines if the solver is owner of the memory or not
   DOFsIntegrationSchemesOwner integration_schemes_owner;
 
   /// Type of corrector to use
   DOFsIntegrationSchemesSolutionTypes solution_types;
 
   /// define if the mass matrix is lumped or not
   bool is_mass_lumped;
 };
 
 } // namespace akantu
 
 #endif /* __AKANTU_TIME_STEP_SOLVER_DEFAULT_HH__ */
diff --git a/src/python/python_functor_inline_impl.cc b/src/python/python_functor_inline_impl.cc
index ad679181d..0f982d9b6 100644
--- a/src/python/python_functor_inline_impl.cc
+++ b/src/python/python_functor_inline_impl.cc
@@ -1,319 +1,319 @@
 /**
  * @file   python_functor_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *
  * @date creation: Fri Nov 13 2015
  * @date last modification: Wed Nov 18 2015
  *
  * @brief  Python functor interface
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "integration_point.hh"
 /* -------------------------------------------------------------------------- */
 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
 #include <numpy/arrayobject.h>
 #include <typeinfo>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_PYTHON_FUNCTOR_INLINE_IMPL_CC__
 #define __AKANTU_PYTHON_FUNCTOR_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename T> inline int PythonFunctor::getPythonDataTypeCode() const {
   AKANTU_EXCEPTION("undefined type: " << debug::demangle(typeid(T).name()));
 }
 
 /* -------------------------------------------------------------------------- */
 template <> inline int PythonFunctor::getPythonDataTypeCode<bool>() const {
   int data_typecode = NPY_NOTYPE;
   size_t s = sizeof(bool);
   switch (s) {
   case 1:
     data_typecode = NPY_BOOL;
     break;
   case 2:
     data_typecode = NPY_UINT16;
     break;
   case 4:
     data_typecode = NPY_UINT32;
     break;
   case 8:
     data_typecode = NPY_UINT64;
     break;
   }
   return data_typecode;
 }
 
 /* -------------------------------------------------------------------------- */
 template <> inline int PythonFunctor::getPythonDataTypeCode<double>() const {
   return NPY_DOUBLE;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 PyObject * PythonFunctor::convertToPython(const T &) const {
   AKANTU_DEBUG_ERROR(
       __func__ << " : not implemented yet !" << std::endl
       << debug::demangle(typeid(T).name()));
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<double>(const double & akantu_object) const {
   return PyFloat_FromDouble(akantu_object);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<UInt>(const UInt & akantu_object) const {
   return PyInt_FromLong(akantu_object);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<bool>(const bool & akantu_object) const {
   return PyBool_FromLong(long(akantu_object));
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline PyObject *
 PythonFunctor::convertToPython(const std::vector<T> & array) const {
   int data_typecode = getPythonDataTypeCode<T>();
   npy_intp dims[1] = {int(array.size())};
   PyObject * obj = PyArray_SimpleNewFromData(1, dims, data_typecode,
                                              const_cast<T *>(&array[0]));
-  PyArrayObject * res = (PyArrayObject *)obj;
+  auto * res = (PyArrayObject *)obj;
   return (PyObject *)res;
 }
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline PyObject *
 PythonFunctor::convertToPython(const std::vector<Array<T> *> & array) const {
 
   PyObject * res = PyDict_New();
 
   for (auto a : array) {
     PyObject * obj = this->convertToPython(*a);
     PyObject * name = this->convertToPython(a->getID());
     PyDict_SetItem(res, name, obj);
   }
   return (PyObject *)res;
 }
 /* -------------------------------------------------------------------------- */
 
 template <typename T1, typename T2>
 inline PyObject *
 PythonFunctor::convertToPython(const std::map<T1, T2> & map) const {
 
   PyObject * res = PyDict_New();
 
   for (auto a : map) {
     PyObject * key = this->convertToPython(a.first);
     PyObject * value = this->convertToPython(a.second);
     PyDict_SetItem(res, key, value);
   }
   return (PyObject *)res;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 PyObject * PythonFunctor::convertToPython(const Vector<T> & array) const {
   int data_typecode = getPythonDataTypeCode<T>();
   npy_intp dims[1] = {array.size()};
   PyObject * obj =
       PyArray_SimpleNewFromData(1, dims, data_typecode, array.storage());
-  PyArrayObject * res = (PyArrayObject *)obj;
+  auto * res = (PyArrayObject *)obj;
   return (PyObject *)res;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 PyObject * PythonFunctor::convertToPython(const Array<T> & array) const {
   int data_typecode = getPythonDataTypeCode<T>();
   npy_intp dims[2] = {array.size(), array.getNbComponent()};
   PyObject * obj =
       PyArray_SimpleNewFromData(2, dims, data_typecode, array.storage());
-  PyArrayObject * res = (PyArrayObject *)obj;
+  auto * res = (PyArrayObject *)obj;
   return (PyObject *)res;
 }
 /* -------------------------------------------------------------------------- */
 template <typename T>
 PyObject * PythonFunctor::convertToPython(Array<T> * array) const {
   return this->convertToPython(*array);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 PyObject * PythonFunctor::convertToPython(const Matrix<T> & mat) const {
   int data_typecode = getPythonDataTypeCode<T>();
   npy_intp dims[2] = {mat.size(0), mat.size(1)};
   PyObject * obj =
       PyArray_SimpleNewFromData(2, dims, data_typecode, mat.storage());
-  PyArrayObject * res = (PyArrayObject *)obj;
+  auto * res = (PyArrayObject *)obj;
   return (PyObject *)res;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<std::string>(const std::string & str) const {
   return PyString_FromString(str.c_str());
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline PyObject * PythonFunctor::convertToPython<IntegrationPoint>(
     const IntegrationPoint & qp) const {
 
   PyObject * input = PyDict_New();
   PyObject * num_point = this->convertToPython(qp.num_point);
   PyObject * global_num = this->convertToPython(qp.global_num);
   PyObject * material_id = this->convertToPython(qp.material_id);
   PyObject * position = this->convertToPython(qp.getPosition());
   PyDict_SetItemString(input, "num_point", num_point);
   PyDict_SetItemString(input, "global_num", global_num);
   PyDict_SetItemString(input, "material_id", material_id);
   PyDict_SetItemString(input, "position", position);
   return input;
 }
 
 /* -------------------------------------------------------------------------- */
 inline PyObject *
 PythonFunctor::getPythonFunction(const std::string & functor_name) const {
   if (!PyInstance_Check(this->python_obj))
     AKANTU_EXCEPTION("Python object is not an instance");
 
   PyObject * pFunctor =
       PyObject_GetAttrString(this->python_obj, functor_name.c_str());
   if (!pFunctor)
     AKANTU_EXCEPTION("Python dictionary has no " << functor_name << " entry");
 
   return pFunctor;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void
 PythonFunctor::packArguments(__attribute__((unused))
                              std::vector<PyObject *> & p_args) const {}
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename... Args>
 inline void PythonFunctor::packArguments(std::vector<PyObject *> & p_args,
                                          T & p, Args &... params) const {
   p_args.push_back(this->convertToPython(p));
   if (sizeof...(params) != 0)
     this->packArguments(p_args, params...);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename return_type, typename... Params>
 return_type PythonFunctor::callFunctor(const std::string & functor_name,
                                        Params &... parameters) const {
   _import_array();
 
   std::vector<PyObject *> arg_vector;
   this->packArguments(arg_vector, parameters...);
 
   PyObject * pArgs = PyTuple_New(arg_vector.size());
   for (UInt i = 0; i < arg_vector.size(); ++i) {
     PyTuple_SetItem(pArgs, i, arg_vector[i]);
   }
 
   PyObject * kwargs = PyDict_New();
 
   PyObject * pFunctor = getPythonFunction(functor_name);
   PyObject * res = this->callFunctor(pFunctor, pArgs, kwargs);
 
   Py_XDECREF(pArgs);
   Py_XDECREF(kwargs);
 
   return this->convertToAkantu<return_type>(res);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename return_type>
 inline return_type PythonFunctor::convertToAkantu(PyObject * python_obj) const {
 
   if (PyList_Check(python_obj)) {
     return this->convertListToAkantu<typename return_type::value_type>(
         python_obj);
   }
   AKANTU_DEBUG_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void PythonFunctor::convertToAkantu<void>(PyObject * python_obj) const {
   if (python_obj != Py_None)
     AKANTU_DEBUG_WARNING(
         "functor return a value while none was expected: ignored");
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline std::string
 PythonFunctor::convertToAkantu<std::string>(PyObject * python_obj) const {
   if (!PyString_Check(python_obj))
     AKANTU_EXCEPTION("cannot convert object to string");
   return PyString_AsString(python_obj);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline Real PythonFunctor::convertToAkantu<Real>(PyObject * python_obj) const {
   if (!PyFloat_Check(python_obj))
     AKANTU_EXCEPTION("cannot convert object to float");
   return PyFloat_AsDouble(python_obj);
 }
 /* -------------------------------------------------------------------------- */
 template <>
 inline UInt PythonFunctor::convertToAkantu<UInt>(PyObject * python_obj) const {
   if (!PyInt_Check(python_obj))
     AKANTU_EXCEPTION("cannot convert object to integer");
   return PyInt_AsLong(python_obj);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline std::vector<T>
 PythonFunctor::convertListToAkantu(PyObject * python_obj) const {
   std::vector<T> res;
   UInt size = PyList_Size(python_obj);
   for (UInt i = 0; i < size; ++i) {
     PyObject * item = PyList_GET_ITEM(python_obj, i);
     res.push_back(this->convertToAkantu<T>(item));
   }
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
 
 #endif /* __AKANTU_PYTHON_FUNCTOR_INLINE_IMPL_CC__ */
diff --git a/src/solver/sparse_matrix.cc b/src/solver/sparse_matrix.cc
index 161262b8e..08adfa791 100644
--- a/src/solver/sparse_matrix.cc
+++ b/src/solver/sparse_matrix.cc
@@ -1,80 +1,80 @@
 /**
  * @file   sparse_matrix.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Dec 13 2010
  * @date last modification: Mon Nov 16 2015
  *
  * @brief  implementation of the SparseMatrix class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 #include "dof_manager.hh"
 #include "sparse_matrix.hh"
 #include "communicator.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix::SparseMatrix(DOFManager & dof_manager,
                            const MatrixType & matrix_type, const ID & id)
     : id(id), _dof_manager(dof_manager), matrix_type(matrix_type),
       size_(dof_manager.getSystemSize()), nb_non_zero(0) {
   AKANTU_DEBUG_IN();
 
   const auto & comm = _dof_manager.getCommunicator();
   this->nb_proc = comm.getNbProc();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix::SparseMatrix(const SparseMatrix & matrix, const ID & id)
     : SparseMatrix(matrix._dof_manager, matrix.matrix_type, id) {
   nb_non_zero = matrix.nb_non_zero;
 }
 
 /* -------------------------------------------------------------------------- */
-SparseMatrix::~SparseMatrix() {}
+SparseMatrix::~SparseMatrix() = default;
 
 /* -------------------------------------------------------------------------- */
 Array<Real> & operator*=(Array<Real> & vect, const SparseMatrix & mat) {
   Array<Real> tmp(vect.size(), vect.getNbComponent(), 0.);
   mat.matVecMul(vect, tmp);
 
   vect.copy(tmp);
   return vect;
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrix::add(const SparseMatrix & B, Real alpha) {
   B.addMeTo(*this, alpha);
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/solver/sparse_matrix_aij.cc b/src/solver/sparse_matrix_aij.cc
index 180d878f8..976f483a3 100644
--- a/src/solver/sparse_matrix_aij.cc
+++ b/src/solver/sparse_matrix_aij.cc
@@ -1,221 +1,221 @@
 /**
  * @file   sparse_matrix_aij.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Tue Aug 18 16:31:23 2015
  *
  * @brief  Implementation of the AIJ sparse matrix
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "sparse_matrix_aij.hh"
 #include "dof_manager_default.hh"
 #include "dof_synchronizer.hh"
 #include "terms_to_assemble.hh"
 #include "aka_iterators.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 SparseMatrixAIJ::SparseMatrixAIJ(DOFManagerDefault & dof_manager,
                                  const MatrixType & matrix_type, const ID & id)
     : SparseMatrix(dof_manager, matrix_type, id), dof_manager(dof_manager),
       irn(0, 1, id + ":irn"), jcn(0, 1, id + ":jcn"), a(0, 1, id + ":a") {}
 
 /* -------------------------------------------------------------------------- */
 SparseMatrixAIJ::SparseMatrixAIJ(const SparseMatrixAIJ & matrix, const ID & id)
     : SparseMatrix(matrix, id), dof_manager(matrix.dof_manager),
       irn(matrix.irn, true, id + ":irn"), jcn(matrix.jcn, true, id + ":jcn"),
       a(matrix.a, true, id + ":a") {}
 
 /* -------------------------------------------------------------------------- */
-SparseMatrixAIJ::~SparseMatrixAIJ() {}
+SparseMatrixAIJ::~SparseMatrixAIJ() = default;
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::applyBoundary(Real block_val) {
   AKANTU_DEBUG_IN();
 
   // clang-format off
   const auto & blocked_dofs = this->dof_manager.getGlobalBlockedDOFs();
 
   for (auto && ij_a : zip(irn, jcn, a)) {
     UInt ni = this->dof_manager.globalToLocalEquationNumber(std::get<0>(ij_a) - 1);
     UInt nj = this->dof_manager.globalToLocalEquationNumber(std::get<1>(ij_a) - 1);
     if (blocked_dofs(ni) || blocked_dofs(nj)) {
       std::get<2>(ij_a) =
           std::get<0>(ij_a) != std::get<1>(ij_a)   ? 0.
         : this->dof_manager.isLocalOrMasterDOF(ni) ? block_val
         :                                            0.;
     }
   }
 
   this->value_release++;
   // clang-format on
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::saveProfile(const std::string & filename) const {
   AKANTU_DEBUG_IN();
 
   std::ofstream outfile;
   outfile.open(filename.c_str());
 
   UInt m = this->size_;
   outfile << "%%MatrixMarket matrix coordinate pattern";
   if (this->matrix_type == _symmetric)
     outfile << " symmetric";
   else
     outfile << " general";
   outfile << std::endl;
   outfile << m << " " << m << " " << this->nb_non_zero << std::endl;
 
   for (UInt i = 0; i < this->nb_non_zero; ++i) {
     outfile << this->irn.storage()[i] << " " << this->jcn.storage()[i] << " 1"
             << std::endl;
   }
 
   outfile.close();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::saveMatrix(const std::string & filename) const {
   AKANTU_DEBUG_IN();
 
   // open and set the properties of the stream
   std::ofstream outfile;
   outfile.open(filename.c_str());
   outfile.precision(std::numeric_limits<Real>::digits10);
 
   // write header
   outfile << "%%MatrixMarket matrix coordinate real";
   if (this->matrix_type == _symmetric)
     outfile << " symmetric";
   else
     outfile << " general";
   outfile << std::endl;
   outfile << this->size_ << " " << this->size_ << " " << this->nb_non_zero
           << std::endl;
 
   // write content
   for (UInt i = 0; i < this->nb_non_zero; ++i) {
     outfile << this->irn(i) << " " << this->jcn(i) << " " << this->a(i)
             << std::endl;
   }
 
   // time to end
   outfile.close();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::matVecMul(const Array<Real> & x, Array<Real> & y,
                                 Real alpha, Real beta) const {
   AKANTU_DEBUG_IN();
 
   y *= beta;
 
   auto i_it = this->irn.begin();
   auto j_it = this->jcn.begin();
   auto a_it = this->a.begin();
   auto a_end = this->a.end();
   auto x_it = x.begin_reinterpret(x.size() * x.getNbComponent());
   auto y_it = y.begin_reinterpret(x.size() * x.getNbComponent());
 
   for (; a_it != a_end; ++i_it, ++j_it, ++a_it) {
     Int i = this->dof_manager.globalToLocalEquationNumber(*i_it - 1);
     Int j = this->dof_manager.globalToLocalEquationNumber(*j_it - 1);
     const Real & A = *a_it;
 
     y_it[i] += alpha * A * x_it[j];
 
     if ((this->matrix_type == _symmetric) && (i != j))
       y_it[j] += alpha * A * x_it[i];
   }
 
   if (this->dof_manager.hasSynchronizer())
     this->dof_manager.getSynchronizer().reduceSynchronize<AddOperation>(y);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::copyContent(const SparseMatrix & matrix) {
   AKANTU_DEBUG_IN();
-  const SparseMatrixAIJ & mat = dynamic_cast<const SparseMatrixAIJ &>(matrix);
+  const auto & mat = dynamic_cast<const SparseMatrixAIJ &>(matrix);
   AKANTU_DEBUG_ASSERT(nb_non_zero == mat.getNbNonZero(),
                       "The to matrix don't have the same profiles");
   memcpy(a.storage(), mat.getA().storage(), nb_non_zero * sizeof(Real));
 
   this->value_release++;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class MatrixType>
 void SparseMatrixAIJ::addMeToTemplated(MatrixType & B, Real alpha) const {
   auto i_it = this->irn.begin();
   auto j_it = this->jcn.begin();
   auto a_it = this->a.begin();
   auto a_end = this->a.end();
 
   for (; a_it != a_end; ++a_it, ++i_it, ++j_it) {
     const auto & i = *i_it;
     const auto & j = *j_it;
     const auto & A_ij = *a_it;
 
     B.add(i - 1, j - 1, alpha * A_ij);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::addMeTo(SparseMatrix & B, Real alpha) const {
-  if (SparseMatrixAIJ * B_aij = dynamic_cast<SparseMatrixAIJ *>(&B)) {
+  if (auto * B_aij = dynamic_cast<SparseMatrixAIJ *>(&B)) {
     this->addMeToTemplated<SparseMatrixAIJ>(*B_aij, alpha);
   } else {
     //    this->addMeToTemplated<SparseMatrix>(*this, alpha);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::mul(Real alpha) {
   this->a *= alpha;
   this->value_release++;
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::clear() {
   a.set(0.);
 
   this->value_release++;
 }
 
 } // namespace akantu
diff --git a/src/solver/sparse_matrix_aij_inline_impl.cc b/src/solver/sparse_matrix_aij_inline_impl.cc
index 83f69487b..2c6ee5081 100644
--- a/src/solver/sparse_matrix_aij_inline_impl.cc
+++ b/src/solver/sparse_matrix_aij_inline_impl.cc
@@ -1,117 +1,116 @@
 /**
  * @file   sparse_matrix_aij_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Tue Aug 18 00:42:45 2015
  *
  * @brief  Implementation of inline functions of SparseMatrixAIJ
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "sparse_matrix_aij.hh"
 
 /* -------------------------------------------------------------------------- */
 #ifndef __AKANTU_SPARSE_MATRIX_AIJ_INLINE_IMPL_CC__
 #define __AKANTU_SPARSE_MATRIX_AIJ_INLINE_IMPL_CC__
 
 namespace akantu {
 
 inline UInt SparseMatrixAIJ::add(UInt i, UInt j) {
   KeyCOO jcn_irn = this->key(i, j);
 
-  coordinate_list_map::iterator it = this->irn_jcn_k.find(jcn_irn);
+  auto it = this->irn_jcn_k.find(jcn_irn);
 
   if (!(it == this->irn_jcn_k.end()))
     return it->second;
 
   if (i + 1 > this->size_)
     this->size_ = i + 1;
   if (j + 1 > this->size_)
     this->size_ = j + 1;
 
   this->irn.push_back(i + 1);
   this->jcn.push_back(j + 1);
   this->a.push_back(0.);
 
   this->irn_jcn_k[jcn_irn] = this->nb_non_zero;
 
   (this->nb_non_zero)++;
 
   this->profile_release++;
   this->value_release++;
 
   return (this->nb_non_zero - 1);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void SparseMatrixAIJ::clearProfile() {
   SparseMatrix::clearProfile();
 
   this->irn_jcn_k.clear();
 
   this->irn.resize(0);
   this->jcn.resize(0);
   this->a.resize(0);
 
   this->size_ = 0;
 
   this->profile_release++;
   this->value_release++;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void SparseMatrixAIJ::add(UInt i, UInt j, Real value) {
   UInt idx = this->add(i, j);
 
   this->a(idx) += value;
 
   this->value_release++;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real SparseMatrixAIJ::operator()(UInt i, UInt j) const {
   KeyCOO jcn_irn = this->key(i, j);
-  coordinate_list_map::const_iterator irn_jcn_k_it =
-      this->irn_jcn_k.find(jcn_irn);
+  auto irn_jcn_k_it = this->irn_jcn_k.find(jcn_irn);
 
   if (irn_jcn_k_it == this->irn_jcn_k.end())
     return 0.;
   return this->a(irn_jcn_k_it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real & SparseMatrixAIJ::operator()(UInt i, UInt j) {
   KeyCOO jcn_irn = this->key(i, j);
-  coordinate_list_map::iterator irn_jcn_k_it = this->irn_jcn_k.find(jcn_irn);
+  auto irn_jcn_k_it = this->irn_jcn_k.find(jcn_irn);
   AKANTU_DEBUG_ASSERT(irn_jcn_k_it != this->irn_jcn_k.end(),
                       "Couple (i,j) = (" << i << "," << j
                                          << ") does not exist in the profile");
 
   // it may change the profile so it is considered as a change
   this->value_release++;
 
   return this->a(irn_jcn_k_it->second);
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_SPARSE_MATRIX_AIJ_INLINE_IMPL_CC__ */
diff --git a/src/solver/sparse_solver_mumps.cc b/src/solver/sparse_solver_mumps.cc
index 5f5313299..b84b588af 100644
--- a/src/solver/sparse_solver_mumps.cc
+++ b/src/solver/sparse_solver_mumps.cc
@@ -1,441 +1,440 @@
 /**
  * @file   sparse_solver_mumps.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Dec 13 2010
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  implem of SparseSolverMumps class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  * @section DESCRIPTION
  *
  * @subsection Ctrl_param Control parameters
  *
  * ICNTL(1),
  * ICNTL(2),
  * ICNTL(3) : output streams for error, diagnostics, and global messages
  *
  * ICNTL(4) : verbose level : 0 no message - 4 all messages
  *
  * ICNTL(5) : type of matrix, 0 assembled, 1 elementary
  *
  * ICNTL(6) : control  the permutation and scaling(default 7)  see mumps doc for
  * more information
  *
  * ICNTL(7) : determine  the pivot  order (default  7) see  mumps doc  for more
  * information
  *
  * ICNTL(8) : describe the scaling method used
  *
  * ICNTL(9) : 1 solve A x = b, 0 solve At x = b
  *
  * ICNTL(10) : number of iterative refinement when NRHS = 1
  *
  * ICNTL(11) : > 0 return statistics
  *
  * ICNTL(12) : only used for SYM = 2, ordering strategy
  *
  * ICNTL(13) :
  *
  * ICNTL(14) : percentage of increase of the estimated working space
  *
  * ICNTL(15-17) : not used
  *
  * ICNTL(18) : only  used if ICNTL(5) = 0, 0 matrix  centralized, 1 structure on
  * host and mumps  give the mapping, 2 structure on  host and distributed matrix
  * for facto, 3 distributed matrix
  *
  * ICNTL(19) : > 0, Shur complement returned
  *
  * ICNTL(20) : 0 rhs dense, 1 rhs sparse
  *
  * ICNTL(21) : 0 solution in rhs, 1 solution distributed in ISOL_loc and SOL_loc
  * allocated by user
  *
  * ICNTL(22) : 0 in-core, 1 out-of-core
  *
  * ICNTL(23) : maximum memory allocatable by mumps pre proc
  *
  * ICNTL(24) : controls the detection of "null pivot rows"
  *
  * ICNTL(25) :
  *
  * ICNTL(26) :
  *
  * ICNTL(27) :
  *
  * ICNTL(28) : 0 automatic choice, 1 sequential analysis, 2 parallel analysis
  *
  * ICNTL(29) : 0 automatic choice, 1 PT-Scotch, 2 ParMetis
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "dof_manager_default.hh"
 #include "dof_synchronizer.hh"
 #include "sparse_matrix_aij.hh"
 
 #if defined(AKANTU_USE_MPI)
 #include "mpi_communicator_data.hh"
 #endif
 
 #include "sparse_solver_mumps.hh"
 
 /* -------------------------------------------------------------------------- */
 // static std::ostream & operator <<(std::ostream & stream, const DMUMPS_STRUC_C
 // & _this) {
 //   stream << "DMUMPS Data [" << std::endl;
 //   stream << " + job          : " << _this.job          << std::endl;
 //   stream << " + par          : " << _this.par          << std::endl;
 //   stream << " + sym          : " << _this.sym          << std::endl;
 //   stream << " + comm_fortran : " << _this.comm_fortran << std::endl;
 //   stream << " + nz           : " << _this.nz           << std::endl;
 //   stream << " + irn          : " << _this.irn          << std::endl;
 //   stream << " + jcn          : " << _this.jcn          << std::endl;
 //   stream << " + nz_loc       : " << _this.nz_loc       << std::endl;
 //   stream << " + irn_loc      : " << _this.irn_loc      << std::endl;
 //   stream << " + jcn_loc      : " << _this.jcn_loc      << std::endl;
 //   stream << "]";
 //   return stream;
 // }
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 SparseSolverMumps::SparseSolverMumps(DOFManagerDefault & dof_manager,
                                      const ID & matrix_id, const ID & id,
                                      const MemoryID & memory_id)
     : SparseSolver(dof_manager, matrix_id, id, memory_id),
       dof_manager(dof_manager),
       master_rhs_solution(0, 1) {
   AKANTU_DEBUG_IN();
 
   this->prank = communicator.whoAmI();
 
 #ifdef AKANTU_USE_MPI
   this->parallel_method = _fully_distributed;
 #else  // AKANTU_USE_MPI
   this->parallel_method = _not_parallel;
 #endif // AKANTU_USE_MPI
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 SparseSolverMumps::~SparseSolverMumps() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::destroyInternalData() {
   if (this->is_initialized) {
     this->mumps_data.job = _smj_destroy; // destroy
     dmumps_c(&this->mumps_data);
     this->is_initialized = false;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::checkInitialized() {
   if (this->is_initialized) return;
 
   this->initialize();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::setOutputLevel() {
   // Output setup
   icntl(1) = 0; // error output
   icntl(2) = 0; // diagnostics output
   icntl(3) = 0; // information
   icntl(4) = 0;
 
 #if !defined(AKANTU_NDEBUG)
   DebugLevel dbg_lvl = debug::debugger.getDebugLevel();
 
   if (AKANTU_DEBUG_TEST(dblDump)) {
     strcpy(this->mumps_data.write_problem, "mumps_matrix.mtx");
   }
 
   // clang-format off
   icntl(1) = (dbg_lvl >= dblWarning) ? 6 : 0;
   icntl(3) = (dbg_lvl >= dblInfo)    ? 6 : 0;
   icntl(2) = (dbg_lvl >= dblTrace)   ? 6 : 0;
 
   icntl(4) =
     dbg_lvl >= dblDump    ? 4 :
     dbg_lvl >= dblTrace   ? 3 :
     dbg_lvl >= dblInfo    ? 2 :
     dbg_lvl >= dblWarning ? 1 :
                             0;
 
   // clang-format on
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::initMumpsData() {
   auto & A = dof_manager.getMatrix(matrix_id);
 
   // Default Scaling
   icntl(8) = 77;
 
   // Assembled matrix
   icntl(5) = 0;
 
   /// Default centralized dense second member
   icntl(20) = 0;
   icntl(21) = 0;
 
   // automatic choice for analysis
   icntl(28) = 0;
 
   UInt size = A.size();
 
   if (prank == 0) {
     this->master_rhs_solution.resize(size);
   }
 
   this->mumps_data.nz_alloc = 0;
   this->mumps_data.n = size;
 
   switch (this->parallel_method) {
   case _fully_distributed:
     icntl(18) = 3; // fully distributed
 
     this->mumps_data.nz_loc = A.getNbNonZero();
     this->mumps_data.irn_loc = A.getIRN().storage();
     this->mumps_data.jcn_loc = A.getJCN().storage();
 
     break;
   case _not_parallel:
   case _master_slave_distributed:
     icntl(18) = 0; // centralized
 
     if (prank == 0) {
       this->mumps_data.nz = A.getNbNonZero();
       this->mumps_data.irn = A.getIRN().storage();
       this->mumps_data.jcn = A.getJCN().storage();
     } else {
       this->mumps_data.nz = 0;
-      this->mumps_data.irn = NULL;
-      this->mumps_data.jcn = NULL;
+      this->mumps_data.irn = nullptr;
+      this->mumps_data.jcn = nullptr;
     }
     break;
   default:
     AKANTU_DEBUG_ERROR("This case should not happen!!");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::initialize() {
   AKANTU_DEBUG_IN();
 
   this->mumps_data.par = 1; // The host is part of computations
 
   switch (this->parallel_method) {
   case _not_parallel:
     break;
   case _master_slave_distributed:
     this->mumps_data.par = 0; // The host is not part of the computations
     /* FALLTHRU */
     /* [[fallthrough]]; un-comment when compiler will get it */
   case _fully_distributed:
 #ifdef AKANTU_USE_MPI
-    const MPICommunicatorData & mpi_data =
-        dynamic_cast<const MPICommunicatorData &>(
-            communicator.getCommunicatorData());
+    const auto & mpi_data = dynamic_cast<const MPICommunicatorData &>(
+        communicator.getCommunicatorData());
     MPI_Comm mpi_comm = mpi_data.getMPICommunicator();
     this->mumps_data.comm_fortran = MPI_Comm_c2f(mpi_comm);
 #else
     AKANTU_DEBUG_ERROR(
         "You cannot use parallel method to solve without activating MPI");
 #endif
     break;
   }
 
   const auto & A = dof_manager.getMatrix(matrix_id);
 
   this->mumps_data.sym = 2 * (A.getMatrixType() == _symmetric);
   this->prank = communicator.whoAmI();
 
   this->setOutputLevel();
 
   this->mumps_data.job = _smj_initialize; // initialize
   dmumps_c(&this->mumps_data);
 
   this->setOutputLevel();
 
   this->is_initialized = true;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::analysis() {
   AKANTU_DEBUG_IN();
 
   initMumpsData();
 
   this->mumps_data.job = _smj_analyze; // analyze
   dmumps_c(&this->mumps_data);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::factorize() {
   AKANTU_DEBUG_IN();
 
   auto & A = dof_manager.getMatrix(matrix_id);
 
   if (parallel_method == _fully_distributed)
     this->mumps_data.a_loc = A.getA().storage();
   else {
     if (prank == 0)
       this->mumps_data.a = A.getA().storage();
   }
 
   this->mumps_data.job = _smj_factorize; // factorize
   dmumps_c(&this->mumps_data);
 
   this->printError();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::solve(Array<Real> & x, const Array<Real> & b) {
   auto & synch = this->dof_manager.getSynchronizer();
 
   if (this->prank == 0) {
     this->master_rhs_solution.resize(this->dof_manager.getSystemSize());
     synch.gather(b, this->master_rhs_solution);
   } else {
     synch.gather(b);
   }
 
   this->solveInternal();
 
   if (this->prank == 0) {
     synch.scatter(x, this->master_rhs_solution);
   } else {
     synch.scatter(x);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::solve() {
   this->master_rhs_solution.copy(this->dof_manager.getGlobalResidual());
 
   this->solveInternal();
 
   this->dof_manager.setGlobalSolution(this->master_rhs_solution);
 
   this->dof_manager.splitSolutionPerDOFs();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::solveInternal() {
   AKANTU_DEBUG_IN();
 
   this->checkInitialized();
 
   const auto & A = dof_manager.getMatrix(matrix_id);
 
   this->setOutputLevel();
 
   if (this->last_profile_release != A.getProfileRelease()) {
     this->analysis();
     this->last_profile_release = A.getProfileRelease();
   }
 
   if (AKANTU_DEBUG_TEST(dblDump)) {
     std::stringstream sstr;
     sstr << prank << ".mtx";
     A.saveMatrix("solver_mumps" + sstr.str());
   }
 
   if (this->last_value_release != A.getValueRelease()) {
     this->factorize();
     this->last_value_release = A.getValueRelease();
   }
 
   if (prank == 0) {
     this->mumps_data.rhs = this->master_rhs_solution.storage();
   }
 
   this->mumps_data.job = _smj_solve; // solve
   dmumps_c(&this->mumps_data);
 
   this->printError();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::printError() {
   Vector<Int> _info_v(2);
   _info_v[0] = info(1);  // to get errors
   _info_v[1] = -info(1); // to get warnings
   dof_manager.getCommunicator().allReduce(_info_v, SynchronizerOperation::_min);
   _info_v[1] = -_info_v[1];
 
   if (_info_v[0] < 0) { // < 0 is an error
     switch (_info_v[0]) {
     case -10:
       AKANTU_DEBUG_ERROR("The matrix is singular");
       break;
     case -9: {
       icntl(14) += 10;
       if (icntl(14) != 90) {
         // std::cout << "Dynamic memory increase of 10%" << std::endl;
         AKANTU_DEBUG_WARNING("MUMPS dynamic memory is insufficient it will be "
                              "increased allowed to use 10% more");
 
         // change releases to force a recompute
         this->last_value_release--;
         this->last_profile_release--;
 
         this->solve();
       } else {
         AKANTU_DEBUG_ERROR("The MUMPS workarray is too small INFO(2)="
                            << info(2) << "No further increase possible");
       }
       break;
     }
     default:
       AKANTU_DEBUG_ERROR("Error in mumps during solve process, check mumps "
                          "user guide INFO(1) = "
                          << _info_v[1]);
     }
   } else if (_info_v[1] > 0) {
     AKANTU_DEBUG_WARNING("Warning in mumps during solve process, check mumps "
                          "user guide INFO(1) = "
                          << _info_v[1]);
   }
 }
 
 } // akantu
diff --git a/src/solver/terms_to_assemble.hh b/src/solver/terms_to_assemble.hh
index 61e968029..375d30fe4 100644
--- a/src/solver/terms_to_assemble.hh
+++ b/src/solver/terms_to_assemble.hh
@@ -1,99 +1,99 @@
 /**
  * @file   terms_to_assemble.hh
  *
  * @author Nicolas Richart
  *
  * @date creation  Tue Dec 20 2016
  *
  * @brief List of terms to assemble to a matrix
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 /* -------------------------------------------------------------------------- */
 #include <vector>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_TERMS_TO_ASSEMBLE_HH__
 #define __AKANTU_TERMS_TO_ASSEMBLE_HH__
 
 namespace akantu {
 
 class TermsToAssemble {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-  TermsToAssemble() {}
-  virtual ~TermsToAssemble() {}
+  TermsToAssemble() = default;
+  virtual ~TermsToAssemble() = default;
 
   class TermToAssemble {
   public:
     TermToAssemble(UInt i, UInt j) : _i(i), _j(j), val(0.) {}
     inline TermToAssemble & operator=(Real val) {
       this->val = val;
       return *this;
     }
     inline TermToAssemble operator+=(Real val) {
       this->val += val;
       return *this;
     }
     inline operator Real() const { return val; }
     inline UInt i() const { return _i; }
     inline UInt j() const { return _j; }
 
   private:
     UInt _i, _j;
     Real val;
   };
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   inline TermToAssemble & operator()(UInt i, UInt j) {
     terms.emplace_back(i, j);
     return terms.back();
   }
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 private:
-  typedef std::vector<TermToAssemble> TermsContainer;
+  using TermsContainer = std::vector<TermToAssemble>;
 
 public:
-  typedef TermsContainer::const_iterator const_terms_iterator;
+  using const_terms_iterator = TermsContainer::const_iterator;
 
   const_terms_iterator begin() const { return terms.begin(); }
   const_terms_iterator end() const { return terms.end(); }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   TermsContainer terms;
 };
 
 } // akantu
 
 #endif /* __AKANTU_TERMS_TO_ASSEMBLE_HH__ */
diff --git a/src/synchronizer/communication_buffer.hh b/src/synchronizer/communication_buffer.hh
index f1e86211d..5cd056d1e 100644
--- a/src/synchronizer/communication_buffer.hh
+++ b/src/synchronizer/communication_buffer.hh
@@ -1,183 +1,183 @@
 /**
  * @file   communication_buffer.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Buffer for packing and unpacking data
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "aka_common.hh"
 #include "element.hh"
 
 #ifndef __AKANTU_COMMUNICATION_BUFFER_HH__
 #define __AKANTU_COMMUNICATION_BUFFER_HH__
 
 namespace akantu {
 
 template <bool is_static = true> class CommunicationBufferTemplated {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   explicit CommunicationBufferTemplated(UInt size) : buffer(size, 1) {
     ptr_pack = buffer.storage();
     ptr_unpack = buffer.storage();
   };
 
   CommunicationBufferTemplated() : CommunicationBufferTemplated(0) {}
 
   CommunicationBufferTemplated(const CommunicationBufferTemplated & other) {
     buffer = other.buffer;
     ptr_pack = buffer.storage();
     ptr_unpack = buffer.storage();
   }
 
   CommunicationBufferTemplated &
   operator=(const CommunicationBufferTemplated & other) {
     if (this != &other) {
       buffer = other.buffer;
       ptr_pack = buffer.storage();
       ptr_unpack = buffer.storage();
     }
     return *this;
   }
 
-  virtual ~CommunicationBufferTemplated(){};
+  virtual ~CommunicationBufferTemplated() = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// reset to "empty"
   inline void reset();
 
   /// resize the internal buffer
   inline void resize(UInt size);
 
   /// clear buffer context
   inline void clear();
 
 private:
   inline void packResize(UInt size);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   inline char * storage() { return buffer.storage(); };
   inline const char * storage() const { return buffer.storage(); };
   /* ------------------------------------------------------------------------ */
   /* Operators                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// printing tool
   template <typename T> inline std::string extractStream(UInt packet_size);
 
   /// packing data
   template <typename T>
   inline CommunicationBufferTemplated & operator<<(const T & to_pack);
 
   template <typename T>
   inline CommunicationBufferTemplated & operator<<(const Vector<T> & to_pack);
 
   template <typename T>
   inline CommunicationBufferTemplated & operator<<(const Matrix<T> & to_pack);
 
   template <typename T>
   inline CommunicationBufferTemplated &
   operator<<(const std::vector<T> & to_pack);
 
   /// unpacking data
   template <typename T>
   inline CommunicationBufferTemplated & operator>>(T & to_unpack);
 
   template <typename T>
   inline CommunicationBufferTemplated & operator>>(Vector<T> & to_unpack);
 
   template <typename T>
   inline CommunicationBufferTemplated & operator>>(Matrix<T> & to_unpack);
 
   template <typename T>
   inline CommunicationBufferTemplated & operator>>(std::vector<T> & to_unpack);
 
   inline CommunicationBufferTemplated & operator<<(const std::string & to_pack);
   inline CommunicationBufferTemplated & operator>>(std::string & to_unpack);
 
 private:
   template <typename T> inline void packIterable(T & to_pack);
   template <typename T> inline void unpackIterable(T & to_pack);
 
   /* ------------------------------------------------------------------------ */
   /* Accessor                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   template <typename T> static inline UInt sizeInBuffer(const T & data);
   template <typename T> static inline UInt sizeInBuffer(const Vector<T> & data);
   template <typename T> static inline UInt sizeInBuffer(const Matrix<T> & data);
   template <typename T>
   static inline UInt sizeInBuffer(const std::vector<T> & data);
   static inline UInt sizeInBuffer(const std::string & data);
 
   /// return the size in bytes of the stored values
   inline UInt getPackedSize() const { return ptr_pack - buffer.storage(); };
   /// return the size in bytes of data left to be unpacked
   inline UInt getLeftToUnpack() const {
     return buffer.size() - (ptr_unpack - buffer.storage());
   };
   /// return the global size allocated
   inline UInt size() const { return buffer.size(); };
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// current position for packing
   char * ptr_pack;
 
   /// current position for unpacking
   char * ptr_unpack;
 
   /// storing buffer
   Array<char> buffer;
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 #if defined(AKANTU_INCLUDE_INLINE_IMPL)
 #include "communication_buffer_inline_impl.cc"
 #endif
 
 using CommunicationBuffer = CommunicationBufferTemplated<true>;
 using DynamicCommunicationBuffer = CommunicationBufferTemplated<false>;
 
 } // namespace akantu
 
 #endif /* __AKANTU_COMMUNICATION_BUFFER_HH__ */
diff --git a/src/synchronizer/communication_buffer_inline_impl.cc b/src/synchronizer/communication_buffer_inline_impl.cc
index 565510cee..9e75736e8 100644
--- a/src/synchronizer/communication_buffer_inline_impl.cc
+++ b/src/synchronizer/communication_buffer_inline_impl.cc
@@ -1,319 +1,319 @@
 /**
  * @file   communication_buffer_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Apr 14 2011
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  CommunicationBuffer inline implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline UInt CommunicationBufferTemplated<is_static>::sizeInBuffer(const T &) {
   return sizeof(T);
 }
 
 template <bool is_static>
 template <typename T>
 inline UInt
 CommunicationBufferTemplated<is_static>::sizeInBuffer(const Vector<T> & data) {
   UInt size = data.size() * sizeof(T);
   return size;
 }
 
 template <bool is_static>
 template <typename T>
 inline UInt
 CommunicationBufferTemplated<is_static>::sizeInBuffer(const Matrix<T> & data) {
   UInt size = data.size() * sizeof(T);
   return size;
 }
 
 template <bool is_static>
 template <typename T>
 inline UInt CommunicationBufferTemplated<is_static>::sizeInBuffer(
     const std::vector<T> & data) {
   UInt size = data.size() * sizeof(T) + sizeof(size_t);
   return size;
 }
 
 template <bool is_static>
 inline UInt CommunicationBufferTemplated<is_static>::sizeInBuffer(
     const std::string & data) {
   UInt size = data.size() * sizeof(std::string::value_type) + sizeof(size_t);
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 inline void CommunicationBufferTemplated<is_static>::packResize(UInt size) {
   if (!is_static) {
     char * values = buffer.storage();
     buffer.resize(buffer.size() + size);
     ptr_pack = buffer.storage() + (ptr_pack - values);
     ptr_unpack = buffer.storage() + (ptr_unpack - values);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator<<(const T & to_pack) {
   UInt size = sizeInBuffer(to_pack);
   packResize(size);
   AKANTU_DEBUG_ASSERT(
       (buffer.storage() + buffer.size()) >= (ptr_pack + size),
       "Packing too much data in the CommunicationBufferTemplated");
   memcpy(ptr_pack, reinterpret_cast<const char *>(&to_pack), size);
   ptr_pack += size;
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator>>(T & to_unpack) {
   UInt size = sizeInBuffer(to_unpack);
 
   alignas(alignof(T)) std::array<char, sizeof(T)> aligned_ptr;
   memcpy(aligned_ptr.data(), ptr_unpack, size);
 
-  T * tmp = reinterpret_cast<T *>(aligned_ptr.data());
+  auto * tmp = reinterpret_cast<T *>(aligned_ptr.data());
   AKANTU_DEBUG_ASSERT(
       (buffer.storage() + buffer.size()) >= (ptr_unpack + size),
       "Unpacking too much data in the CommunicationBufferTemplated");
   to_unpack = *tmp;
   // memcpy(reinterpret_cast<char *>(&to_unpack), ptr_unpack, size);
   ptr_unpack += size;
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 /* Specialization                                                             */
 /* -------------------------------------------------------------------------- */
 
 /**
  * Vector
  */
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator<<(const Vector<T> & to_pack) {
   UInt size = sizeInBuffer(to_pack);
   packResize(size);
   AKANTU_DEBUG_ASSERT(
       (buffer.storage() + buffer.size()) >= (ptr_pack + size),
       "Packing too much data in the CommunicationBufferTemplated");
   memcpy(ptr_pack, to_pack.storage(), size);
   ptr_pack += size;
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator>>(Vector<T> & to_unpack) {
   UInt size = sizeInBuffer(to_unpack);
   AKANTU_DEBUG_ASSERT(
       (buffer.storage() + buffer.size()) >= (ptr_unpack + size),
       "Unpacking too much data in the CommunicationBufferTemplated");
   memcpy(to_unpack.storage(), ptr_unpack, size);
   ptr_unpack += size;
   return *this;
 }
 
 /**
  * Matrix
  */
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator<<(const Matrix<T> & to_pack) {
   UInt size = sizeInBuffer(to_pack);
   packResize(size);
   AKANTU_DEBUG_ASSERT(
       (buffer.storage() + buffer.size()) >= (ptr_pack + size),
       "Packing too much data in the CommunicationBufferTemplated");
   memcpy(ptr_pack, to_pack.storage(), size);
   ptr_pack += size;
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator>>(Matrix<T> & to_unpack) {
   UInt size = sizeInBuffer(to_unpack);
   AKANTU_DEBUG_ASSERT(
       (buffer.storage() + buffer.size()) >= (ptr_unpack + size),
       "Unpacking too much data in the CommunicationBufferTemplated");
   memcpy(to_unpack.storage(), ptr_unpack, size);
   ptr_unpack += size;
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline void CommunicationBufferTemplated<is_static>::packIterable(T & to_pack) {
   operator<<(size_t(to_pack.size()));
-  typename T::const_iterator it = to_pack.begin();
-  typename T::const_iterator end = to_pack.end();
+  auto it = to_pack.begin();
+  auto end = to_pack.end();
   for (; it != end; ++it)
     operator<<(*it);
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline void
 CommunicationBufferTemplated<is_static>::unpackIterable(T & to_unpack) {
   size_t size;
   operator>>(size);
   to_unpack.resize(size);
-  typename T::iterator it = to_unpack.begin();
-  typename T::iterator end = to_unpack.end();
+  auto it = to_unpack.begin();
+  auto end = to_unpack.end();
   for (; it != end; ++it)
     operator>>(*it);
 }
 
 /**
  * std::vector<T>
  */
 /* -------------------------------------------------------------------------- */
 
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::
 operator<<(const std::vector<T> & to_pack) {
   packIterable(to_pack);
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::
 operator>>(std::vector<T> & to_unpack) {
   unpackIterable(to_unpack);
   return *this;
 }
 
 /**
  * std::string
  */
 /* -------------------------------------------------------------------------- */
 
 template <bool is_static>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::
 operator<<(const std::string & to_pack) {
   packIterable(to_pack);
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator>>(std::string & to_unpack) {
   unpackIterable(to_unpack);
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline std::string
 CommunicationBufferTemplated<is_static>::extractStream(UInt block_size) {
   std::stringstream str;
-  T * ptr = reinterpret_cast<T *>(buffer.storage());
+  auto * ptr = reinterpret_cast<T *>(buffer.storage());
   UInt sz = buffer.size() / sizeof(T);
   UInt sz_block = block_size / sizeof(T);
 
   UInt n_block = 0;
   for (UInt i = 0; i < sz; ++i) {
     if (i % sz_block == 0) {
       str << std::endl << n_block << " ";
       ++n_block;
     }
     str << *ptr << " ";
     ++ptr;
   }
   return str.str();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 inline void CommunicationBufferTemplated<is_static>::resize(UInt size) {
   if (!is_static) {
     buffer.resize(0);
   } else {
     buffer.resize(size);
   }
   reset();
 #ifndef AKANTU_NDEBUG
   clear();
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 inline void CommunicationBufferTemplated<is_static>::clear() {
   buffer.clear();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 inline void CommunicationBufferTemplated<is_static>::reset() {
   ptr_pack = buffer.storage();
   ptr_unpack = buffer.storage();
 }
 
 /* -------------------------------------------------------------------------- */
 // template<bool is_static>
 // inline CommunicationBufferTemplated<is_static> &
 // CommunicationBufferTemplated<is_static>::packMeshData (const MeshData &
 // to_pack, const ElementType & type) {
 
 // UInt size = to_pack.size();
 // operator<<(size);
 // typename std::vector<T>::iterator it  = to_pack.begin();
 // typename std::vector<T>::iterator end = to_pack.end();
 // for(;it != end; ++it) operator<<(*it);
 // return *this;
 
 //}
diff --git a/src/synchronizer/communication_descriptor.hh b/src/synchronizer/communication_descriptor.hh
index 5856cd7a1..e3f24ad99 100644
--- a/src/synchronizer/communication_descriptor.hh
+++ b/src/synchronizer/communication_descriptor.hh
@@ -1,153 +1,153 @@
 /**
  * @file   synchronizer_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Aug  3 13:49:36 2016
  *
  * @brief  Implementation of the helper classes for the synchronizer
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "communication_tag.hh"
 #include "data_accessor.hh"
 #include "communication_request.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_COMMUNICATION_DESCRIPTOR_HH__
 #define __AKANTU_COMMUNICATION_DESCRIPTOR_HH__
 
 namespace akantu {
 
 /* ------------------------------------------------------------------------ */
 enum CommunicationSendRecv  { _send, _recv, _csr_not_defined };
 
 /* -------------------------------------------------------------------------- */
 struct CommunicationSRType {
-  typedef CommunicationSendRecv type;
+  using type = CommunicationSendRecv;
   static const type _begin_ = _send;
   static const type _end_ = _csr_not_defined;
 };
 
-typedef safe_enum<CommunicationSRType> send_recv_t;
+using send_recv_t = safe_enum<CommunicationSRType>;
 
 namespace {
   send_recv_t iterate_send_recv{};
 }
 
 /* ------------------------------------------------------------------------ */
 class Communication {
 public:
   explicit Communication(const CommunicationSendRecv & type = _csr_not_defined)
-      : _size(0), _type(type) {}
+      : _type(type) {}
 
   Communication(const Communication &) = delete;
   Communication & operator=(const Communication &) = delete;
 
   void resize(UInt size) {
     this->_size = size;
     this->_buffer.resize(size);
   }
 
   inline const CommunicationSendRecv & type() const { return this->_type; }
   inline const UInt & size() const { return this->_size; }
 
   inline const CommunicationRequest & request() const { return this->_request; }
   inline CommunicationRequest & request() { return this->_request; }
 
   inline const CommunicationBuffer & buffer() const { return this->_buffer; }
   inline CommunicationBuffer & buffer() { return this->_buffer; }
 
 private:
-  UInt _size;
+  UInt _size{0};
   CommunicationBuffer _buffer;
   CommunicationRequest _request;
   CommunicationSendRecv _type;
 };
 
 template <class Entity> class Communications;
 
 /* ------------------------------------------------------------------------ */
 template <class Entity> class CommunicationDescriptor {
 public:
   CommunicationDescriptor(Communication & communication, Array<Entity> & scheme,
                           Communications<Entity> & communications,
                           const SynchronizationTag & tag, UInt proc);
 
   CommunicationDescriptor(const CommunicationDescriptor &) = default;
 
   CommunicationDescriptor &
   operator=(const CommunicationDescriptor &) = default;
 
   /// get the quantity of data in the buffer
   UInt getNbData() { return communication.size(); }
   /// set the quantity of data in the buffer
   void setNbData(UInt size) { communication.resize(size); }
 
   /// get the corresponding tag
   const SynchronizationTag & getTag() const { return tag; }
   /// get the data buffer
   CommunicationBuffer & getBuffer();
 
   /// get the corresponding request
   CommunicationRequest & getRequest();
 
   /// get the communication scheme
   Array<Entity> & getScheme();
 
   /// reset the buffer before pack or after unpack
   void resetBuffer();
 
   /// pack data for entities in the buffer
   void packData(const DataAccessor<Entity> & accessor);
 
   /// unpack data for entities from the buffer
   void unpackData(DataAccessor<Entity> & accessor);
 
   /// posts asynchronous send requests
   void postSend(int hash_id);
 
   /// posts asynchronous receive requests
   void postRecv(int hash_id);
 
   /// free the request
   void freeRequest();
 
   UInt getProc() { return proc; }
 
 protected:
   Communication & communication;
   Array<Entity> & scheme;
   Communications<Entity> & communications;
   const SynchronizationTag & tag;
   UInt proc;
   UInt rank;
   UInt counter;
 };
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
 
 #include "communication_descriptor_tmpl.hh"
 
 #endif /* __AKANTU_COMMUNICATION_DESCRIPTOR_HH__ */
diff --git a/src/synchronizer/communication_tag.hh b/src/synchronizer/communication_tag.hh
index c4ffc2b46..f9a16291a 100644
--- a/src/synchronizer/communication_tag.hh
+++ b/src/synchronizer/communication_tag.hh
@@ -1,114 +1,114 @@
 /**
  * @file   communication_tag.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Aug 24 12:40:55 2016
  *
  * @brief  Description of the communication tags
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 #ifndef __AKANTU_COMMUNICATION_TAG_HH__
 #define __AKANTU_COMMUNICATION_TAG_HH__
 
 namespace akantu {
 /**
  * tag = |__________20_________|___8____|_4_|
  *       |          proc       | num mes| ct|
  */
 class Tag {
 public:
-  Tag() : tag(0), hash(0) {}
-  Tag(int val) : tag(val), hash(0) {}
+  Tag() = default;
+  Tag(int val) : tag(val) {}
   Tag(int val, int hash) : tag(val), hash(hash) {}
 
   operator int() const { return int(max_tag == 0 ? tag : (uint32_t(tag) % max_tag)); }
 
   /// generates a tag
   template <typename CommTag>
   static inline Tag genTag(int proc, UInt msg_count, CommTag tag) {
     int _tag = ((((proc & 0xFFFFF) << 12) + ((msg_count & 0xFF) << 4) +
                  ((int)tag & 0xF)));
     Tag t(_tag);
     return t;
   }
 
   /// generates a tag and hashes it
   template <typename CommTag>
   static inline Tag genTag(int proc, UInt msg_count, CommTag tag, int hash) {
     Tag t = genTag(proc, msg_count, tag);
     t.tag = t.tag ^ hash;
     t.hash = hash;
     return t;
   }
 
   virtual void printself(std::ostream & stream, int) const {
     int t = tag;
     stream << "TAG(";
     if (hash != 0)
       t = t ^ hash;
     stream << (t >> 12) << ":" << (t >> 4 & 0xFF) << ":" << (t & 0xF)
            << " -> " << std::hex << "0x"<< int(*this);
     if (hash != 0)
       stream << " {hash: 0x" << hash << "}";
     stream << " [0x" << this->max_tag << "]";
     stream << ")";
   }
 
   enum CommTags : int {
     _SIZES = 1,
     _CONNECTIVITY = 2,
     _DATA = 3,
     _PARTITIONS = 4,
     _NB_NODES = 5,
     _NODES = 6,
     _COORDINATES = 7,
     _NODES_TYPE = 8,
     _MESH_DATA = 9,
     _ELEMENT_GROUP = 10,
     _NODE_GROUP = 11,
     _MODIFY_SCHEME = 12,
     _GATHER_INITIALIZATION = 1,
     _GATHER = 2,
     _SCATTER = 3,
     _SYNCHRONIZE = 15,
   };
 
 private:
   static void setMaxTag(int _max_tag) { max_tag = _max_tag; }
   friend void initialize(const std::string &, int &, char **&);
 
 private:
-  int tag;
-  int hash;
+  int tag{0};
+  int hash{0};
   static int max_tag;
 };
 
 /* -------------------------------------------------------------------------- */
 inline std::ostream & operator<<(std::ostream & stream, const Tag & _this) {
   _this.printself(stream, 0);
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 }
 
 #endif /* __AKANTU_COMMUNICATION_TAG_HH__ */
diff --git a/src/synchronizer/communications_tmpl.hh b/src/synchronizer/communications_tmpl.hh
index badefca03..65bad6a4f 100644
--- a/src/synchronizer/communications_tmpl.hh
+++ b/src/synchronizer/communications_tmpl.hh
@@ -1,560 +1,560 @@
 /**
  * @file   communications_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Tue Sep  6 17:14:06 2016
  *
  * @brief  Implementation of Communications
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "communications.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_COMMUNICATIONS_TMPL_HH__
 #define __AKANTU_COMMUNICATIONS_TMPL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class Entity> class Communications<Entity>::iterator {
   typedef
       typename std::map<UInt, Communication>::iterator communication_iterator;
 
 public:
   iterator() : communications(nullptr) {}
   iterator(scheme_iterator scheme_it, communication_iterator comm_it,
            Communications<Entity> & communications,
            const SynchronizationTag & tag)
       : scheme_it(scheme_it), comm_it(comm_it), communications(&communications),
         tag(tag) {}
 
   iterator & operator=(const iterator & other) {
     if (this != &other) {
       this->scheme_it = other.scheme_it;
       this->comm_it = other.comm_it;
       this->communications = other.communications;
       this->tag = other.tag;
     }
     return *this;
   }
 
   iterator & operator++() {
     ++scheme_it;
     ++comm_it;
     return *this;
   }
 
   CommunicationDescriptor<Entity> operator*() {
     AKANTU_DEBUG_ASSERT(
         scheme_it->first == comm_it->first,
         "The two iterators are not in phase, something wrong"
             << " happened, time to take out your favorite debugger ("
             << scheme_it->first << " != " << comm_it->first << ")");
     return CommunicationDescriptor<Entity>(comm_it->second, scheme_it->second,
                                            *communications, tag,
                                            scheme_it->first);
   }
 
   bool operator==(const iterator & other) const {
     return scheme_it == other.scheme_it && comm_it == other.comm_it;
   }
 
   bool operator!=(const iterator & other) const {
     return scheme_it != other.scheme_it || comm_it != other.comm_it;
   }
 
 private:
   scheme_iterator scheme_it;
   communication_iterator comm_it;
   Communications<Entity> * communications;
   SynchronizationTag tag;
 };
 
 /* -------------------------------------------------------------------------- */
 template <class Entity> class Communications<Entity>::tag_iterator {
   typedef std::map<SynchronizationTag, UInt>::const_iterator internal_iterator;
 
 public:
   tag_iterator(const internal_iterator & it) : it(it) {}
   tag_iterator & operator++() {
     ++it;
     return *this;
   }
   SynchronizationTag operator*() { return it->first; }
   bool operator==(const tag_iterator & other) const { return it == other.it; }
   bool operator!=(const tag_iterator & other) const { return it != other.it; }
 
 private:
   internal_iterator it;
 };
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 typename Communications<Entity>::CommunicationPerProcs &
 Communications<Entity>::getCommunications(const SynchronizationTag & tag,
                                           const CommunicationSendRecv & sr) {
   auto comm_it = this->communications[sr].find(tag);
   if (comm_it == this->communications[sr].end())
     AKANTU_CUSTOM_EXCEPTION_INFO(
         debug::CommunicationException(),
         "No known communications for the tag: " << tag);
   return comm_it->second;
 }
 
 /* ---------------------------------------------------------------------- */
 template <class Entity>
 UInt Communications<Entity>::getPending(
     const SynchronizationTag & tag, const CommunicationSendRecv & sr) const {
   const std::map<SynchronizationTag, UInt> & pending =
       pending_communications[sr];
   auto it = pending.find(tag);
 
   if (it == pending.end())
     return 0;
   return it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 bool Communications<Entity>::hasPending(
     const SynchronizationTag & tag, const CommunicationSendRecv & sr) const {
   return this->hasCommunication(tag) && (this->getPending(tag, sr) != 0);
 }
 
 /* ---------------------------------------------------------------------- */
 template <class Entity>
 typename Communications<Entity>::iterator
 Communications<Entity>::begin(const SynchronizationTag & tag,
                               const CommunicationSendRecv & sr) {
   auto & comms = this->getCommunications(tag, sr);
   return iterator(this->schemes[sr].begin(), comms.begin(), *this, tag);
 }
 
 template <class Entity>
 typename Communications<Entity>::iterator
 Communications<Entity>::end(const SynchronizationTag & tag,
                             const CommunicationSendRecv & sr) {
   auto & comms = this->getCommunications(tag, sr);
   return iterator(this->schemes[sr].end(), comms.end(), *this, tag);
 }
 
 /* ---------------------------------------------------------------------- */
 template <class Entity>
 typename Communications<Entity>::iterator
 Communications<Entity>::waitAny(const SynchronizationTag & tag,
                                 const CommunicationSendRecv & sr) {
   auto & comms = this->getCommunications(tag, sr);
   auto it = comms.begin();
   auto end = comms.end();
 
   std::vector<CommunicationRequest> requests;
 
   for (; it != end; ++it) {
     auto & request = it->second.request();
     if (!request.isFreed())
       requests.push_back(request);
   }
 
   UInt req_id = communicator.waitAny(requests);
   if (req_id != UInt(-1)) {
     auto & request = requests[req_id];
     UInt proc = sr == _recv ? request.getSource() : request.getDestination();
 
     return iterator(this->schemes[sr].find(proc), comms.find(proc), *this, tag);
   } else {
     return this->end(tag, sr);
   }
 }
 
 /* ---------------------------------------------------------------------- */
 template <class Entity>
 void Communications<Entity>::waitAll(const SynchronizationTag & tag,
                                      const CommunicationSendRecv & sr) {
   auto & comms = this->getCommunications(tag, sr);
   auto it = comms.begin();
   auto end = comms.end();
 
   std::vector<CommunicationRequest> requests;
 
   for (; it != end; ++it) {
     requests.push_back(it->second.request());
   }
 
   communicator.waitAll(requests);
 }
 
 template <class Entity>
 void Communications<Entity>::incrementPending(
     const SynchronizationTag & tag, const CommunicationSendRecv & sr) {
   ++(pending_communications[sr][tag]);
 }
 
 template <class Entity>
 void Communications<Entity>::decrementPending(
     const SynchronizationTag & tag, const CommunicationSendRecv & sr) {
   --(pending_communications[sr][tag]);
 }
 
 template <class Entity>
 void Communications<Entity>::freeRequests(const SynchronizationTag & tag,
                                           const CommunicationSendRecv & sr) {
   iterator it = this->begin(tag, sr);
   iterator end = this->end(tag, sr);
 
   for (; it != end; ++it) {
     (*it).freeRequest();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 typename Communications<Entity>::Scheme &
 Communications<Entity>::createScheme(UInt proc,
                                      const CommunicationSendRecv & sr) {
   // scheme_iterator it = schemes[sr].find(proc);
   // if (it != schemes[sr].end()) {
   //   AKANTU_CUSTOM_EXCEPTION_INFO(debug::CommunicationException(),
   //                                "Communication scheme("
   //                                    << sr
   //                                    << ") already created for proc: " <<
   //                                    proc);
   // }
   return schemes[sr][proc];
 }
 
 template <class Entity>
 void Communications<Entity>::resetSchemes(const CommunicationSendRecv & sr) {
-  scheme_iterator it = this->schemes[sr].begin();
-  scheme_iterator end = this->schemes[sr].end();
+  auto it = this->schemes[sr].begin();
+  auto end = this->schemes[sr].end();
   for (; it != end; ++it) {
     it->second.resize(0);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 void Communications<Entity>::setCommunicationSize(
     const SynchronizationTag & tag, UInt proc, UInt size,
     const CommunicationSendRecv & sr) {
   // accessor that fails if it does not exists
   comm_size_computed[tag] = true; // TODO: need perhaps to be split based on sr
   auto & comms = this->communications[sr];
   auto & comms_per_tag = comms.at(tag);
 
   comms_per_tag.at(proc).resize(size);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 void Communications<Entity>::initializeCommunications(
     const SynchronizationTag & tag) {
 
   for (auto t = send_recv_t::begin(); t != send_recv_t::end(); ++t) {
     pending_communications[*t].insert(std::make_pair(tag, 0));
 
     auto & comms = this->communications[*t];
     auto & comms_per_tag =
         comms.insert(std::make_pair(tag, CommunicationPerProcs()))
             .first->second;
 
     for (auto pair : this->schemes[*t]) {
       comms_per_tag.emplace(std::piecewise_construct,
                             std::forward_as_tuple(pair.first),
                             std::forward_as_tuple(*t));
     }
   }
 
   comm_counter.insert(std::make_pair(tag, 0));
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 Communications<Entity>::Communications(const Communicator & communicator)
     : communicator(communicator) {}
 
 /* ---------------------------------------------------------------------- */
 // template <class Entity>
 // typename Communications<Entity>::iterator
 // Communications<Entity>::begin_send(const SynchronizationTag & tag) {
 //   return this->begin(tag, _send);
 // }
 
 // template <class Entity>
 // typename Communications<Entity>::iterator
 // Communications<Entity>::end_send(const SynchronizationTag & tag) {
 //   return this->end(tag, _send);
 // }
 
 // /* ---------------------------------------------------------------------- */
 // template <class Entity>
 // typename Communications<Entity>::iterator
 // Communications<Entity>::begin_recv(const SynchronizationTag & tag) {
 //   return this->begin(tag, _recv);
 // }
 
 // template <class Entity>
 // typename Communications<Entity>::iterator
 // Communications<Entity>::end_recv(const SynchronizationTag & tag) {
 //   return this->end(tag, _recv);
 // }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 typename Communications<Entity>::tag_iterator
 Communications<Entity>::begin_tag() {
   return tag_iterator(comm_counter.begin());
 }
 
 template <class Entity>
 typename Communications<Entity>::tag_iterator
 Communications<Entity>::end_tag() {
   return tag_iterator(comm_counter.end());
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 typename Communications<Entity>::scheme_iterator
 Communications<Entity>::begin_scheme(const CommunicationSendRecv & sr) {
   return this->schemes[sr].begin();
 }
 
 template <class Entity>
 typename Communications<Entity>::scheme_iterator
 Communications<Entity>::end_scheme(const CommunicationSendRecv & sr) {
   return this->schemes[sr].end();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 typename Communications<Entity>::const_scheme_iterator
 Communications<Entity>::begin_scheme(const CommunicationSendRecv & sr) const {
   return this->schemes[sr].begin();
 }
 
 template <class Entity>
 typename Communications<Entity>::const_scheme_iterator
 Communications<Entity>::end_scheme(const CommunicationSendRecv & sr) const {
   return this->schemes[sr].end();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 typename Communications<Entity>::scheme_iterator
 Communications<Entity>::begin_send_scheme() {
   return this->begin_scheme(_send);
 }
 
 template <class Entity>
 typename Communications<Entity>::scheme_iterator
 Communications<Entity>::end_send_scheme() {
   return this->end_scheme(_send);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 typename Communications<Entity>::const_scheme_iterator
 Communications<Entity>::begin_send_scheme() const {
   return this->begin_scheme(_send);
 }
 
 template <class Entity>
 typename Communications<Entity>::const_scheme_iterator
 Communications<Entity>::end_send_scheme() const {
   return this->end_scheme(_send);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 typename Communications<Entity>::scheme_iterator
 Communications<Entity>::begin_recv_scheme() {
   return this->begin_scheme(_recv);
 }
 
 template <class Entity>
 typename Communications<Entity>::scheme_iterator
 Communications<Entity>::end_recv_scheme() {
   return this->end_scheme(_recv);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 typename Communications<Entity>::const_scheme_iterator
 Communications<Entity>::begin_recv_scheme() const {
   return this->begin_scheme(_recv);
 }
 
 template <class Entity>
 typename Communications<Entity>::const_scheme_iterator
 Communications<Entity>::end_recv_scheme() const {
   return this->end_scheme(_recv);
 }
 
 /* ------------------------------------------------------------------------ */
 template <class Entity>
 bool Communications<Entity>::hasCommunication(
     const SynchronizationTag & tag) const {
   return (communications[_send].find(tag) != communications[_send].end());
 }
 
 template <class Entity>
 void Communications<Entity>::incrementCounter(const SynchronizationTag & tag) {
   auto it = comm_counter.find(tag);
   if (it == comm_counter.end()) {
     AKANTU_CUSTOM_EXCEPTION_INFO(
         debug::CommunicationException(),
         "No counter initialized in communications for the tags: " << tag);
   }
 
   ++(it->second);
 }
 
 template <class Entity>
 UInt Communications<Entity>::getCounter(const SynchronizationTag & tag) const {
   auto it = comm_counter.find(tag);
   if (it == comm_counter.end()) {
     AKANTU_CUSTOM_EXCEPTION_INFO(
         debug::CommunicationException(),
         "No counter initialized in communications for the tags: " << tag);
   }
 
   return it->second;
 }
 
 template <class Entity>
 bool Communications<Entity>::hasCommunicationSize(
     const SynchronizationTag & tag) const {
   auto it = comm_size_computed.find(tag);
   if (it == comm_size_computed.end()) {
     return false;
   }
 
   return it->second;
 }
 
 template <class Entity> void Communications<Entity>::invalidateSizes() {
   for (auto && pair : comm_size_computed) {
     pair.second = true;
   }
 }
 
 template <class Entity>
 bool Communications<Entity>::hasPendingRecv(
     const SynchronizationTag & tag) const {
   return this->hasPending(tag, _recv);
 }
 
 template <class Entity>
 bool Communications<Entity>::hasPendingSend(
     const SynchronizationTag & tag) const {
   return this->hasPending(tag, _send);
 }
 
 template <class Entity>
 const auto & Communications<Entity>::getCommunicator() const {
   return communicator;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 typename Communications<Entity>::iterator
 Communications<Entity>::waitAnyRecv(const SynchronizationTag & tag) {
   return this->waitAny(tag, _recv);
 }
 
 template <class Entity>
 typename Communications<Entity>::iterator
 Communications<Entity>::waitAnySend(const SynchronizationTag & tag) {
   return this->waitAny(tag, _send);
 }
 
 template <class Entity>
 void Communications<Entity>::waitAllRecv(const SynchronizationTag & tag) {
   this->waitAll(tag, _recv);
 }
 
 template <class Entity>
 void Communications<Entity>::waitAllSend(const SynchronizationTag & tag) {
   this->waitAll(tag, _send);
 }
 
 template <class Entity>
 void Communications<Entity>::freeSendRequests(const SynchronizationTag & tag) {
   this->freeRequests(tag, _send);
 }
 
 template <class Entity>
 void Communications<Entity>::freeRecvRequests(const SynchronizationTag & tag) {
   this->freeRequests(tag, _recv);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 typename Communications<Entity>::Scheme &
 Communications<Entity>::createSendScheme(UInt proc) {
   return createScheme(proc, _send);
 }
 
 template <class Entity>
 typename Communications<Entity>::Scheme &
 Communications<Entity>::createRecvScheme(UInt proc) {
   return createScheme(proc, _recv);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity> void Communications<Entity>::resetSchemes() {
   resetSchemes(_send);
   resetSchemes(_recv);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 typename Communications<Entity>::Scheme &
 Communications<Entity>::getScheme(UInt proc, const CommunicationSendRecv & sr) {
   return this->schemes[sr].find(proc)->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 const typename Communications<Entity>::Scheme &
 Communications<Entity>::getScheme(UInt proc,
                                   const CommunicationSendRecv & sr) const {
   return this->schemes[sr].find(proc)->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 void Communications<Entity>::setSendCommunicationSize(
     const SynchronizationTag & tag, UInt proc, UInt size) {
   this->setCommunicationSize(tag, proc, size, _send);
 }
 
 template <class Entity>
 void Communications<Entity>::setRecvCommunicationSize(
     const SynchronizationTag & tag, UInt proc, UInt size) {
   this->setCommunicationSize(tag, proc, size, _recv);
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_COMMUNICATIONS_TMPL_HH__ */
diff --git a/src/synchronizer/communicator.cc b/src/synchronizer/communicator.cc
index 3a479e1cb..445d78b79 100644
--- a/src/synchronizer/communicator.cc
+++ b/src/synchronizer/communicator.cc
@@ -1,174 +1,174 @@
 /**
  * @file   static_communicator.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  implementation of the common part of the static communicator
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "communicator.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 UInt InternalCommunicationRequest::counter = 0;
 
 /* -------------------------------------------------------------------------- */
 InternalCommunicationRequest::InternalCommunicationRequest(UInt source,
                                                            UInt dest)
     : source(source), destination(dest) {
   this->id = counter++;
 }
 
 /* -------------------------------------------------------------------------- */
-InternalCommunicationRequest::~InternalCommunicationRequest() {}
+InternalCommunicationRequest::~InternalCommunicationRequest() = default;
 
 /* -------------------------------------------------------------------------- */
 void InternalCommunicationRequest::printself(std::ostream & stream,
                                              int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "CommunicationRequest [" << std::endl;
   stream << space << " + id          : " << id << std::endl;
   stream << space << " + source      : " << source << std::endl;
   stream << space << " + destination : " << destination << std::endl;
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 Communicator::~Communicator() {
-  FinalizeCommunicatorEvent * event = new FinalizeCommunicatorEvent(*this);
+  auto * event = new FinalizeCommunicatorEvent(*this);
   this->sendEvent(*event);
   this->barrier();
   delete event;
 }
 
 /* -------------------------------------------------------------------------- */
 Communicator & Communicator::getStaticCommunicator() {
   AKANTU_DEBUG_IN();
 
   if (!static_communicator) {
     int nb_args = 0;
     char ** null = nullptr;
     static_communicator = std::make_unique<Communicator>(nb_args, null, private_member{});
   }
 
   AKANTU_DEBUG_OUT();
   return *static_communicator;
 }
 
 /* -------------------------------------------------------------------------- */
 Communicator & Communicator::getStaticCommunicator(int & argc, char **& argv) {
   if (!static_communicator)
     static_communicator = std::make_unique<Communicator>(argc, argv, private_member{});
   return getStaticCommunicator();
 }
 
 } // namespace akantu
 
 #ifdef AKANTU_USE_MPI
 #  include "communicator_mpi_inline_impl.cc"
 #else
 #  include "communicator_dummy_inline_impl.cc"
 #endif
 
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 /* Template instantiation                                                     */
 /* -------------------------------------------------------------------------- */
 #define AKANTU_COMM_INSTANTIATE(T)                                             \
   template void Communicator::probe<T>(Int sender, Int tag,                    \
                                        CommunicationStatus & status) const;    \
   template bool Communicator::asyncProbe<T>(                                   \
       Int sender, Int tag, CommunicationStatus & status) const;                \
   template void Communicator::sendImpl<T>(                                     \
       const T * buffer, Int size, Int receiver, Int tag,                             \
       const CommunicationMode & mode) const;                                   \
   template void Communicator::receiveImpl<T>(T * buffer, Int size, Int sender, \
                                              Int tag) const;                   \
   template CommunicationRequest Communicator::asyncSendImpl<T>(                \
       const T * buffer, Int size, Int receiver, Int tag,                             \
       const CommunicationMode & mode) const;                                   \
   template CommunicationRequest Communicator::asyncReceiveImpl<T>(             \
       T * buffer, Int size, Int sender, Int tag) const;                        \
   template void Communicator::allGatherImpl<T>(T * values, int nb_values)      \
       const;                                                                   \
   template void Communicator::allGatherVImpl<T>(T * values, int * nb_values)   \
       const;                                                                   \
   template void Communicator::gatherImpl<T>(T * values, int nb_values,         \
                                             int root) const;                   \
   template void Communicator::gatherImpl<T>(                                   \
       T * values, int nb_values, T * gathered, int nb_gathered) const;         \
   template void Communicator::gatherVImpl<T>(T * values, int * nb_values,      \
                                              int root) const;                  \
   template void Communicator::broadcastImpl<T>(T * values, int nb_values,      \
                                                int root) const;                \
   template void Communicator::allReduceImpl<T>(                                \
       T * values, int nb_values, const SynchronizerOperation & op) const
 
 #define MIN_MAX_REAL SCMinMaxLoc<Real, int>
 
 AKANTU_COMM_INSTANTIATE(bool);
 AKANTU_COMM_INSTANTIATE(Real);
 AKANTU_COMM_INSTANTIATE(UInt);
 AKANTU_COMM_INSTANTIATE(Int);
 AKANTU_COMM_INSTANTIATE(char);
 AKANTU_COMM_INSTANTIATE(NodeType);
 AKANTU_COMM_INSTANTIATE(MIN_MAX_REAL);
 
 #if AKANTU_INTEGER_SIZE > 4
 AKANTU_COMM_INSTANTIATE(int);
 #endif
 
 // template void Communicator::send<SCMinMaxLoc<Real, int>>(
 //     SCMinMaxLoc<Real, int> * buffer, Int size, Int receiver, Int tag);
 // template void Communicator::receive<SCMinMaxLoc<Real, int>>(
 //     SCMinMaxLoc<Real, int> * buffer, Int size, Int sender, Int tag);
 // template CommunicationRequest
 // Communicator::asyncSend<SCMinMaxLoc<Real, int>>(
 //     SCMinMaxLoc<Real, int> * buffer, Int size, Int receiver, Int tag);
 // template CommunicationRequest
 // Communicator::asyncReceive<SCMinMaxLoc<Real, int>>(
 //     SCMinMaxLoc<Real, int> * buffer, Int size, Int sender, Int tag);
 // template void Communicator::probe<SCMinMaxLoc<Real, int>>(
 //     Int sender, Int tag, CommunicationStatus & status);
 // template void Communicator::allGather<SCMinMaxLoc<Real, int>>(
 //     SCMinMaxLoc<Real, int> * values, int nb_values);
 // template void Communicator::allGatherV<SCMinMaxLoc<Real, int>>(
 //     SCMinMaxLoc<Real, int> * values, int * nb_values);
 // template void Communicator::gather<SCMinMaxLoc<Real, int>>(
 //     SCMinMaxLoc<Real, int> * values, int nb_values, int root);
 // template void Communicator::gatherV<SCMinMaxLoc<Real, int>>(
 //     SCMinMaxLoc<Real, int> * values, int * nb_values, int root);
 // template void Communicator::broadcast<SCMinMaxLoc<Real, int>>(
 //     SCMinMaxLoc<Real, int> * values, int nb_values, int root);
 // template void Communicator::allReduce<SCMinMaxLoc<Real, int>>(
 //     SCMinMaxLoc<Real, int> * values, int nb_values,
 //     const SynchronizerOperation & op);
 } // akantu
diff --git a/src/synchronizer/communicator.hh b/src/synchronizer/communicator.hh
index 900b6b0dd..c0b103030 100644
--- a/src/synchronizer/communicator.hh
+++ b/src/synchronizer/communicator.hh
@@ -1,456 +1,457 @@
 /**
  * @file   static_communicator.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  Class handling the parallel communications
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "aka_common.hh"
 #include "aka_event_handler_manager.hh"
 #include "communication_buffer.hh"
 #include "communication_request.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_STATIC_COMMUNICATOR_HH__
 #define __AKANTU_STATIC_COMMUNICATOR_HH__
 
 namespace akantu {
 
 namespace debug {
   class CommunicationException : public Exception {
   public:
     CommunicationException()
         : Exception("An exception happen during a communication process.") {}
   };
 } // namespace debug
 
 /// @enum SynchronizerOperation reduce operation that the synchronizer can
 /// perform
 enum class SynchronizerOperation {
   _sum,
   _min,
   _max,
   _prod,
   _land,
   _band,
   _lor,
   _bor,
   _lxor,
   _bxor,
   _min_loc,
   _max_loc,
   _null
 };
 
 enum class CommunicationMode { _auto, _synchronous, _ready };
 
 namespace {
   int _any_source = -1;
 }
 } // namespace akantu
 
 namespace akantu {
 
 struct CommunicatorInternalData {
   virtual ~CommunicatorInternalData() = default;
 };
 
 class Communicator;
 
 struct FinalizeCommunicatorEvent {
   explicit FinalizeCommunicatorEvent(const Communicator & comm)
       : communicator(comm) {}
   const Communicator & communicator;
 };
 
 class CommunicatorEventHandler {
 public:
-  virtual ~CommunicatorEventHandler() {}
+  virtual ~CommunicatorEventHandler() = default;
   virtual void onCommunicatorFinalize() {}
 
 private:
   inline void sendEvent(const FinalizeCommunicatorEvent &) {
     onCommunicatorFinalize();
   }
 
   template <class EventHandler> friend class EventHandlerManager;
 };
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
 class Communicator : public EventHandlerManager<CommunicatorEventHandler> {
   struct private_member {};
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   Communicator(int & argc, char **& argv, const private_member &);
   ~Communicator() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /* ------------------------------------------------------------------------ */
   /* Point to Point                                                           */
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void receive(Array<T> & values, Int sender, Int tag) const {
     return this->receiveImpl(
         values.storage(), values.size() * values.getNbComponent(), sender, tag);
   }
   template <typename Tensor>
   inline void
   receive(Tensor & values, Int sender, Int tag,
           std::enable_if_t<is_tensor<Tensor>::value> * = nullptr) const {
     return this->receiveImpl(values.storage(), values.size(), sender, tag);
   }
   template <bool is_static>
   inline void receive(CommunicationBufferTemplated<is_static> & values,
                       Int sender, Int tag) const {
     return this->receiveImpl(values.storage(), values.size(), sender, tag);
   }
   template <typename T>
   inline void
   receive(T & values, Int sender, Int tag,
           std::enable_if_t<std::is_arithmetic<T>::value> * = nullptr) const {
     return this->receiveImpl(&values, 1, sender, tag);
   }
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void
   send(const Array<T> & values, Int receiver, Int tag,
        const CommunicationMode & mode = CommunicationMode::_auto) const {
     return this->sendImpl(values.storage(),
                           values.size() * values.getNbComponent(), receiver,
                           tag, mode);
   }
   template <typename Tensor>
   inline void
   send(const Tensor & values, Int receiver, Int tag,
        const CommunicationMode & mode = CommunicationMode::_auto,
        std::enable_if_t<is_tensor<Tensor>::value> * = nullptr) const {
     return this->sendImpl(values.storage(), values.size(), receiver, tag, mode);
   }
   template <bool is_static>
   inline void
   send(const CommunicationBufferTemplated<is_static> & values, Int receiver,
        Int tag,
        const CommunicationMode & mode = CommunicationMode::_auto) const {
     return this->sendImpl(values.storage(), values.size(), receiver, tag, mode);
   }
   template <typename T>
   inline void
   send(const T & values, Int receiver, Int tag,
        const CommunicationMode & mode = CommunicationMode::_auto,
        std::enable_if_t<std::is_arithmetic<T>::value> * = nullptr) const {
     return this->sendImpl(&values, 1, receiver, tag, mode);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline CommunicationRequest
   asyncSend(const Array<T> & values, Int receiver, Int tag,
             const CommunicationMode & mode = CommunicationMode::_auto) const {
     return this->asyncSendImpl(values.storage(),
                                values.size() * values.getNbComponent(),
                                receiver, tag, mode);
   }
   template <typename T>
   inline CommunicationRequest
   asyncSend(const std::vector<T> & values, Int receiver, Int tag,
             const CommunicationMode & mode = CommunicationMode::_auto) const {
     return this->asyncSendImpl(values.data(), values.size(), receiver, tag,
                                mode);
   }
 
   template <typename Tensor>
   inline CommunicationRequest
   asyncSend(const Tensor & values, Int receiver, Int tag,
             const CommunicationMode & mode = CommunicationMode::_auto,
             std::enable_if_t<is_tensor<Tensor>::value> * = nullptr) const {
     return this->asyncSendImpl(values.storage(), values.size(), receiver, tag,
                                mode);
   }
   template <bool is_static>
   inline CommunicationRequest
   asyncSend(const CommunicationBufferTemplated<is_static> & values,
             Int receiver, Int tag,
             const CommunicationMode & mode = CommunicationMode::_auto) const {
     return this->asyncSendImpl(values.storage(), values.size(), receiver, tag,
                                mode);
   }
   template <typename T>
   inline CommunicationRequest
   asyncSend(const T & values, Int receiver, Int tag,
             const CommunicationMode & mode = CommunicationMode::_auto,
             std::enable_if_t<std::is_arithmetic<T>::value> * = nullptr) const {
     return this->asyncSendImpl(&values, 1, receiver, tag, mode);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline CommunicationRequest asyncReceive(Array<T> & values, Int sender,
                                            Int tag) const {
     return this->asyncReceiveImpl(
         values.storage(), values.size() * values.getNbComponent(), sender, tag);
   }
   template <typename T>
   inline CommunicationRequest asyncReceive(std::vector<T> & values, Int sender,
                                            Int tag) const {
     return this->asyncReceiveImpl(values.data(), values.size(), sender, tag);
   }
 
   template <typename Tensor,
             typename = std::enable_if_t<is_tensor<Tensor>::value>>
   inline CommunicationRequest asyncReceive(Tensor & values, Int sender,
                                            Int tag) const {
     return this->asyncReceiveImpl(values.storage(), values.size(), sender, tag);
   }
   template <bool is_static>
   inline CommunicationRequest
   asyncReceive(CommunicationBufferTemplated<is_static> & values, Int sender,
                Int tag) const {
     return this->asyncReceiveImpl(values.storage(), values.size(), sender, tag);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   void probe(Int sender, Int tag, CommunicationStatus & status) const;
 
   template <typename T>
   bool asyncProbe(Int sender, Int tag, CommunicationStatus & status) const;
 
   /* ------------------------------------------------------------------------ */
   /* Collectives                                                              */
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void allReduce(Array<T> & values,
                         const SynchronizerOperation & op) const {
     this->allReduceImpl(values.storage(),
                         values.size() * values.getNbComponent(), op);
   }
 
   template <typename Tensor>
   inline void
   allReduce(Tensor & values, const SynchronizerOperation & op,
             std::enable_if_t<is_tensor<Tensor>::value> * = nullptr) const {
     this->allReduceImpl(values.storage(), values.size(), op);
   }
 
   template <typename T>
   inline void
   allReduce(T & values, const SynchronizerOperation & op,
             std::enable_if_t<std::is_arithmetic<T>::value> * = nullptr) const {
     this->allReduceImpl(&values, 1, op);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T> inline void allGather(Array<T> & values) const {
     AKANTU_DEBUG_ASSERT(UInt(psize) == values.size(),
                         "The array size is not correct");
     this->allGatherImpl(values.storage(), values.getNbComponent());
   }
 
   template <typename Tensor,
             typename = std::enable_if_t<is_tensor<Tensor>::value>>
   inline void allGather(Tensor & values) const {
     AKANTU_DEBUG_ASSERT(UInt(psize) == values.size(),
                         "The vector size is not correct");
     this->allGatherImpl(values.storage(), 1);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
-  inline void allGatherV(Array<T> & values, Array<Int> sizes) const {
+  inline void allGatherV(Array<T> & values, const Array<Int> & sizes) const {
     this->allGatherVImpl(values.storage(), sizes.storage());
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void reduce(Array<T> & values, const SynchronizerOperation & op,
                      int root = 0) const {
     this->reduceImpl(values.storage(), values.size() * values.getNbComponent(),
                      op, root);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename Tensor>
   inline void
   gather(Tensor & values, int root = 0,
          std::enable_if_t<is_tensor<Tensor>::value> * = nullptr) const {
     this->gatherImpl(values.storage(), values.getNbComponent(), root);
   }
   template <typename T>
   inline void
   gather(T values, int root = 0,
          std::enable_if_t<std::is_arithmetic<T>::value> * = nullptr) const {
     this->gatherImpl(&values, 1, root);
   }
   /* ------------------------------------------------------------------------ */
   template <typename Tensor, typename T>
   inline void
   gather(Tensor & values, Array<T> & gathered,
          std::enable_if_t<is_tensor<Tensor>::value> * = nullptr) const {
     AKANTU_DEBUG_ASSERT(values.size() == gathered.getNbComponent(),
                         "The array size is not correct");
     gathered.resize(psize);
     this->gatherImpl(values.data(), values.size(), gathered.storage(),
                      gathered.getNbComponent());
   }
 
   template <typename T>
   inline void
   gather(T values, Array<T> & gathered,
          std::enable_if_t<std::is_arithmetic<T>::value> * = nullptr) const {
     this->gatherImpl(&values, 1, gathered.storage(), 1);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
-  inline void gatherV(Array<T> & values, Array<Int> sizes, int root = 0) const {
+  inline void gatherV(Array<T> & values, const Array<Int> & sizes,
+                      int root = 0) const {
     this->gatherVImpl(values.storage(), sizes.storage(), root);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void broadcast(Array<T> & values, int root = 0) const {
     this->broadcastImpl(values.storage(),
                         values.size() * values.getNbComponent(), root);
   }
   template <bool is_static>
   inline void broadcast(CommunicationBufferTemplated<is_static> & values,
                         int root = 0) const {
     this->broadcastImpl(values.storage(), values.size(), root);
   }
   template <typename T> inline void broadcast(T & values, int root = 0) const {
     this->broadcastImpl(&values, 1, root);
   }
 
   /* ------------------------------------------------------------------------ */
   void barrier() const;
   CommunicationRequest asyncBarrier() const;
 
   /* ------------------------------------------------------------------------ */
   /* Request handling                                                         */
   /* ------------------------------------------------------------------------ */
   bool test(CommunicationRequest & request) const;
   bool testAll(std::vector<CommunicationRequest> & request) const;
   void wait(CommunicationRequest & request) const;
   void waitAll(std::vector<CommunicationRequest> & requests) const;
   UInt waitAny(std::vector<CommunicationRequest> & requests) const;
   inline void freeCommunicationRequest(CommunicationRequest & request) const;
   inline void
   freeCommunicationRequest(std::vector<CommunicationRequest> & requests) const;
 
   template <typename T, typename MsgProcessor, typename TagGen>
   inline void
   receiveAnyNumber(std::vector<CommunicationRequest> & send_requests,
                    Array<T> receive_buffer, MsgProcessor && processor,
                    TagGen && tag_gen) const;
 
 protected:
   template <typename T>
   void
   sendImpl(const T * buffer, Int size, Int receiver, Int tag,
            const CommunicationMode & mode = CommunicationMode::_auto) const;
 
   template <typename T>
   void receiveImpl(T * buffer, Int size, Int sender, Int tag) const;
 
   template <typename T>
   CommunicationRequest asyncSendImpl(
       const T * buffer, Int size, Int receiver, Int tag,
       const CommunicationMode & mode = CommunicationMode::_auto) const;
 
   template <typename T>
   CommunicationRequest asyncReceiveImpl(T * buffer, Int size, Int sender,
                                         Int tag) const;
 
   template <typename T>
   void allReduceImpl(T * values, int nb_values,
                      const SynchronizerOperation & op) const;
 
   template <typename T> void allGatherImpl(T * values, int nb_values) const;
   template <typename T> void allGatherVImpl(T * values, int * nb_values) const;
 
   template <typename T>
   void reduceImpl(T * values, int nb_values, const SynchronizerOperation & op,
                   int root = 0) const;
   template <typename T>
   void gatherImpl(T * values, int nb_values, int root = 0) const;
 
   template <typename T>
   void gatherImpl(T * values, int nb_values, T * gathered,
                   int nb_gathered = 0) const;
 
   template <typename T>
   void gatherVImpl(T * values, int * nb_values, int root = 0) const;
 
   template <typename T>
   void broadcastImpl(T * values, int nb_values, int root = 0) const;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   Int getNbProc() const { return psize; };
   Int whoAmI() const { return prank; };
 
   static Communicator & getStaticCommunicator();
   static Communicator & getStaticCommunicator(int & argc, char **& argv);
 
   int getMaxTag() const;
   int getMinTag() const;
 
   AKANTU_GET_MACRO(CommunicatorData, (*communicator_data), decltype(auto));
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   static std::unique_ptr<Communicator> static_communicator;
 
 protected:
   Int prank{0};
   Int psize{1};
   std::unique_ptr<CommunicatorInternalData> communicator_data;
 };
 
 inline std::ostream & operator<<(std::ostream & stream,
                                  const CommunicationRequest & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #include "communicator_inline_impl.hh"
 
 #endif /* __AKANTU_STATIC_COMMUNICATOR_HH__ */
diff --git a/src/synchronizer/communicator_mpi_inline_impl.cc b/src/synchronizer/communicator_mpi_inline_impl.cc
index 9c3cf04ee..ad9f7a49f 100644
--- a/src/synchronizer/communicator_mpi_inline_impl.cc
+++ b/src/synchronizer/communicator_mpi_inline_impl.cc
@@ -1,465 +1,463 @@
 /**
  * @file   static_communicator_mpi.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Sep 26 2010
  * @date last modification: Thu Jan 21 2016
  *
  * @brief  StaticCommunicatorMPI implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_iterators.hh"
 #include "communicator.hh"
 #include "mpi_communicator_data.hh"
 /* -------------------------------------------------------------------------- */
 #include <type_traits>
 #include <unordered_map>
 #include <vector>
 #include <memory>
 /* -------------------------------------------------------------------------- */
 #include <mpi.h>
 /* -------------------------------------------------------------------------- */
 
 #if (defined(__GNUC__) || defined(__GNUG__))
 #define GCC_VERSION                                                            \
   (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
 #if GCC_VERSION < 60000
 namespace std {
 template <> struct hash<akantu::SynchronizerOperation> {
   using argument_type = akantu::SynchronizerOperation;
   size_t operator()(const argument_type & e) const noexcept {
     auto ue = underlying_type_t<argument_type>(e);
       return uh(ue);
     }
 
   private:
     const hash<underlying_type_t<argument_type>> uh{};
   };
 } // namespace std
 #endif
 #endif
 
 
 namespace akantu {
 
 class CommunicationRequestMPI : public InternalCommunicationRequest {
 public:
   CommunicationRequestMPI(UInt source, UInt dest)
       : InternalCommunicationRequest(source, dest),
         request(std::make_unique<MPI_Request>()) {}
   MPI_Request & getMPIRequest() { return *request; };
 
 private:
   std::unique_ptr<MPI_Request> request;
 };
 
 namespace {
   template <typename T> inline MPI_Datatype getMPIDatatype();
   MPI_Op getMPISynchronizerOperation(const SynchronizerOperation & op) {
     std::unordered_map<SynchronizerOperation, MPI_Op> _operations{
         {SynchronizerOperation::_sum, MPI_SUM},
         {SynchronizerOperation::_min, MPI_MIN},
         {SynchronizerOperation::_max, MPI_MAX},
         {SynchronizerOperation::_prod, MPI_PROD},
         {SynchronizerOperation::_land, MPI_LAND},
         {SynchronizerOperation::_band, MPI_BAND},
         {SynchronizerOperation::_lor, MPI_LOR},
         {SynchronizerOperation::_bor, MPI_BOR},
         {SynchronizerOperation::_lxor, MPI_LXOR},
         {SynchronizerOperation::_bxor, MPI_BXOR},
         {SynchronizerOperation::_min_loc, MPI_MINLOC},
         {SynchronizerOperation::_max_loc, MPI_MAXLOC},
         {SynchronizerOperation::_null, MPI_OP_NULL}};
     return _operations[op];
   }
 
   template <typename T> MPI_Datatype inline getMPIDatatype() {
     return MPI_DATATYPE_NULL;
   }
 
 #define SPECIALIZE_MPI_DATATYPE(type, mpi_type)                                \
   template <> MPI_Datatype inline getMPIDatatype<type>() { return mpi_type; }
 
 #define COMMA ,
   SPECIALIZE_MPI_DATATYPE(char, MPI_CHAR)
   SPECIALIZE_MPI_DATATYPE(float, MPI_FLOAT)
   SPECIALIZE_MPI_DATATYPE(double, MPI_DOUBLE)
   SPECIALIZE_MPI_DATATYPE(long double, MPI_LONG_DOUBLE)
   SPECIALIZE_MPI_DATATYPE(signed int, MPI_INT)
   SPECIALIZE_MPI_DATATYPE(NodeType, getMPIDatatype<Int>())
   SPECIALIZE_MPI_DATATYPE(unsigned int, MPI_UNSIGNED)
   SPECIALIZE_MPI_DATATYPE(signed long int, MPI_LONG)
   SPECIALIZE_MPI_DATATYPE(unsigned long int, MPI_UNSIGNED_LONG)
   SPECIALIZE_MPI_DATATYPE(signed long long int, MPI_LONG_LONG)
   SPECIALIZE_MPI_DATATYPE(unsigned long long int, MPI_UNSIGNED_LONG_LONG)
   SPECIALIZE_MPI_DATATYPE(SCMinMaxLoc<double COMMA int>, MPI_DOUBLE_INT)
   SPECIALIZE_MPI_DATATYPE(SCMinMaxLoc<float COMMA int>, MPI_FLOAT_INT)
   SPECIALIZE_MPI_DATATYPE(bool, MPI_CXX_BOOL)
 
   inline int getMPISource(int src) {
     if (src == _any_source)
       return MPI_ANY_SOURCE;
     return src;
   }
 
   decltype(auto) convertRequests(std::vector<CommunicationRequest> & requests) {
     std::vector<MPI_Request> mpi_requests(requests.size());
 
     for (auto && request_pair : zip(requests, mpi_requests)) {
       auto && req = std::get<0>(request_pair);
       auto && mpi_req = std::get<1>(request_pair);
       mpi_req = dynamic_cast<CommunicationRequestMPI &>(req.getInternal())
                     .getMPIRequest();
     }
     return mpi_requests;
   }
 
 } // namespace
 
 // this is ugly but shorten the code a lot
 #define MPIDATA                                                                \
   (*reinterpret_cast<MPICommunicatorData *>(communicator_data.get()))
 
 /* -------------------------------------------------------------------------- */
 /* Implementation                                                             */
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 Communicator::Communicator(int & /*argc*/, char **& /*argv*/,
                            const private_member & /*unused*/)
     : communicator_data(std::make_unique<MPICommunicatorData>()) {
   prank = MPIDATA.rank();
   psize = MPIDATA.size();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Communicator::sendImpl(const T * buffer, Int size, Int receiver, Int tag,
                             const CommunicationMode & mode) const {
   MPI_Comm communicator = MPIDATA.getMPICommunicator();
   MPI_Datatype type = getMPIDatatype<T>();
 
   switch (mode) {
   case CommunicationMode::_auto:
     MPI_Send(buffer, size, type, receiver, tag, communicator);
     break;
   case CommunicationMode::_synchronous:
     MPI_Ssend(buffer, size, type, receiver, tag, communicator);
     break;
   case CommunicationMode::_ready:
     MPI_Rsend(buffer, size, type, receiver, tag, communicator);
     break;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Communicator::receiveImpl(T * buffer, Int size, Int sender,
                                Int tag) const {
   MPI_Comm communicator = MPIDATA.getMPICommunicator();
   MPI_Status status;
   MPI_Datatype type = getMPIDatatype<T>();
   MPI_Recv(buffer, size, type, getMPISource(sender), tag, communicator,
            &status);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 CommunicationRequest
 Communicator::asyncSendImpl(const T * buffer, Int size, Int receiver, Int tag,
                             const CommunicationMode & mode) const {
   MPI_Comm communicator = MPIDATA.getMPICommunicator();
-  CommunicationRequestMPI * request =
-      new CommunicationRequestMPI(prank, receiver);
+  auto * request = new CommunicationRequestMPI(prank, receiver);
   MPI_Request & req = request->getMPIRequest();
 
   MPI_Datatype type = getMPIDatatype<T>();
 
   switch (mode) {
   case CommunicationMode::_auto:
     MPI_Isend(buffer, size, type, receiver, tag, communicator, &req);
     break;
   case CommunicationMode::_synchronous:
     MPI_Issend(buffer, size, type, receiver, tag, communicator, &req);
     break;
   case CommunicationMode::_ready:
     MPI_Irsend(buffer, size, type, receiver, tag, communicator, &req);
     break;
   }
   return std::shared_ptr<InternalCommunicationRequest>(request);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 CommunicationRequest Communicator::asyncReceiveImpl(T * buffer, Int size,
                                                     Int sender, Int tag) const {
   MPI_Comm communicator = MPIDATA.getMPICommunicator();
-  CommunicationRequestMPI * request =
-      new CommunicationRequestMPI(sender, prank);
+  auto * request = new CommunicationRequestMPI(sender, prank);
   MPI_Datatype type = getMPIDatatype<T>();
 
   MPI_Request & req = request->getMPIRequest();
   MPI_Irecv(buffer, size, type, getMPISource(sender), tag, communicator, &req);
   return std::shared_ptr<InternalCommunicationRequest>(request);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Communicator::probe(Int sender, Int tag,
                          CommunicationStatus & status) const {
   MPI_Comm communicator = MPIDATA.getMPICommunicator();
   MPI_Status mpi_status;
   MPI_Probe(getMPISource(sender), tag, communicator, &mpi_status);
 
   MPI_Datatype type = getMPIDatatype<T>();
   int count;
   MPI_Get_count(&mpi_status, type, &count);
 
   status.setSource(mpi_status.MPI_SOURCE);
   status.setTag(mpi_status.MPI_TAG);
   status.setSize(count);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 bool Communicator::asyncProbe(Int sender, Int tag,
                               CommunicationStatus & status) const {
   MPI_Comm communicator = MPIDATA.getMPICommunicator();
   MPI_Status mpi_status;
   int test;
   MPI_Iprobe(getMPISource(sender), tag, communicator, &test, &mpi_status);
 
   if (not test)
     return false;
 
   MPI_Datatype type = getMPIDatatype<T>();
   int count;
   MPI_Get_count(&mpi_status, type, &count);
 
   status.setSource(mpi_status.MPI_SOURCE);
   status.setTag(mpi_status.MPI_TAG);
   status.setSize(count);
   return true;
 }
 
 /* -------------------------------------------------------------------------- */
 bool Communicator::test(CommunicationRequest & request) const {
   MPI_Status status;
   int flag;
-  CommunicationRequestMPI & req_mpi =
+  auto & req_mpi =
       dynamic_cast<CommunicationRequestMPI &>(request.getInternal());
   MPI_Request & req = req_mpi.getMPIRequest();
 
 #if !defined(AKANTU_NDEBUG)
   int ret =
 #endif
       MPI_Test(&req, &flag, &status);
 
   AKANTU_DEBUG_ASSERT(ret == MPI_SUCCESS, "Error in MPI_Test.");
   return (flag != 0);
 }
 
 /* -------------------------------------------------------------------------- */
 bool Communicator::testAll(std::vector<CommunicationRequest> & requests) const {
   int are_finished;
   auto && mpi_requests = convertRequests(requests);
   MPI_Testall(mpi_requests.size(), mpi_requests.data(), &are_finished,
               MPI_STATUSES_IGNORE);
   return are_finished != 0 ? true : false;
 }
 
 /* -------------------------------------------------------------------------- */
 void Communicator::wait(CommunicationRequest & request) const {
   MPI_Status status;
-  CommunicationRequestMPI & req_mpi =
+  auto & req_mpi =
       dynamic_cast<CommunicationRequestMPI &>(request.getInternal());
   MPI_Request & req = req_mpi.getMPIRequest();
   MPI_Wait(&req, &status);
 }
 
 /* -------------------------------------------------------------------------- */
 void Communicator::waitAll(std::vector<CommunicationRequest> & requests) const {
   auto && mpi_requests = convertRequests(requests);
   MPI_Waitall(mpi_requests.size(), mpi_requests.data(), MPI_STATUSES_IGNORE);
 }
 
 /* -------------------------------------------------------------------------- */
 UInt Communicator::waitAny(std::vector<CommunicationRequest> & requests) const {
   auto && mpi_requests = convertRequests(requests);
 
   int pos;
   MPI_Waitany(mpi_requests.size(), mpi_requests.data(), &pos,
               MPI_STATUSES_IGNORE);
 
   if (pos != MPI_UNDEFINED) {
     return pos;
   } else {
     return UInt(-1);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Communicator::barrier() const {
   MPI_Comm communicator = MPIDATA.getMPICommunicator();
   MPI_Barrier(communicator);
 }
 
 /* -------------------------------------------------------------------------- */
 CommunicationRequest Communicator::asyncBarrier() const {
   MPI_Comm communicator = MPIDATA.getMPICommunicator();
-  CommunicationRequestMPI * request = new CommunicationRequestMPI(0, 0);
+  auto * request = new CommunicationRequestMPI(0, 0);
 
   MPI_Request & req = request->getMPIRequest();
   MPI_Ibarrier(communicator, &req);
 
   return std::shared_ptr<InternalCommunicationRequest>(request);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Communicator::reduceImpl(T * values, int nb_values,
                               const SynchronizerOperation & op,
                               int root) const {
   MPI_Comm communicator = MPIDATA.getMPICommunicator();
   MPI_Datatype type = getMPIDatatype<T>();
 
   MPI_Reduce(MPI_IN_PLACE, values, nb_values, type,
              getMPISynchronizerOperation(op), root, communicator);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Communicator::allReduceImpl(T * values, int nb_values,
                                  const SynchronizerOperation & op) const {
   MPI_Comm communicator = MPIDATA.getMPICommunicator();
   MPI_Datatype type = getMPIDatatype<T>();
 
   MPI_Allreduce(MPI_IN_PLACE, values, nb_values, type,
                 getMPISynchronizerOperation(op), communicator);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Communicator::allGatherImpl(T * values, int nb_values) const {
   MPI_Comm communicator = MPIDATA.getMPICommunicator();
   MPI_Datatype type = getMPIDatatype<T>();
 
   MPI_Allgather(MPI_IN_PLACE, nb_values, type, values, nb_values, type,
                 communicator);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Communicator::allGatherVImpl(T * values, int * nb_values) const {
   MPI_Comm communicator = MPIDATA.getMPICommunicator();
   std::vector<int> displs(psize);
   displs[0] = 0;
   for (int i = 1; i < psize; ++i) {
     displs[i] = displs[i - 1] + nb_values[i - 1];
   }
 
   MPI_Datatype type = getMPIDatatype<T>();
   MPI_Allgatherv(MPI_IN_PLACE, *nb_values, type, values, nb_values,
                  displs.data(), type, communicator);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Communicator::gatherImpl(T * values, int nb_values, int root) const {
   MPI_Comm communicator = MPIDATA.getMPICommunicator();
   T *send_buf = nullptr, *recv_buf = nullptr;
   if (prank == root) {
     send_buf = (T *)MPI_IN_PLACE;
     recv_buf = values;
   } else {
     send_buf = values;
   }
 
   MPI_Datatype type = getMPIDatatype<T>();
   MPI_Gather(send_buf, nb_values, type, recv_buf, nb_values, type, root,
              communicator);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Communicator::gatherImpl(T * values, int nb_values, T * gathered,
                               int nb_gathered) const {
   MPI_Comm communicator = MPIDATA.getMPICommunicator();
   T * send_buf = values;
   T * recv_buf = gathered;
 
   if (nb_gathered == 0)
     nb_gathered = nb_values;
 
   MPI_Datatype type = getMPIDatatype<T>();
   MPI_Gather(send_buf, nb_values, type, recv_buf, nb_gathered, type,
              this->prank, communicator);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Communicator::gatherVImpl(T * values, int * nb_values, int root) const {
   MPI_Comm communicator = MPIDATA.getMPICommunicator();
   int * displs = nullptr;
   if (prank == root) {
     displs = new int[psize];
     displs[0] = 0;
     for (int i = 1; i < psize; ++i) {
       displs[i] = displs[i - 1] + nb_values[i - 1];
     }
   }
 
   T *send_buf = nullptr, *recv_buf = nullptr;
   if (prank == root) {
     send_buf = (T *)MPI_IN_PLACE;
     recv_buf = values;
   } else
     send_buf = values;
 
   MPI_Datatype type = getMPIDatatype<T>();
 
   MPI_Gatherv(send_buf, *nb_values, type, recv_buf, nb_values, displs, type,
               root, communicator);
 
   if (prank == root) {
     delete[] displs;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Communicator::broadcastImpl(T * values, int nb_values, int root) const {
   MPI_Comm communicator = MPIDATA.getMPICommunicator();
   MPI_Datatype type = getMPIDatatype<T>();
   MPI_Bcast(values, nb_values, type, root, communicator);
 }
 
 /* -------------------------------------------------------------------------- */
 int Communicator::getMaxTag() const { return MPIDATA.getMaxTag(); }
 int Communicator::getMinTag() const { return 0; }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/synchronizer/data_accessor.cc b/src/synchronizer/data_accessor.cc
index c1f6ee670..c4855e9ab 100644
--- a/src/synchronizer/data_accessor.cc
+++ b/src/synchronizer/data_accessor.cc
@@ -1,163 +1,163 @@
 /**
  * @file   data_accessor.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  data accessors constructor functions
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "data_accessor.hh"
 #include "fe_engine.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename T, bool pack_helper>
 void DataAccessor<Element>::packUnpackNodalDataHelper(
     Array<T> & data, CommunicationBuffer & buffer,
     const Array<Element> & elements, const Mesh & mesh) {
   UInt nb_component = data.getNbComponent();
   UInt nb_nodes_per_element = 0;
 
   ElementType current_element_type = _not_defined;
   GhostType current_ghost_type = _casper;
-  UInt * conn = NULL;
+  UInt * conn = nullptr;
 
   Array<Element>::const_iterator<Element> it = elements.begin();
   Array<Element>::const_iterator<Element> end = elements.end();
   for (; it != end; ++it) {
     const Element & el = *it;
     if (el.type != current_element_type ||
         el.ghost_type != current_ghost_type) {
       current_element_type = el.type;
       current_ghost_type = el.ghost_type;
       conn = mesh.getConnectivity(el.type, el.ghost_type).storage();
       nb_nodes_per_element = Mesh::getNbNodesPerElement(el.type);
     }
 
     UInt el_offset = el.element * nb_nodes_per_element;
     for (UInt n = 0; n < nb_nodes_per_element; ++n) {
       UInt offset_conn = conn[el_offset + n];
       Vector<T> data_vect(data.storage() + offset_conn * nb_component,
                           nb_component);
 
       if (pack_helper)
         buffer << data_vect;
       else
         buffer >> data_vect;
     }
   }
 }
 
 /* ------------------------------------------------------------------------ */
 template <typename T, bool pack_helper>
 void DataAccessor<Element>::packUnpackElementalDataHelper(
     ElementTypeMapArray<T> & data_to_pack, CommunicationBuffer & buffer,
     const Array<Element> & element, bool per_quadrature_point_data,
     const FEEngine & fem) {
   ElementType current_element_type = _not_defined;
   GhostType current_ghost_type = _casper;
   UInt nb_quad_per_elem = 0;
   UInt nb_component = 0;
 
-  Array<T> * vect = NULL;
+  Array<T> * vect = nullptr;
 
   Array<Element>::const_iterator<Element> it = element.begin();
   Array<Element>::const_iterator<Element> end = element.end();
   for (; it != end; ++it) {
     const Element & el = *it;
     if (el.type != current_element_type ||
         el.ghost_type != current_ghost_type) {
       current_element_type = el.type;
       current_ghost_type = el.ghost_type;
       vect = &data_to_pack(el.type, el.ghost_type);
       if (per_quadrature_point_data)
         nb_quad_per_elem = fem.getNbIntegrationPoints(el.type, el.ghost_type);
       else
         nb_quad_per_elem = 1;
       nb_component = vect->getNbComponent();
     }
 
     Vector<T> data(vect->storage() +
                        el.element * nb_component * nb_quad_per_elem,
                    nb_component * nb_quad_per_elem);
     if (pack_helper)
       buffer << data;
     else
       buffer >> data;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, bool pack_helper>
 void DataAccessor<UInt>::packUnpackDOFDataHelper(Array<T> & data,
                                                  CommunicationBuffer & buffer,
                                                  const Array<UInt> & dofs) {
   Array<UInt>::const_scalar_iterator it_dof = dofs.begin();
   Array<UInt>::const_scalar_iterator end_dof = dofs.end();
   T * data_ptr = data.storage();
 
   for (; it_dof != end_dof; ++it_dof) {
     if (pack_helper)
       buffer << data_ptr[*it_dof];
     else
       buffer >> data_ptr[*it_dof];
   }
 }
 
 /* -------------------------------------------------------------------------- */
 #define DECLARE_HELPERS(T)                                                     \
   template void DataAccessor<Element>::packUnpackNodalDataHelper<T, false>(    \
       Array<T> & data, CommunicationBuffer & buffer,                           \
       const Array<Element> & elements, const Mesh & mesh);                     \
   template void DataAccessor<Element>::packUnpackNodalDataHelper<T, true>(     \
       Array<T> & data, CommunicationBuffer & buffer,                           \
       const Array<Element> & elements, const Mesh & mesh);                     \
   template void                                                                \
   DataAccessor<Element>::packUnpackElementalDataHelper<T, false>(              \
       ElementTypeMapArray<T> & data_to_pack, CommunicationBuffer & buffer,     \
       const Array<Element> & element, bool per_quadrature_point_data,          \
       const FEEngine & fem);                                                   \
   template void DataAccessor<Element>::packUnpackElementalDataHelper<T, true>( \
       ElementTypeMapArray<T> & data_to_pack, CommunicationBuffer & buffer,     \
       const Array<Element> & element, bool per_quadrature_point_data,          \
       const FEEngine & fem);                                                   \
   template void DataAccessor<UInt>::packUnpackDOFDataHelper<T, true>(          \
       Array<T> & data, CommunicationBuffer & buffer,                           \
       const Array<UInt> & dofs);                                               \
   template void DataAccessor<UInt>::packUnpackDOFDataHelper<T, false>(         \
       Array<T> & data, CommunicationBuffer & buffer, const Array<UInt> & dofs)
 
 /* -------------------------------------------------------------------------- */
 DECLARE_HELPERS(Real);
 DECLARE_HELPERS(UInt);
 DECLARE_HELPERS(bool);
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/synchronizer/data_accessor.hh b/src/synchronizer/data_accessor.hh
index 16cfab1e9..cebcb66b3 100644
--- a/src/synchronizer/data_accessor.hh
+++ b/src/synchronizer/data_accessor.hh
@@ -1,279 +1,279 @@
 /**
  * @file   data_accessor.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Sep 01 2010
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Interface of accessors for pack_unpack system
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "communication_buffer.hh"
 #include "element.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_DATA_ACCESSOR_HH__
 #define __AKANTU_DATA_ACCESSOR_HH__
 
 namespace akantu {
 class FEEngine;
 } // akantu
 
 namespace akantu {
 
 class DataAccessorBase {
 public:
-  DataAccessorBase() {}
-  virtual ~DataAccessorBase() {}
+  DataAccessorBase() = default;
+  virtual ~DataAccessorBase() = default;
 };
 
 template <class T> class DataAccessor : public virtual DataAccessorBase {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-  DataAccessor() {}
-  ~DataAccessor() override {}
+  DataAccessor() = default;
+  ~DataAccessor() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /**
    * @brief get  the number of  data to exchange  for a given array of T
    * (elements or dofs) and a given akantu::SynchronizationTag
    */
   virtual UInt getNbData(const Array<T> & elements,
                          const SynchronizationTag & tag) const = 0;
 
   /**
    * @brief pack the data for a given array of T (elements or dofs) and a given
    * akantu::SynchronizationTag
    */
   virtual void packData(CommunicationBuffer & buffer, const Array<T> & element,
                         const SynchronizationTag & tag) const = 0;
 
   /**
    * @brief unpack the data for a given array of T (elements or dofs) and a
    * given akantu::SynchronizationTag
    */
   virtual void unpackData(CommunicationBuffer & buffer,
                           const Array<T> & element,
                           const SynchronizationTag & tag) = 0;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Specialization                                                             */
 /* -------------------------------------------------------------------------- */
 template <> class DataAccessor<Element> : public virtual DataAccessorBase {
 public:
-  DataAccessor() {}
-  ~DataAccessor() override {}
+  DataAccessor() = default;
+  ~DataAccessor() override = default;
 
   virtual UInt getNbData(const Array<Element> & elements,
                          const SynchronizationTag & tag) const = 0;
   virtual void packData(CommunicationBuffer & buffer,
                         const Array<Element> & element,
                         const SynchronizationTag & tag) const = 0;
   virtual void unpackData(CommunicationBuffer & buffer,
                           const Array<Element> & element,
                           const SynchronizationTag & tag) = 0;
 
   /* ------------------------------------------------------------------------ */
 public:
   template <typename T, bool pack_helper>
   static void
   packUnpackNodalDataHelper(Array<T> & data, CommunicationBuffer & buffer,
                             const Array<Element> & elements, const Mesh & mesh);
 
   /* ------------------------------------------------------------------------ */
   template <typename T, bool pack_helper>
   static void packUnpackElementalDataHelper(
       ElementTypeMapArray<T> & data_to_pack, CommunicationBuffer & buffer,
       const Array<Element> & element, bool per_quadrature_point_data,
       const FEEngine & fem);
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   static void
   packNodalDataHelper(const Array<T> & data, CommunicationBuffer & buffer,
                       const Array<Element> & elements, const Mesh & mesh) {
     packUnpackNodalDataHelper<T, true>(const_cast<Array<T> &>(data), buffer,
                                        elements, mesh);
   }
 
   template <typename T>
   static inline void
   unpackNodalDataHelper(Array<T> & data, CommunicationBuffer & buffer,
                         const Array<Element> & elements, const Mesh & mesh) {
     packUnpackNodalDataHelper<T, false>(data, buffer, elements, mesh);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   static inline void
   packElementalDataHelper(const ElementTypeMapArray<T> & data_to_pack,
                           CommunicationBuffer & buffer,
                           const Array<Element> & elements,
                           bool per_quadrature_point, const FEEngine & fem) {
     packUnpackElementalDataHelper<T, true>(
         const_cast<ElementTypeMapArray<T> &>(data_to_pack), buffer, elements,
         per_quadrature_point, fem);
   }
 
   template <typename T>
   static inline void
   unpackElementalDataHelper(ElementTypeMapArray<T> & data_to_unpack,
                             CommunicationBuffer & buffer,
                             const Array<Element> & elements,
                             bool per_quadrature_point, const FEEngine & fem) {
     packUnpackElementalDataHelper<T, false>(data_to_unpack, buffer, elements,
                                             per_quadrature_point, fem);
   }
 };
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 template <> class DataAccessor<UInt> : public virtual DataAccessorBase {
 public:
-  DataAccessor() {}
-  ~DataAccessor() override {}
+  DataAccessor() = default;
+  ~DataAccessor() override = default;
 
   virtual UInt getNbData(const Array<UInt> & elements,
                          const SynchronizationTag & tag) const = 0;
   virtual void packData(CommunicationBuffer & buffer,
                         const Array<UInt> & element,
                         const SynchronizationTag & tag) const = 0;
   virtual void unpackData(CommunicationBuffer & buffer,
                           const Array<UInt> & element,
                           const SynchronizationTag & tag) = 0;
   /* ------------------------------------------------------------------------ */
 public:
   template <typename T, bool pack_helper>
   static void packUnpackDOFDataHelper(Array<T> & data,
                                       CommunicationBuffer & buffer,
                                       const Array<UInt> & dofs);
 
   template <typename T>
   static inline void packDOFDataHelper(const Array<T> & data_to_pack,
                                        CommunicationBuffer & buffer,
                                        const Array<UInt> & dofs) {
     packUnpackDOFDataHelper<T, true>(const_cast<Array<T> &>(data_to_pack),
                                      buffer, dofs);
   }
 
   template <typename T>
   static inline void unpackDOFDataHelper(Array<T> & data_to_unpack,
                                          CommunicationBuffer & buffer,
                                          const Array<UInt> & dofs) {
     packUnpackDOFDataHelper<T, false>(data_to_unpack, buffer, dofs);
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename T> class AddOperation {
 public:
   inline T operator()(T & a, T & b) { return a + b; };
 };
 
 template <typename T> class IdentityOperation {
 public:
   inline T & operator()(T &, T & b) { return b; };
 };
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 template <template <class> class Op, class T>
 class ReduceUIntDataAccessor : public virtual DataAccessor<UInt> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   ReduceUIntDataAccessor(Array<T> & data, const SynchronizationTag & tag)
       : data(data), tag(tag) {}
 
-  ~ReduceUIntDataAccessor() override {}
+  ~ReduceUIntDataAccessor() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /* ------------------------------------------------------------------------ */
   UInt getNbData(const Array<UInt> & elements,
                  const SynchronizationTag & tag) const override {
     if (tag != this->tag)
       return 0;
 
     Vector<T> tmp(data.getNbComponent());
     return elements.size() * CommunicationBuffer::sizeInBuffer(tmp);
   }
 
   /* ------------------------------------------------------------------------ */
   void packData(CommunicationBuffer & buffer, const Array<UInt> & elements,
                 const SynchronizationTag & tag) const override {
     if (tag != this->tag)
       return;
 
     auto data_it = data.begin(data.getNbComponent());
     for (auto el : elements) {
       buffer << Vector<T>(data_it[el]);
     }
   }
 
   /* ------------------------------------------------------------------------ */
   void unpackData(CommunicationBuffer & buffer, const Array<UInt> & elements,
                   const SynchronizationTag & tag) override {
     if (tag != this->tag)
       return;
 
     auto data_it = data.begin(data.getNbComponent());
     for (auto el : elements) {
       Vector<T> unpacked(data.getNbComponent());
       Vector<T> vect(data_it[el]);
       buffer >> unpacked;
 
       vect = oper(vect, unpacked);
     }
   }
 
 protected:
   /// data to (un)pack
   Array<T> & data;
 
   /// Tag to consider
   SynchronizationTag tag;
 
   /// reduction operator
   Op<Vector<T>> oper;
 };
 
 /* -------------------------------------------------------------------------- */
 template <class T>
 using SimpleUIntDataAccessor = ReduceUIntDataAccessor<IdentityOperation, T>;
 
 } // akantu
 
 #endif /* __AKANTU_DATA_ACCESSOR_HH__ */
diff --git a/src/synchronizer/dof_synchronizer.cc b/src/synchronizer/dof_synchronizer.cc
index d08294119..73873d1b3 100644
--- a/src/synchronizer/dof_synchronizer.cc
+++ b/src/synchronizer/dof_synchronizer.cc
@@ -1,281 +1,281 @@
 /**
  * @file   dof_synchronizer.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 17 2011
  * @date last modification: Wed Oct 21 2015
  *
  * @brief  DOF synchronizing object implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dof_synchronizer.hh"
 #include "aka_iterators.hh"
 #include "dof_manager_default.hh"
 #include "mesh.hh"
 #include "node_synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /**
  * A DOFSynchronizer needs a mesh and the number of degrees of freedom
  * per node to be created. In the constructor computes the local and global dof
  * number for each dof. The member
  * proc_informations (std vector) is resized with the number of mpi
  * processes. Each entry in the vector is a PerProcInformations object
  * that contains the interactions of the current mpi process (prank) with the
  * mpi process corresponding to the position of that entry. Every
  * ProcInformations object contains one array with the dofs that have
  * to be sent to prank and a second one with dofs that willl be received form
  * prank.
  * This information is needed for the asychronous communications. The
  * constructor sets up this information.
  */
 DOFSynchronizer::DOFSynchronizer(DOFManagerDefault & dof_manager, const ID & id,
                                  MemoryID memory_id,
                                  const Communicator & comm)
     : SynchronizerImpl<UInt>(id, memory_id, comm), root(0),
       dof_manager(dof_manager), root_dofs(0, 1, "dofs-to-receive-from-master"),
       dof_changed(true) {
   std::vector<ID> dof_ids = dof_manager.getDOFIDs();
 
   // Transfers nodes to global equation numbers in new schemes
-  for (ID dof_id : dof_ids) {
+  for (const ID & dof_id : dof_ids) {
     registerDOFs(dof_id);
   }
 
   this->initScatterGatherCommunicationScheme();
 }
 
 /* -------------------------------------------------------------------------- */
-DOFSynchronizer::~DOFSynchronizer() {}
+DOFSynchronizer::~DOFSynchronizer() = default;
 
 /* -------------------------------------------------------------------------- */
 void DOFSynchronizer::registerDOFs(const ID & dof_id) {
   if (this->nb_proc == 1)
     return;
 
   if (dof_manager.getSupportType(dof_id) != _dst_nodal)
     return;
 
   using const_scheme_iterator = Communications<UInt>::const_scheme_iterator;
 
   const auto equation_numbers = dof_manager.getLocalEquationNumbers(dof_id);
 
   const auto & associated_nodes = dof_manager.getDOFsAssociatedNodes(dof_id);
   const auto & node_synchronizer = dof_manager.getMesh().getNodeSynchronizer();
   const auto & node_communications = node_synchronizer.getCommunications();
 
   auto transcode_node_to_global_dof_scheme =
       [this, &associated_nodes,
        &equation_numbers](const_scheme_iterator it, const_scheme_iterator end,
                           const CommunicationSendRecv & sr) -> void {
     for (; it != end; ++it) {
       auto & scheme = communications.createScheme(it->first, sr);
 
       const auto & node_scheme = it->second;
       for (auto & node : node_scheme) {
         auto an_begin = associated_nodes.begin();
         auto an_it = an_begin;
         auto an_end = associated_nodes.end();
 
         std::vector<UInt> global_dofs_per_node;
         while ((an_it = std::find(an_it, an_end, node)) != an_end) {
           UInt pos = an_it - an_begin;
           UInt local_eq_num = equation_numbers(pos);
           UInt global_eq_num =
               dof_manager.localToGlobalEquationNumber(local_eq_num);
           global_dofs_per_node.push_back(global_eq_num);
           ++an_it;
         }
 
         std::sort(global_dofs_per_node.begin(), global_dofs_per_node.end());
         std::transform(global_dofs_per_node.begin(), global_dofs_per_node.end(),
                        global_dofs_per_node.begin(), [this](UInt g) -> UInt {
                          UInt l = dof_manager.globalToLocalEquationNumber(g);
                          return l;
                        });
         for (auto & leqnum : global_dofs_per_node) {
           scheme.push_back(leqnum);
         }
       }
     }
   };
 
   for (auto sr_it = send_recv_t::begin(); sr_it != send_recv_t::end();
        ++sr_it) {
     auto ncs_it = node_communications.begin_scheme(*sr_it);
     auto ncs_end = node_communications.end_scheme(*sr_it);
 
     transcode_node_to_global_dof_scheme(ncs_it, ncs_end, *sr_it);
   }
 
   dof_changed = true;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFSynchronizer::initScatterGatherCommunicationScheme() {
   AKANTU_DEBUG_IN();
 
   if (this->nb_proc == 1) {
     dof_changed = false;
     AKANTU_DEBUG_OUT();
     return;
   }
 
   UInt nb_dofs = dof_manager.getLocalSystemSize();
 
   this->root_dofs.clear();
   this->master_receive_dofs.clear();
 
   Array<UInt> dofs_to_send;
   for (UInt n = 0; n < nb_dofs; ++n) {
     if (dof_manager.isLocalOrMasterDOF(n)) {
       auto & receive_per_proc = master_receive_dofs[this->root];
       UInt global_dof = dof_manager.localToGlobalEquationNumber(n);
 
       root_dofs.push_back(n);
       receive_per_proc.push_back(global_dof);
       dofs_to_send.push_back(global_dof);
     }
   }
 
   if (this->rank == UInt(this->root)) {
     Array<UInt> nb_dof_per_proc(this->nb_proc);
     communicator.gather(dofs_to_send.size(), nb_dof_per_proc);
 
     std::vector<CommunicationRequest> requests;
     for (UInt p = 0; p < nb_proc; ++p) {
       if (p == UInt(this->root))
         continue;
 
       auto & receive_per_proc = master_receive_dofs[p];
       receive_per_proc.resize(nb_dof_per_proc(p));
       if (nb_dof_per_proc(p) != 0)
         requests.push_back(communicator.asyncReceive(
             receive_per_proc, p,
             Tag::genTag(p, 0, Tag::_GATHER_INITIALIZATION, this->hash_id)));
     }
 
     communicator.waitAll(requests);
     communicator.freeCommunicationRequest(requests);
   } else {
     communicator.gather(dofs_to_send.size(), this->root);
     AKANTU_DEBUG(dblDebug, "I have " << nb_dofs << " dofs ("
                                      << dofs_to_send.size()
                                      << " to send to master proc");
 
     if (dofs_to_send.size() != 0)
       communicator.send(dofs_to_send, this->root,
                         Tag::genTag(this->rank, 0, Tag::_GATHER_INITIALIZATION,
                                     this->hash_id));
   }
 
   dof_changed = false;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFSynchronizer::hasChanged() {
   communicator.allReduce(dof_changed, SynchronizerOperation::_lor);
   return dof_changed;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFSynchronizer::onNodesAdded(const Array<UInt> & nodes_list) {
   auto dof_ids = dof_manager.getDOFIDs();
 
   const auto & node_synchronizer = dof_manager.getMesh().getNodeSynchronizer();
   const auto & node_communications = node_synchronizer.getCommunications();
 
   std::set<UInt> relevant_nodes;
   std::map<UInt, std::vector<UInt>> nodes_per_proc[2];
   for (auto sr_it = send_recv_t::begin(); sr_it != send_recv_t::end();
        ++sr_it) {
     auto sit = node_communications.begin_scheme(*sr_it);
     auto send = node_communications.end_scheme(*sr_it);
 
     for (; sit != send; ++sit) {
       auto proc = sit->first;
       const auto & scheme = sit->second;
       for (auto node : nodes_list) {
         if (scheme.find(node) == UInt(-1))
           continue;
         relevant_nodes.insert(node);
         nodes_per_proc[*sr_it][proc].push_back(node);
       }
     }
   }
 
   std::map<UInt, std::vector<UInt>> dofs_per_proc[2];
   for (auto & dof_id : dof_ids) {
     const auto & associated_nodes = dof_manager.getDOFsAssociatedNodes(dof_id);
     const auto & local_equation_numbers =
         dof_manager.getEquationsNumbers(dof_id);
 
     for (auto tuple : zip(associated_nodes, local_equation_numbers)) {
       UInt assoc_node;
       UInt local_eq_num;
       std::tie(assoc_node, local_eq_num) = tuple;
 
       for (auto sr_it = send_recv_t::begin(); sr_it != send_recv_t::end();
            ++sr_it) {
         for (auto & pair : nodes_per_proc[*sr_it]) {
           if (std::find(pair.second.end(), pair.second.end(), assoc_node) !=
               pair.second.end()) {
             dofs_per_proc[*sr_it][pair.first].push_back(local_eq_num);
           }
         }
       }
     }
   }
 
   for (auto sr_it = send_recv_t::begin(); sr_it != send_recv_t::end();
            ++sr_it) {
     for (auto & pair : dofs_per_proc[*sr_it]) {
       std::sort(pair.second.begin(), pair.second.end(),
                 [this] (UInt la, UInt lb) -> bool {
                   UInt ga = dof_manager.localToGlobalEquationNumber(la);
                   UInt gb = dof_manager.localToGlobalEquationNumber(lb);
                   return ga < gb;
                 });
 
       auto & scheme = communications.getScheme(pair.first, *sr_it);
       for(auto leq : pair.second) {
         scheme.push_back(leq);
       }
     }
   }
   dof_changed = true;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/synchronizer/dof_synchronizer_inline_impl.cc b/src/synchronizer/dof_synchronizer_inline_impl.cc
index 94a786155..182863dfc 100644
--- a/src/synchronizer/dof_synchronizer_inline_impl.cc
+++ b/src/synchronizer/dof_synchronizer_inline_impl.cc
@@ -1,300 +1,300 @@
 /**
  * @file   dof_synchronizer_inline_impl.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 17 2011
  * @date last modification: Tue Dec 09 2014
  *
  * @brief  DOFSynchronizer inline implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "communication_buffer.hh"
 #include "data_accessor.hh"
 #include "dof_manager_default.hh"
 #include "dof_synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 #include <map>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_DOF_SYNCHRONIZER_INLINE_IMPL_CC__
 #define __AKANTU_DOF_SYNCHRONIZER_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void DOFSynchronizer::gather(const Array<T> & to_gather, Array<T> & gathered) {
   if (this->hasChanged())
     initScatterGatherCommunicationScheme();
 
   AKANTU_DEBUG_ASSERT(this->rank == UInt(this->root),
                       "This function cannot be called on a slave processor");
   AKANTU_DEBUG_ASSERT(to_gather.size() ==
                           this->dof_manager.getLocalSystemSize(),
                       "The array to gather does not have the correct size");
   AKANTU_DEBUG_ASSERT(gathered.size() == this->dof_manager.getSystemSize(),
                       "The gathered array does not have the correct size");
 
   if (this->nb_proc == 1) {
     gathered.copy(to_gather, true);
 
     AKANTU_DEBUG_OUT();
     return;
   }
 
   std::map<UInt, CommunicationBuffer> buffers;
   std::vector<CommunicationRequest> requests;
   for (UInt p = 0; p < this->nb_proc; ++p) {
     if (p == UInt(this->root))
       continue;
 
     auto receive_it = this->master_receive_dofs.find(p);
     AKANTU_DEBUG_ASSERT(receive_it != this->master_receive_dofs.end(),
                         "Could not find the receive list for dofs of proc "
                             << p);
     const Array<UInt> & receive_dofs = receive_it->second;
     if (receive_dofs.size() == 0)
       continue;
 
     CommunicationBuffer & buffer = buffers[p];
 
     buffer.resize(receive_dofs.size() * to_gather.getNbComponent() *
                   sizeof(T));
 
     AKANTU_DEBUG_INFO(
         "Preparing to receive data for "
         << receive_dofs.size() << " dofs from processor " << p << " "
         << Tag::genTag(p, this->root, Tag::_GATHER, this->hash_id));
 
     requests.push_back(communicator.asyncReceive(
         buffer, p, Tag::genTag(p, this->root, Tag::_GATHER, this->hash_id)));
   }
 
   auto data_gathered_it = gathered.begin(to_gather.getNbComponent());
 
   { // copy master data
     auto data_to_gather_it = to_gather.begin(to_gather.getNbComponent());
     for (auto local_dof : root_dofs) {
       UInt global_dof = dof_manager.localToGlobalEquationNumber(local_dof);
 
       Vector<T> dof_data_gathered = data_gathered_it[global_dof];
       Vector<T> dof_data_to_gather = data_to_gather_it[local_dof];
       dof_data_gathered = dof_data_to_gather;
     }
   }
 
-  UInt rr = UInt(-1);
+  auto rr = UInt(-1);
   while ((rr = communicator.waitAny(requests)) != UInt(-1)) {
     CommunicationRequest & request = requests[rr];
     UInt sender = request.getSource();
 
     AKANTU_DEBUG_ASSERT(this->master_receive_dofs.find(sender) !=
                                 this->master_receive_dofs.end() &&
                             buffers.find(sender) != buffers.end(),
                         "Missing infos concerning proc " << sender);
 
     const Array<UInt> & receive_dofs =
         this->master_receive_dofs.find(sender)->second;
     CommunicationBuffer & buffer = buffers[sender];
 
     for (auto global_dof : receive_dofs) {
       Vector<T> dof_data = data_gathered_it[global_dof];
       buffer >> dof_data;
     }
 
     requests.erase(requests.begin() + rr);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> void DOFSynchronizer::gather(const Array<T> & to_gather) {
   AKANTU_DEBUG_IN();
 
   if (this->hasChanged())
     initScatterGatherCommunicationScheme();
 
   AKANTU_DEBUG_ASSERT(this->rank != UInt(this->root),
                       "This function cannot be called on the root processor");
   AKANTU_DEBUG_ASSERT(to_gather.size() ==
                           this->dof_manager.getLocalSystemSize(),
                       "The array to gather does not have the correct size");
 
   if (this->root_dofs.size() == 0) {
     AKANTU_DEBUG_OUT();
     return;
   }
   CommunicationBuffer buffer(this->root_dofs.size() *
                              to_gather.getNbComponent() * sizeof(T));
 
   auto data_it = to_gather.begin(to_gather.getNbComponent());
   for (auto dof : this->root_dofs) {
     Vector<T> data = data_it[dof];
     buffer << data;
   }
 
   AKANTU_DEBUG_INFO("Gathering data for "
                     << to_gather.size() << " dofs on processor "
                     << this->root << " "
                     << Tag::genTag(this->rank, 0, Tag::_GATHER, this->hash_id));
 
   communicator.send(buffer, this->root,
                     Tag::genTag(this->rank, 0, Tag::_GATHER, this->hash_id));
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void DOFSynchronizer::scatter(Array<T> & scattered,
                               const Array<T> & to_scatter) {
   AKANTU_DEBUG_IN();
 
   if (this->hasChanged())
     initScatterGatherCommunicationScheme();
   AKANTU_DEBUG_ASSERT(this->rank == UInt(this->root),
                       "This function cannot be called on a slave processor");
   AKANTU_DEBUG_ASSERT(scattered.size() ==
                           this->dof_manager.getLocalSystemSize(),
                       "The scattered array does not have the correct size");
   AKANTU_DEBUG_ASSERT(to_scatter.size() == this->dof_manager.getSystemSize(),
                       "The array to scatter does not have the correct size");
 
   if (this->nb_proc == 1) {
     scattered.copy(to_scatter, true);
     AKANTU_DEBUG_OUT();
     return;
   }
 
   std::map<UInt, CommunicationBuffer> buffers;
   std::vector<CommunicationRequest> requests;
 
   for (UInt p = 0; p < nb_proc; ++p) {
     auto data_to_scatter_it = to_scatter.begin(to_scatter.getNbComponent());
 
     if (p == this->rank) {
       auto data_scattered_it = scattered.begin(to_scatter.getNbComponent());
 
       // copy the data for the local processor
       for (auto local_dof : root_dofs) {
         auto global_dof = dof_manager.localToGlobalEquationNumber(local_dof);
 
         Vector<T> dof_data_to_scatter = data_to_scatter_it[global_dof];
         Vector<T> dof_data_scattered = data_scattered_it[local_dof];
         dof_data_scattered = dof_data_to_scatter;
       }
 
       continue;
     }
 
     const Array<UInt> & receive_dofs =
         this->master_receive_dofs.find(p)->second;
 
     // prepare the send buffer
     CommunicationBuffer & buffer = buffers[p];
     buffer.resize(receive_dofs.size() * scattered.getNbComponent() *
                   sizeof(T));
 
     // pack the data
     for (auto global_dof : receive_dofs) {
       Vector<T> dof_data_to_scatter = data_to_scatter_it[global_dof];
       buffer << dof_data_to_scatter;
     }
 
     // send the data
     requests.push_back(communicator.asyncSend(
         buffer, p, Tag::genTag(p, 0, Tag::_SCATTER, this->hash_id)));
   }
 
   // wait a clean communications
   communicator.waitAll(requests);
   communicator.freeCommunicationRequest(requests);
 
   // synchronize slave and ghost nodes
   synchronize(scattered);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> void DOFSynchronizer::scatter(Array<T> & scattered) {
   AKANTU_DEBUG_IN();
 
   if (this->hasChanged())
     this->initScatterGatherCommunicationScheme();
   AKANTU_DEBUG_ASSERT(this->rank != UInt(this->root),
                       "This function cannot be called on the root processor");
   AKANTU_DEBUG_ASSERT(scattered.size() ==
                           this->dof_manager.getLocalSystemSize(),
                       "The scattered array does not have the correct size");
 
   // prepare the data
   auto data_scattered_it = scattered.begin(scattered.getNbComponent());
   CommunicationBuffer buffer(this->root_dofs.size() *
                              scattered.getNbComponent() * sizeof(T));
 
   // receive the data
   communicator.receive(
       buffer, this->root,
       Tag::genTag(this->rank, 0, Tag::_SCATTER, this->hash_id));
 
   // unpack the data
   for (auto local_dof : root_dofs) {
     Vector<T> dof_data_scattered = data_scattered_it[local_dof];
     buffer >> dof_data_scattered;
   }
 
   // synchronize the ghosts
   synchronize(scattered);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void DOFSynchronizer::synchronize(Array<T> & dof_values_to_synchronize) const {
   AKANTU_DEBUG_IN();
 
   SimpleUIntDataAccessor<T> data_accessor(dof_values_to_synchronize,
                                           _gst_whatever);
   this->synchronizeOnce(data_accessor, _gst_whatever);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <class> class Op, typename T>
 void DOFSynchronizer::reduceSynchronize(Array<T> & dof_vector) const {
   AKANTU_DEBUG_IN();
 
   ReduceUIntDataAccessor<Op, T> data_accessor(dof_vector, _gst_whatever);
   this->synchronizeOnce(data_accessor, _gst_whatever);
 
   AKANTU_DEBUG_OUT();
 }
 
 } // akantu
 
 #endif /* __AKANTU_DOF_SYNCHRONIZER_INLINE_IMPL_CC__ */
diff --git a/src/synchronizer/node_info_per_processor.cc b/src/synchronizer/node_info_per_processor.cc
index d3b38b482..2e97b07ff 100644
--- a/src/synchronizer/node_info_per_processor.cc
+++ b/src/synchronizer/node_info_per_processor.cc
@@ -1,500 +1,500 @@
 /**
  * @file   node_info_per_processor.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Fri Mar 11 15:49:43 2016
  *
  * @brief
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "node_info_per_processor.hh"
 #include "node_group.hh"
 #include "node_synchronizer.hh"
 #include "communicator.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NodeInfoPerProc::NodeInfoPerProc(NodeSynchronizer & synchronizer,
                                  UInt message_cnt, UInt root)
     : MeshAccessor(synchronizer.getMesh()), synchronizer(synchronizer),
       comm(synchronizer.getCommunicator()), rank(comm.whoAmI()),
       nb_proc(comm.getNbProc()), root(root), mesh(synchronizer.getMesh()),
       spatial_dimension(synchronizer.getMesh().getSpatialDimension()),
       message_count(message_cnt) {}
 
 /* -------------------------------------------------------------------------- */
 template <class CommunicationBuffer>
 void NodeInfoPerProc::fillNodeGroupsFromBuffer(CommunicationBuffer & buffer) {
   AKANTU_DEBUG_IN();
 
   std::vector<std::vector<std::string>> node_to_group;
 
   buffer >> node_to_group;
 
   AKANTU_DEBUG_ASSERT(node_to_group.size() == mesh.getNbGlobalNodes(),
                       "Not the good amount of nodes where transmitted");
 
   const auto & global_nodes = mesh.getGlobalNodesIds();
 
   auto nbegin = global_nodes.begin();
   auto nit = global_nodes.begin();
   auto nend = global_nodes.end();
   for (; nit != nend; ++nit) {
-    std::vector<std::string>::iterator it = node_to_group[*nit].begin();
-    std::vector<std::string>::iterator end = node_to_group[*nit].end();
+    auto it = node_to_group[*nit].begin();
+    auto end = node_to_group[*nit].end();
 
     for (; it != end; ++it) {
       mesh.getNodeGroup(*it).add(nit - nbegin, false);
     }
   }
 
   GroupManager::const_node_group_iterator ngi = mesh.node_group_begin();
   GroupManager::const_node_group_iterator nge = mesh.node_group_end();
   for (; ngi != nge; ++ngi) {
     NodeGroup & ng = *(ngi->second);
     ng.optimize();
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeInfoPerProc::fillNodesType() {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes = mesh.getNbNodes();
   Array<NodeType> & nodes_type = this->getNodesType();
 
   Array<UInt> nodes_set(nb_nodes);
   nodes_set.set(0);
 
   enum NodeSet {
     NORMAL_SET = 1,
     GHOST_SET = 2,
   };
 
   Array<bool> already_seen(nb_nodes, 1, false);
 
   for (UInt g = _not_ghost; g <= _ghost; ++g) {
-    GhostType gt = (GhostType)g;
+    auto gt = (GhostType)g;
     UInt set = NORMAL_SET;
     if (gt == _ghost)
       set = GHOST_SET;
 
     already_seen.set(false);
     Mesh::type_iterator it =
         mesh.firstType(_all_dimensions, gt, _ek_not_defined);
     Mesh::type_iterator end =
         mesh.lastType(_all_dimensions, gt, _ek_not_defined);
     for (; it != end; ++it) {
       ElementType type = *it;
 
       UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
       UInt nb_element = mesh.getNbElement(type, gt);
       Array<UInt>::const_vector_iterator conn_it =
           mesh.getConnectivity(type, gt).begin(nb_nodes_per_element);
 
       for (UInt e = 0; e < nb_element; ++e, ++conn_it) {
         const Vector<UInt> & conn = *conn_it;
         for (UInt n = 0; n < nb_nodes_per_element; ++n) {
           AKANTU_DEBUG_ASSERT(conn(n) < nb_nodes,
                               "Node " << conn(n)
                                       << " bigger than number of nodes "
                                       << nb_nodes);
           if (!already_seen(conn(n))) {
             nodes_set(conn(n)) += set;
             already_seen(conn(n)) = true;
           }
         }
       }
     }
   }
 
   for (UInt i = 0; i < nb_nodes; ++i) {
     if (nodes_set(i) == NORMAL_SET)
       nodes_type(i) = _nt_normal;
     else if (nodes_set(i) == GHOST_SET)
       nodes_type(i) = _nt_pure_gost;
     else if (nodes_set(i) == (GHOST_SET + NORMAL_SET))
       nodes_type(i) = _nt_master;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeInfoPerProc::fillCommunicationScheme(const Array<UInt> & master_info) {
   AKANTU_DEBUG_IN();
 
   Communications<UInt> & communications =
       this->synchronizer.getCommunications();
 
   { // send schemes
     auto it = master_info.begin_reinterpret(2, master_info.size() / 2);
     auto end = master_info.end_reinterpret(2, master_info.size() / 2);
 
     std::map<UInt, Array<UInt>> send_array_per_proc;
 
     for (; it != end; ++it) {
       const Vector<UInt> & send_info = *it;
 
       send_array_per_proc[send_info(0)].push_back(send_info(1));
     }
 
     for (auto & send_schemes : send_array_per_proc) {
       auto & scheme = communications.createSendScheme(send_schemes.first);
 
       auto & sends = send_schemes.second;
       std::sort(sends.begin(), sends.end());
       std::transform(sends.begin(), sends.end(), sends.begin(),
                      [this](UInt g) -> UInt { return mesh.getNodeLocalId(g); });
       scheme.copy(sends);
     }
   }
 
   { // receive schemes
     const Array<NodeType> & nodes_type = this->getNodesType();
 
     std::map<UInt, Array<UInt>> recv_array_per_proc;
 
     UInt node = 0;
     for (auto & node_type : nodes_type) {
       if (Int(node_type) >= 0) {
         recv_array_per_proc[node_type].push_back(mesh.getNodeGlobalId(node));
       }
       ++node;
     }
 
     for (auto & recv_schemes : recv_array_per_proc) {
       auto & scheme = communications.createRecvScheme(recv_schemes.first);
 
       auto & recvs = recv_schemes.second;
       std::sort(recvs.begin(), recvs.end());
       std::transform(recvs.begin(), recvs.end(), recvs.begin(),
                      [this](UInt g) -> UInt { return mesh.getNodeLocalId(g); });
 
       scheme.copy(recvs);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 MasterNodeInfoPerProc::MasterNodeInfoPerProc(NodeSynchronizer & synchronizer,
                                              UInt message_cnt, UInt root)
     : NodeInfoPerProc(synchronizer, message_cnt, root) {
   UInt nb_global_nodes = this->mesh.getNbGlobalNodes();
   this->comm.broadcast(nb_global_nodes, this->root);
 }
 
 /* -------------------------------------------------------------------------- */
 void MasterNodeInfoPerProc::synchronizeNodes() {
   this->nodes_per_proc.resize(nb_proc);
   this->nb_nodes_per_proc.resize(nb_proc);
 
   Array<Real> local_nodes(0, spatial_dimension);
   Array<Real> & nodes = this->getNodes();
 
   for (UInt p = 0; p < nb_proc; ++p) {
     UInt nb_nodes = 0;
     //      UInt * buffer;
     Array<Real> * nodes_to_send;
 
     Array<UInt> & nodespp = nodes_per_proc[p];
     if (p != root) {
       nodes_to_send = new Array<Real>(0, spatial_dimension);
       AKANTU_DEBUG_INFO("Receiving number of nodes from proc "
                         << p << " " << Tag::genTag(p, 0, Tag::_NB_NODES));
       comm.receive(nb_nodes, p, Tag::genTag(p, 0, Tag::_NB_NODES));
       nodespp.resize(nb_nodes);
       this->nb_nodes_per_proc(p) = nb_nodes;
 
       AKANTU_DEBUG_INFO("Receiving list of nodes from proc "
                         << p << " " << Tag::genTag(p, 0, Tag::_NODES));
       comm.receive(nodespp, p, Tag::genTag(p, 0, Tag::_NODES));
     } else {
       Array<UInt> & local_ids = this->getNodesGlobalIds();
       this->nb_nodes_per_proc(p) = local_ids.size();
       nodespp.copy(local_ids);
       nodes_to_send = &local_nodes;
     }
 
     Array<UInt>::const_scalar_iterator it = nodespp.begin();
     Array<UInt>::const_scalar_iterator end = nodespp.end();
     /// get the coordinates for the selected nodes
     for (; it != end; ++it) {
       Vector<Real> coord(nodes.storage() + spatial_dimension * *it,
                          spatial_dimension);
       nodes_to_send->push_back(coord);
     }
 
     if (p != root) { /// send them for distant processors
       AKANTU_DEBUG_INFO("Sending coordinates to proc "
                         << p << " "
                         << Tag::genTag(this->rank, 0, Tag::_COORDINATES));
       comm.send(*nodes_to_send, p,
                 Tag::genTag(this->rank, 0, Tag::_COORDINATES));
       delete nodes_to_send;
     }
   }
 
   /// construct the local nodes coordinates
   nodes.copy(local_nodes);
 }
 
 /* -------------------------------------------------------------------------- */
 void MasterNodeInfoPerProc::synchronizeTypes() {
   //           <global_id,     <proc, local_id> >
   std::multimap<UInt, std::pair<UInt, UInt>> nodes_to_proc;
   std::vector<Array<NodeType>> nodes_type_per_proc(nb_proc);
 
   // arrays containing pairs of (proc, node)
   std::vector<Array<UInt>> nodes_to_send_per_proc(nb_proc);
   for (UInt p = 0; p < nb_proc; ++p) {
     nodes_type_per_proc[p].resize(nb_nodes_per_proc(p));
   }
 
   this->fillNodesType();
 
   for (UInt p = 0; p < nb_proc; ++p) {
     auto & nodes_types = nodes_type_per_proc[p];
     if (p != root) {
       AKANTU_DEBUG_INFO(
           "Receiving first nodes types from proc "
           << p << " "
           << Tag::genTag(this->rank, this->message_count, Tag::_NODES_TYPE));
       comm.receive(nodes_types, p, Tag::genTag(p, 0, Tag::_NODES_TYPE));
     } else {
       nodes_types.copy(this->getNodesType());
     }
 
     // stack all processors claiming to be master for a node
     for (UInt local_node = 0; local_node < nb_nodes_per_proc(p); ++local_node) {
       if (nodes_types(local_node) == _nt_master) {
         UInt global_node = nodes_per_proc[p](local_node);
         nodes_to_proc.insert(std::make_pair(global_node, std::make_pair(p, local_node)));
       }
     }
   }
 
   for (UInt i = 0; i < mesh.getNbGlobalNodes(); ++i) {
     auto it_range = nodes_to_proc.equal_range(i);
     if (it_range.first == nodes_to_proc.end() || it_range.first->first != i)
       continue;
 
     // pick the first processor out of the multi-map as the actual master
     UInt master_proc = (it_range.first)->second.first;
     for (auto it_node = it_range.first; it_node != it_range.second; ++it_node) {
       UInt proc = it_node->second.first;
       UInt node = it_node->second.second;
       if (proc != master_proc) {
         // store the info on all the slaves for a given master
         nodes_type_per_proc[proc](node) = NodeType(master_proc);
         nodes_to_send_per_proc[master_proc].push_back(proc);
         nodes_to_send_per_proc[master_proc].push_back(i);
       }
     }
   }
 
 
   std::vector<CommunicationRequest> requests_send_type;
   std::vector<CommunicationRequest> requests_send_master_info;
   for (UInt p = 0; p < nb_proc; ++p) {
     if (p != root) {
       AKANTU_DEBUG_INFO("Sending nodes types to proc "
                         << p << " "
                         << Tag::genTag(this->rank, 0, Tag::_NODES_TYPE));
       requests_send_type.push_back(
           comm.asyncSend(nodes_type_per_proc[p], p,
                          Tag::genTag(this->rank, 0, Tag::_NODES_TYPE)));
 
       auto & nodes_to_send = nodes_to_send_per_proc[p];
 
       /// push back an element to avoid a send of size 0
       nodes_to_send.push_back(-1);
 
       AKANTU_DEBUG_INFO("Sending nodes master info to proc "
                         << p << " "
                         << Tag::genTag(this->rank, 1, Tag::_NODES_TYPE));
       requests_send_master_info.push_back(
           comm.asyncSend(nodes_to_send, p,
                          Tag::genTag(this->rank, 1, Tag::_NODES_TYPE)));
     } else {
       this->getNodesType().copy(nodes_type_per_proc[p]);
 
       this->fillCommunicationScheme(nodes_to_send_per_proc[root]);
     }
   }
 
   comm.waitAll(requests_send_type);
   comm.freeCommunicationRequest(requests_send_type);
   requests_send_type.clear();
 
   comm.waitAll(requests_send_master_info);
   comm.freeCommunicationRequest(requests_send_master_info);
 }
 
 /* -------------------------------------------------------------------------- */
 void MasterNodeInfoPerProc::synchronizeGroups() {
   AKANTU_DEBUG_IN();
 
   UInt nb_total_nodes = mesh.getNbGlobalNodes();
 
   DynamicCommunicationBuffer buffer;
 
-  typedef std::vector<std::vector<std::string>> NodeToGroup;
+  using NodeToGroup = std::vector<std::vector<std::string>>;
   NodeToGroup node_to_group;
   node_to_group.resize(nb_total_nodes);
 
   GroupManager::const_node_group_iterator ngi = mesh.node_group_begin();
   GroupManager::const_node_group_iterator nge = mesh.node_group_end();
   for (; ngi != nge; ++ngi) {
     NodeGroup & ng = *(ngi->second);
 
     std::string name = ngi->first;
 
     NodeGroup::const_node_iterator nit = ng.begin();
     NodeGroup::const_node_iterator nend = ng.end();
     for (; nit != nend; ++nit) {
       node_to_group[*nit].push_back(name);
     }
 
     nit = ng.begin();
     if (nit != nend)
       ng.empty();
   }
 
   buffer << node_to_group;
 
   std::vector<CommunicationRequest> requests;
   for (UInt p = 0; p < nb_proc; ++p) {
     if (p == this->rank)
       continue;
     AKANTU_DEBUG_INFO("Sending node groups to proc "
                       << p << " "
                       << Tag::genTag(this->rank, p, Tag::_NODE_GROUP));
     requests.push_back(comm.asyncSend(
         buffer, p, Tag::genTag(this->rank, p, Tag::_NODE_GROUP)));
   }
 
   this->fillNodeGroupsFromBuffer(buffer);
 
   comm.waitAll(requests);
   comm.freeCommunicationRequest(requests);
   requests.clear();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 SlaveNodeInfoPerProc::SlaveNodeInfoPerProc(NodeSynchronizer & synchronizer,
                                            UInt message_cnt, UInt root)
     : NodeInfoPerProc(synchronizer, message_cnt, root) {
   UInt nb_global_nodes = 0;
   comm.broadcast(nb_global_nodes, root);
   this->setNbGlobalNodes(nb_global_nodes);
 }
 
 /* -------------------------------------------------------------------------- */
 void SlaveNodeInfoPerProc::synchronizeNodes() {
   AKANTU_DEBUG_INFO("Sending list of nodes to proc "
                     << root << " " << Tag::genTag(this->rank, 0, Tag::_NB_NODES)
                     << " " << Tag::genTag(this->rank, 0, Tag::_NODES));
   Array<UInt> & local_ids = this->getNodesGlobalIds();
   Array<Real> & nodes = this->getNodes();
 
   UInt nb_nodes = local_ids.size();
   comm.send(nb_nodes, root, Tag::genTag(this->rank, 0, Tag::_NB_NODES));
   comm.send(local_ids, root, Tag::genTag(this->rank, 0, Tag::_NODES));
 
   /* --------<<<<-COORDINATES---------------------------------------------- */
   nodes.resize(nb_nodes);
   AKANTU_DEBUG_INFO("Receiving coordinates from proc "
                     << root << " " << Tag::genTag(root, 0, Tag::_COORDINATES));
   comm.receive(nodes, root, Tag::genTag(root, 0, Tag::_COORDINATES));
 }
 
 /* -------------------------------------------------------------------------- */
 void SlaveNodeInfoPerProc::synchronizeTypes() {
   this->fillNodesType();
 
   Array<NodeType> & nodes_types = this->getNodesType();
 
   AKANTU_DEBUG_INFO("Sending first nodes types to proc "
                     << root << ""
                     << Tag::genTag(this->rank, 0, Tag::_NODES_TYPE));
   comm.send(nodes_types, root, Tag::genTag(this->rank, 0, Tag::_NODES_TYPE));
 
   AKANTU_DEBUG_INFO("Receiving nodes types from proc "
                     << root << " " << Tag::genTag(root, 0, Tag::_NODES_TYPE));
   comm.receive(nodes_types, root, Tag::genTag(root, 0, Tag::_NODES_TYPE));
 
 
   AKANTU_DEBUG_INFO("Receiving nodes master info from proc "
                     << root << " " << Tag::genTag(root, 1, Tag::_NODES_TYPE));
   CommunicationStatus status;
   comm.probe<UInt>(root, Tag::genTag(root, 1, Tag::_NODES_TYPE), status);
 
   Array<UInt> nodes_master_info(status.size());
 
   comm.receive(nodes_master_info, root,
                Tag::genTag(root, 1, Tag::_NODES_TYPE));
 
   nodes_master_info.resize(nodes_master_info.size() - 1);
 
   this->fillCommunicationScheme(nodes_master_info);
 }
 
 /* -------------------------------------------------------------------------- */
 void SlaveNodeInfoPerProc::synchronizeGroups() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Receiving node groups from proc "
                     << root << " "
                     << Tag::genTag(root, this->rank, Tag::_NODE_GROUP));
 
   CommunicationStatus status;
   comm.probe<char>(root, Tag::genTag(root, this->rank, Tag::_NODE_GROUP),
                    status);
 
   CommunicationBuffer buffer(status.size());
   comm.receive(buffer, root, Tag::genTag(root, this->rank, Tag::_NODE_GROUP));
 
   this->fillNodeGroupsFromBuffer(buffer);
 
   AKANTU_DEBUG_OUT();
 }
 
 } // akantu
diff --git a/src/synchronizer/synchronizer.hh b/src/synchronizer/synchronizer.hh
index 2fad3305a..e910b07aa 100644
--- a/src/synchronizer/synchronizer.hh
+++ b/src/synchronizer/synchronizer.hh
@@ -1,130 +1,130 @@
 /**
  * @file   synchronizer.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Dec 10 2015
  *
  * @brief  Common interface for synchronizers
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "aka_memory.hh"
 #include "communicator.hh"
 /* -------------------------------------------------------------------------- */
 #include <map>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SYNCHRONIZER_HH__
 #define __AKANTU_SYNCHRONIZER_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* Base class for synchronizers                                               */
 /* -------------------------------------------------------------------------- */
 class Synchronizer : protected Memory {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   Synchronizer(const ID & id = "synchronizer", MemoryID memory_id = 0,
                const Communicator & comm =
                    Communicator::getStaticCommunicator());
 
-  ~Synchronizer() override{};
+  ~Synchronizer() override = default;
 
   virtual void printself(__attribute__((unused)) std::ostream & stream,
                          __attribute__((unused)) int indent = 0) const {};
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// synchronize ghosts without state
   template <class DataAccessor>
   void synchronizeOnce(DataAccessor & data_accessor,
                        const SynchronizationTag & tag) const;
 
   /// synchronize ghosts
   template <class DataAccessor>
   void synchronize(DataAccessor & data_accessor,
                    const SynchronizationTag & tag);
 
   /// asynchronous synchronization of ghosts
   template <class DataAccessor>
   void asynchronousSynchronize(const DataAccessor & data_accessor,
                                const SynchronizationTag & tag);
 
   /// wait end of asynchronous synchronization of ghosts
   template <class DataAccessor>
   void waitEndSynchronize(DataAccessor & data_accessor,
                           const SynchronizationTag & tag);
 
   /// compute buffer size for a given tag and data accessor
   template <class DataAccessor>
   void computeBufferSize(const DataAccessor & data_accessor,
                          const SynchronizationTag & tag);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   AKANTU_GET_MACRO(Communicator, communicator, const Communicator &);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// id of the synchronizer
   ID id;
 
   /// hashed version of the id
   int hash_id;
 
   /// message counter per tag
   std::map<SynchronizationTag, UInt> tag_counter;
 
   /// the static memory instance
   const Communicator & communicator;
 
   /// nb processors in the communicator
   UInt nb_proc;
 
   /// rank in the communicator
   UInt rank;
 };
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream,
                                  const Synchronizer & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // akantu
 
 #include "synchronizer_tmpl.hh"
 
 #endif /* __AKANTU_SYNCHRONIZER_HH__ */
diff --git a/src/synchronizer/synchronizer_impl.hh b/src/synchronizer/synchronizer_impl.hh
index 1b28e3583..ec4516b84 100644
--- a/src/synchronizer/synchronizer_impl.hh
+++ b/src/synchronizer/synchronizer_impl.hh
@@ -1,122 +1,122 @@
 /**
  * @file   synchronizer_impl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Aug 24 13:26:47 2016
  *
  * @brief  Implementation of the generic part of synchronizers
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "communications.hh"
 #include "synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SYNCHRONIZER_IMPL_HH__
 #define __AKANTU_SYNCHRONIZER_IMPL_HH__
 
 namespace akantu {
 
 template <class Entity> class SynchronizerImpl : public Synchronizer {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   SynchronizerImpl(
       const ID & id = "synchronizer", MemoryID memory_id = 0,
       const Communicator & comm = Communicator::getStaticCommunicator());
 
-  ~SynchronizerImpl() override{};
+  ~SynchronizerImpl() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// synchronous synchronization without state
   virtual void synchronizeOnceImpl(DataAccessor<Entity> & data_accessor,
                                    const SynchronizationTag & tag) const;
 
   /// asynchronous synchronization of ghosts
   virtual void
   asynchronousSynchronizeImpl(const DataAccessor<Entity> & data_accessor,
                               const SynchronizationTag & tag);
 
   /// wait end of asynchronous synchronization of ghosts
   virtual void waitEndSynchronizeImpl(DataAccessor<Entity> & data_accessor,
                                       const SynchronizationTag & tag);
 
   /// compute all buffer sizes
   virtual void computeAllBufferSizes(const DataAccessor<Entity> & data_accessor);
 
   /// compute buffer size for a given tag and data accessor
   virtual void computeBufferSizeImpl(const DataAccessor<Entity> & data_accessor,
                                      const SynchronizationTag & tag);
 
   /* ------------------------------------------------------------------------ */
   virtual void synchronizeImpl(DataAccessor<Entity> & data_accessor,
                                const SynchronizationTag & tag) {
     this->asynchronousSynchronizeImpl(data_accessor, tag);
     this->waitEndSynchronizeImpl(data_accessor, tag);
   }
 
   /* ------------------------------------------------------------------------ */
   /// extract the elements that have a true predicate from in_synchronizer and
   /// store them in the current synchronizer
   template <typename Pred>
   void split(SynchronizerImpl & in_synchronizer, Pred && pred);
 
   /// update schemes in a synchronizer
   template <typename Updater>
   void updateSchemes(Updater && scheme_updater);
 
 
   /* ------------------------------------------------------------------------ */
   virtual UInt sanityCheckDataSize(const Array<Entity> & elements,
                                    const SynchronizationTag & tag) const;
   virtual void
   packSanityCheckData(CommunicationDescriptor<Entity> & comm_desc) const;
   virtual void
   unpackSanityCheckData(CommunicationDescriptor<Entity> & comm_desc) const;
 
 public:
   AKANTU_GET_MACRO(Communications, communications, const Communications<Entity> &);
 
 protected:
   AKANTU_GET_MACRO_NOT_CONST(Communications, communications, Communications<Entity> &);
 
   virtual Int getRank(const Entity & entity) const = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// information on the communications
   Communications<Entity> communications;
 };
 
 } // akantu
 
 #include "synchronizer_impl_tmpl.hh"
 
 
 #endif /* __AKANTU_SYNCHRONIZER_IMPL_HH__ */
diff --git a/src/synchronizer/synchronizer_registry.cc b/src/synchronizer/synchronizer_registry.cc
index 38c318c89..715cb4f31 100644
--- a/src/synchronizer/synchronizer_registry.cc
+++ b/src/synchronizer/synchronizer_registry.cc
@@ -1,139 +1,139 @@
 /**
  * @file   synchronizer_registry.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Jun 16 2011
  * @date last modification: Thu Oct 08 2015
  *
  * @brief  Registry of synchronizers
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "synchronizer_registry.hh"
 #include "synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
-SynchronizerRegistry::SynchronizerRegistry() : data_accessor(nullptr) {
+SynchronizerRegistry::SynchronizerRegistry() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 SynchronizerRegistry::~SynchronizerRegistry() {
   AKANTU_DEBUG_IN();
 
   synchronizers.clear();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SynchronizerRegistry::registerDataAccessor(
     DataAccessorBase & data_accessor) {
   this->data_accessor = &data_accessor;
 }
 
 /* -------------------------------------------------------------------------- */
 void SynchronizerRegistry::synchronize(SynchronizationTag tag) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(data_accessor != nullptr, "No data accessor set.");
 
   std::pair<Tag2Sync::iterator, Tag2Sync::iterator> range =
       synchronizers.equal_range(tag);
 
-  for (Tag2Sync::iterator it = range.first; it != range.second; ++it) {
+  for (auto it = range.first; it != range.second; ++it) {
     it->second->synchronize(*data_accessor, tag);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SynchronizerRegistry::asynchronousSynchronize(SynchronizationTag tag) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(data_accessor != nullptr, "No data accessor set.");
 
   std::pair<Tag2Sync::iterator, Tag2Sync::iterator> range =
       synchronizers.equal_range(tag);
 
-  for (Tag2Sync::iterator it = range.first; it != range.second; ++it) {
+  for (auto it = range.first; it != range.second; ++it) {
     (*it).second->asynchronousSynchronize(*data_accessor, tag);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SynchronizerRegistry::waitEndSynchronize(SynchronizationTag tag) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(data_accessor != nullptr, "No data accessor set.");
 
   std::pair<Tag2Sync::iterator, Tag2Sync::iterator> range =
       synchronizers.equal_range(tag);
 
-  for (Tag2Sync::iterator it = range.first; it != range.second; ++it) {
+  for (auto it = range.first; it != range.second; ++it) {
     (*it).second->waitEndSynchronize(*data_accessor, tag);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SynchronizerRegistry::registerSynchronizer(Synchronizer & synchronizer,
                                                 SynchronizationTag tag) {
   AKANTU_DEBUG_IN();
 
   synchronizers.insert(
       std::pair<SynchronizationTag, Synchronizer *>(tag, &synchronizer));
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SynchronizerRegistry::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "SynchronizerRegistry [" << std::endl;
   Tag2Sync::const_iterator it;
   for (it = synchronizers.begin(); it != synchronizers.end(); it++) {
     stream << space << " + Synchronizers for tag " << (*it).first << " ["
            << std::endl;
     (*it).second->printself(stream, indent + 1);
     stream << space << " ]" << std::endl;
   }
 
   stream << space << "]" << std::endl;
 }
 
 } // akantu
diff --git a/src/synchronizer/synchronizer_registry.hh b/src/synchronizer/synchronizer_registry.hh
index 8db7313cb..107255250 100644
--- a/src/synchronizer/synchronizer_registry.hh
+++ b/src/synchronizer/synchronizer_registry.hh
@@ -1,107 +1,107 @@
 /**
  * @file   synchronizer_registry.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Dec 09 2014
  *
  * @brief  Registry of synchronizers
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 /* -------------------------------------------------------------------------- */
 #include <map>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SYNCHRONIZER_REGISTRY_HH__
 #define __AKANTU_SYNCHRONIZER_REGISTRY_HH__
 
 namespace akantu {
 class DataAccessorBase;
 class Synchronizer;
 }
 
 namespace akantu {
 
 class SynchronizerRegistry {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   SynchronizerRegistry();
   virtual ~SynchronizerRegistry();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// synchronize operation
   void synchronize(SynchronizationTag tag);
 
   /// asynchronous synchronization
   void asynchronousSynchronize(SynchronizationTag tag);
 
   /// wait end of asynchronous synchronization
   void waitEndSynchronize(SynchronizationTag tag);
 
   /// register a new synchronization
   void registerSynchronizer(Synchronizer & synchronizer,
                             SynchronizationTag tag);
 
   /// function to print the containt of the class
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
   /// Register a different data accessor.
   void registerDataAccessor(DataAccessorBase & data_accessor);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   typedef std::multimap<SynchronizationTag, Synchronizer *> Tag2Sync;
   /// list of registered synchronization
   Tag2Sync synchronizers;
 
   /// data accessor that will permit to do the pack/unpack things
-  DataAccessorBase * data_accessor;
+  DataAccessorBase * data_accessor{nullptr};
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 // #include "synchronizer_registry_inline_impl.cc"
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream,
                                  const SynchronizerRegistry & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // akantu
 
 #endif /* __AKANTU_SYNCHRONIZER_REGISTRY_HH__ */
diff --git a/test/test_mesh_utils/test_buildfacets/test_buildfacets_triangle_3.cc b/test/test_mesh_utils/test_buildfacets/test_buildfacets_triangle_3.cc
index 06e5b546c..f072da165 100644
--- a/test/test_mesh_utils/test_buildfacets/test_buildfacets_triangle_3.cc
+++ b/test/test_mesh_utils/test_buildfacets/test_buildfacets_triangle_3.cc
@@ -1,116 +1,113 @@
 /**
  * @file   test_buildfacets_triangle_3.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  *
  * @date creation: Fri Sep 18 2015
  * @date last modification: Sat Sep 19 2015
  *
  * @brief  Test to check the building of the facets. Mesh with triangles
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 #include <limits>
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   initialize(argc, argv);
 
   const UInt spatial_dimension = 2;
   const ElementType type = _triangle_3;
 
   Mesh mesh(spatial_dimension);
   mesh.read("triangle_3.msh");
-  Mesh & mesh_facets = mesh.initMeshFacets("mesh_facets");
-
-  MeshUtils::buildAllFacets(mesh, mesh_facets);
+  const auto & mesh_facets = mesh.initMeshFacets("mesh_facets");
 
   const ElementType type_facet = mesh.getFacetType(type);
   const ElementType type_subfacet = mesh.getFacetType(type_facet);
 
   /* ------------------------------------------------------------------------ */
   /* Element to Subelement testing                                            */
   /* ------------------------------------------------------------------------ */
-
   const Array< std::vector<Element> > & el_to_subel2 = mesh_facets.getElementToSubelement(type_facet);
   const Array< std::vector<Element> > & el_to_subel1 = mesh_facets.getElementToSubelement(type_subfacet);
 
 
   std::cout << "ElementToSubelement2" << std::endl;
   for (UInt i = 0; i < el_to_subel2.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << el_to_subel2(i)[j].type << " " << el_to_subel2(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement1" << std::endl;
   for (UInt i = 0; i < el_to_subel1.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel1(i).size(); ++j){
       std::cout << el_to_subel1(i)[j].type << " " << el_to_subel1(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   /* ------------------------------------------------------------------------ */
   /* Subelement to Element testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array<Element> & subel_to_el2 = mesh_facets.getSubelementToElement(type);
   const Array<Element> & subel_to_el1 = mesh_facets.getSubelementToElement(type_facet);
 
   std::cout << " " << std::endl;
   std::cout << "SubelementToElement2" << std::endl;
   for (UInt i = 0; i < subel_to_el2.size(); ++i) {
     std::cout << type << " " << i << " connected to ";
     for (UInt j = 0; j < 3; ++j){
       std::cout << subel_to_el2(i, j).type << " " << subel_to_el2(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement1" << std::endl;
   for (UInt i = 0; i < subel_to_el1.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << subel_to_el1(i, j).type << " " << subel_to_el1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/third-party/iohelper/src/CMakeLists.txt b/third-party/iohelper/src/CMakeLists.txt
index 72d46cdbc..b857c8629 100644
--- a/third-party/iohelper/src/CMakeLists.txt
+++ b/third-party/iohelper/src/CMakeLists.txt
@@ -1,115 +1,115 @@
 #===============================================================================
 # @file   CMakeLists.txt
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 #
 # @date creation: Thu Nov 24 2011
 # @date last modification: Wed Nov 13 2013
 #
 # @brief  main iohelper configuration
 #
 # @section LICENSE
 #
 # Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # IOHelper 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.
 #
 # IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 #===============================================================================
 # List of source files
 #===============================================================================
 set(IOHELPER_COMMON_SRC
   dumper_lammps.cc
   dumper.cc
 #  dumper_restart.cc
 #  src/reader_C_wrapper.cpp
 #  src/reader.cpp
 #  src/dumper_C_wrapper.cpp
   dumper_paraview.cc
   dumper_text.cc
   paraview_helper.cc
 #  src/reader_restart.cpp
 )
 
 set(IOHELPER_COMMON_HEADERS
   field_inline_impl.cc
   dumper_restart.hh
   field_interface.hh
   visitor.hh
   field.hh
   variable_inline_impl.cc
   variable_interface.hh
   variable.hh
   container_array.hh
   dumper_paraview.hh
   dumper_text.hh
   paraview_helper.tcc
   iohelper_common.hh
   io_helper.hh
   dumper.hh
   file_manager.hh
   paraview_helper.hh
   dumper_C_wrapper.h
   base64.hh
 #  src/reader_C_wrapper.h
 #  src/reader.hh
   dumper_lammps.hh
   base64_reader.hh
 #  src/reader_restart.hh
 )
 
 #===============================================================================
 # Library creation rule
 #===============================================================================
 include_directories(
   ${IOHELPER_SOURCE_DIR}/src
   )
 
 add_library(iohelper ${IOHELPER_COMMON_SRC})
 
 # link library with other libraries
 target_link_libraries (iohelper ${IOHELPER_EXTERNAL_LIBS})
 set_target_properties(iohelper PROPERTIES PUBLIC_HEADER "${IOHELPER_COMMON_HEADERS}")
-
+set_property(TARGET iohelper PROPERTY CXX_STANDARD 11)
 
 export(TARGETS iohelper
   FILE "${CMAKE_BINARY_DIR}/IOHelperLibraryDepends.cmake")
 export(PACKAGE IOHelper)
 
 #===============================================================================
 # Install rules
 #===============================================================================
 # Tweak for when IOHelper is a subproject
 if(NOT IOHELPER_TARGETS_EXPORT)
   set(IOHELPER_TARGETS_EXPORT IOHelperLibraryDepends)
 endif()
 
 install(TARGETS iohelper
   EXPORT ${IOHELPER_TARGETS_EXPORT}
   ARCHIVE DESTINATION lib COMPONENT lib
   LIBRARY DESTINATION lib COMPONENT lib
   RUNTIME DESTINATION lib COMPONENT lib
   PUBLIC_HEADER DESTINATION include/iohelper COMPONENT dev
   )
 
 # Install the export set for use with the install-tree
 if("${IOHELPER_TARGETS_EXPORT}" STREQUAL "IOHelperLibraryDepends")
   install(EXPORT IOHelperLibraryDepends DESTINATION  lib/iohelper
     COMPONENT dev)
 endif()
 
 
 set(IOHELPER_INCLUDE_DIRS ${IOHelper_SOURCE_DIR}/src CACHE INTERNAL "Internal include directorie to link with IOHelper as a subproject")
diff --git a/third-party/iohelper/src/base64.hh b/third-party/iohelper/src/base64.hh
index 1aca7fdcf..5d7e480f2 100644
--- a/third-party/iohelper/src/base64.hh
+++ b/third-party/iohelper/src/base64.hh
@@ -1,439 +1,439 @@
 /**
  * @file   base64.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Mar 11 2010
  * @date last modification: Wed Nov 13 2013
  *
  * @brief  header for base64 handling
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * IOHelper 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.
  *
  * IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __IOHLPER_BASE64_H__
 #define __IOHLPER_BASE64_H__
 /* -------------------------------------------------------------------------- */
 #include <vector>
 #include "file_manager.hh"
 #ifdef USING_ZLIB
 #include <zlib.h>
 #endif
 /* -------------------------------------------------------------------------- */
 
 __BEGIN_IOHELPER__
 
 #if defined(__INTEL_COMPILER)
 #pragma warning ( push )
 /// remark #981: operands are evaluated in unspecified order
 #pragma warning ( disable : 981 )
 #endif //defined(__INTEL_COMPILER)
 
 /** Class that allow to push binary data
     in base64 format to any file.
     This class is mainly used by the paraview helper
     to create binary XML VTK files.
     The conversion is a 4/3 size conversion. */
 
 
 class Base64Writer{
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
  public:
 
   Base64Writer(File & f);
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 
   //! for any packet in base64 a little header is used that is an int = nbBytes written
   void WriteHeader();
   //! this is used to allocate the memory for the final count of bytes
   void CreateHeader();
   //! when all stream is ready buffer is sent to file
   inline void DumpToFile();
   //! empty temporary buffer
   void ClearBuffer();
 
   template<typename T>
   inline void push(T c);
 
   //! notify that we don't want to add any data. Closing the current buffer
   void finish();
   //! decode 3 bytes from 4 Base64 bytes (4/3 ratio)
   int Decode(char c0,char c1,char c2,char c3,
 	      char * r0,char * r1,char * r2);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
  private:
   //! push to file a Byte
   inline void PushByteInBase64(unsigned char c);
 
   //! when 4 bytes are ready they are dumped to buffer by this function
   inline void dumpToBuffer();
   //! initialisation process
   inline void InitBase64Stuff();
   //! primitive function to push bytes to file
   //void ochar(int c);
 
   //! decoding table
   char dtable[256];
   //! encoding table
   char etable[256];
   //! stage in conversion process(1,2 or 3)
   int n;
   //! used to code/decode
   unsigned char igroup[3],ogroup[4];
 
   //!unused
   int linelength;
   //!unused
   //  int maxlinelength;
 
   //! LM file descriptor
   File & file;
 
   //! buffer to cache data
   std::vector<unsigned char> buffer;
   //! number of bytes written to buffer
   long nbBytes;
   //! for rewind need o floating index
   int start;
 
 };
 
 /* -------------------------------------------------------------------------- */
 template<typename T> inline void Base64Writer::push(T t) {
-  unsigned char * c = (unsigned char*) & t;
+  auto * c = (unsigned char *)&t;
   for (unsigned int i = 0 ; i < sizeof(T) ; ++i){
     this->PushByteInBase64(c[i]);
   }
 }
 
-template<> inline void Base64Writer::push<char *>(char * str) { 
-  unsigned char * c = (unsigned char*)str;
+template<> inline void Base64Writer::push<char *>(char * str) {
+  auto * c = (unsigned char *)str;
   for (unsigned int i = 0 ; i < 512 ; ++i){
     if (str[i] == '\0') break;
     PushByteInBase64(c[i]);
   }
 }
 
 inline void Base64Writer::InitBase64Stuff(){
   memset(dtable,0xFF,256);
   memset(etable,0xFF,256);
 
   for(int i=0;i<9;i++){
     etable[i]= (char)('A'+i);
     dtable[0+etable[i]] = (char)i;
     etable[i+9]= (char)('J'+i);
     dtable[(0+etable[i+9])] = (char)(i+9);
     etable[26+i]= (char)('a'+i);
     dtable[(0+etable[26+i])] = (char)(i + 26);
     etable[(26+i+9)]= (char)('j'+i);
     dtable[(0+etable[26+i+9])] = (char)(i + 26 + 9);
   }
   for(int i= 0;i<8;i++){
     etable[i+18]= (char)('S'+i);
     dtable[(0+etable[i+18])] = (char)(i + 18);
     etable[26+i+18]= (char)('s'+i);
     dtable[(0+etable[26+i+18])] = (char)(26 + i + 18);
   }
   for(char i= 0;i<10;i++){
     etable[52+i]= (char)('0'+i);
     dtable[(0+etable[i+52])] = (char)(i + 52);
   }
   etable[62]= '+';
   dtable[0+etable[62]] = 62;
   etable[63]= '/';
   dtable[0+etable[63]] = 63;
 }
 /* -------------------------------------------------------------------------- */
 
 
 // inline void Base64Writer::PushIntegerInBase64(int d){
 //   //  DUMP("pushing " << d << " ( n = " << n << " )",DBG_ALL);
 //   unsigned char * c = (unsigned char*)&d;
 //   for (unsigned int i = 0 ; i < sizeof(int) ; ++i){
 //     PushByteInBase64(c[i]);
 //   }
 // }
 // /* -------------------------------------------------------------------------- */
 
 
 // inline void Base64Writer::PushStrInBase64(char * str){
 //   unsigned char * c = (unsigned char*)str;
 //   for (unsigned int i = 0 ; i < 512 ; ++i){
 //     if (str[i] == '\0') break;
 //     PushByteInBase64(c[i]);
 //   }
 // }
 // /* -------------------------------------------------------------------------- */
 
 
 // inline void Base64Writer::PushDoubleInBase64(double d){
 //   //  DUMP("pushing double " << d << " as " << sizeof(double) << " bytes",DBG_ALL);
 
 //   unsigned char * c = (unsigned char*)&d;
 //   for (unsigned int i = 0 ; i < sizeof(double) ; ++i){
 //     PushByteInBase64(c[i]);
 //   }
 // }
 // /* -------------------------------------------------------------------------- */
 
 
 inline void Base64Writer::PushByteInBase64(unsigned char c){
   //initialise les blocs
   //  DUMP("pushing byte " << (int) c << " at position " << n,DBG_ALL);
 
   if (n == 0){
     igroup[0]= 0;
     igroup[1]= 0;
     igroup[2]= 0;
   }
   igroup[n]= c;
   ++n;
 
   if(n == 3){
     dumpToBuffer();
   }
   nbBytes += 1;
 }
 /* -------------------------------------------------------------------------- */
 
 
 inline void Base64Writer::finish(){
   if (n == 0) return;
 
   dumpToBuffer();
   linelength = 0;
 }
 
 /* -------------------------------------------------------------------------- */
 
 
 inline void Base64Writer::dumpToBuffer(){
   if(n<3){
     igroup[2]= 0;
     if(n<2){
       igroup[1]= 0;
     }
   }
 
   //DUMP("premiere partie en base 64 : " << (igroup[0]>>2),DBG_ALL);
   int index = igroup[0]>>2;
   ogroup[0]= etable[index];
   //DUMP("deuxieme partie en base 64 : " << (((igroup[0]&3)<<4)|(igroup[1]>>4)),DBG_ALL);
   index = ((igroup[0]&3)<<4)|(igroup[1]>>4);
   ogroup[1]= etable[index];
   //DUMP("troisieme partie en base 64 : " << (((igroup[1]&0xF)<<2)|(igroup[2]>>6)),DBG_ALL);
   index = ((igroup[1]&0xF)<<2)|(igroup[2]>>6);
   ogroup[2]= etable[index];
   //DUMP("last partie en base 64 : " << (igroup[2]&0x3F),DBG_ALL);
   index = igroup[2]&0x3F;
   ogroup[3]= etable[index];
 
   if(n<3){
     ogroup[3]= '=';
     if(n<2){
       ogroup[2]= '=';
     }
   }
 
   for(int i= 0;i<4;i++){
     //DUMP("dumped to buffer " << ogroup[i],DBG_ALL);
     if (start == -1)
       buffer.push_back(ogroup[i]);
     else{
       buffer[start] = ogroup[i];
       ++start;
     }
   }
 
   //remise a zero du compteur
     n = 0;
 }
 
 /* inline void Base64Writer::ochar(int c) */
 /* { */
 /*   if(file.dumpchar(c)==-1){ */
 /*       FATAL("error while writing to file (in compressed mode) ! no more space ?"); */
 /*   } */
 /*   linelength++; */
 /* } */
 
 /* -------------------------------------------------------------------------- */
 
 
 inline int Base64Writer::Decode(char c0,char c1,char c2,char c3,
 				 char * r0,char * r1,char * r2){
 
   unsigned char d0, d1, d2, d3;
 
   d0 = dtable[0+c0];
   d1 = dtable[0+c1];
   d2 = dtable[0+c2];
   d3 = dtable[0+c3];
 
 
 
   //DUMP("d0 " << (int)d0 << " d1 " << (int)d1 << " d2 " << (int)d2 << " d3 " << (int)d3,DBG_ALL);
 
   // Decode the 3 bytes
 
   *r0 = (char)(((d0 << 2) & 0xFC) | ((d1 >> 4) & 0x03));
   *r1 = (char)(((d1 << 4) & 0xF0) | ((d2 >> 2) & 0x0F));
   *r2 = (char)(((d2 << 6) & 0xC0) | ((d3 >> 0) & 0x3F));
 
   //DUMP("r0 " << (int)*r0 << " r1 " << (int)*r1 << " r2 " << (int)*r2,DBG_ALL);
 
   // Return the number of bytes actually decoded
 
   if (c2 == '=')
     {
     return 1;
     }
   if (c3 == '=')
     {
     return 2;
     }
   return 3;
 }
 /* -------------------------------------------------------------------------- */
 
 
 
 inline void Base64Writer::WriteHeader(){
 
   //  if (bflag == BASE64){
   //  char byteC[8];
   char byte[6];
 
   finish();
 
 /*   long save_offset; */
 
 
 /*   save_offset = file.tell(); */
 /*   file.seek(header_offset,SEEK_SET); */
 /*   //reread the 4 bytes precedently written */
 
 /*   file.read(byteC,sizeof(char),4); */
 
 /*   DUMP("la chaine saisie " << byteC[0] << " " << byteC[1] << " " << byteC[2] << " " << byteC[3]); */
 /*   b64.Decode(byteC[0],byteC[0],byteC[0],byteC[0], */
 /* 	     byte,byte+1,byte+2); */
   //DUMP("la chaine saisie " << buffer[0] << " " << buffer[1] << " " << buffer[2] << " " << buffer[3],DBG_ALL);
 
   Decode(buffer[0], buffer[0], buffer[0], buffer[0],
 	 byte, byte + 1, byte + 2);
 
 /*   file.read(byteC+4,sizeof(char),4); */
 /*   DUMP("la chaine saisie " << byteC[4] << " " << byteC[5] << " " << byteC[6] << " " << byteC[7]); */
 /*   int nb = b64.Decode(byteC[4],byteC[5],byteC[6],byteC[7], */
 /* 		      byte+3,byte+4,byte+5); */
 
   //DUMP("la chaine saisie " << buffer[4] << " " << buffer[5] << " " << buffer[6] << " " << buffer[7],DBG_ALL);
   int nb = Decode(buffer[4],buffer[5],buffer[6],buffer[7],
 		  byte + 3,byte + 4,byte + 5);
 
 
 /*   //je me replace au debut du header */
 /*   file.seek(header_offset,SEEK_SET); */
 /*   //je viens de relire 6 octets */
 /*   //les quatres premiers seulement sont a changer */
 
 
   //DUMP("placing number of writen bytes : " << nbBytes << " " << buffer.size(),DBG_ALL);
 
   int temp = nbBytes;
   start = 0;
   push(temp);
   if (nb > 1)
     push(byte[4]);
   if (nb > 2)
     push(byte[5]);
 
   start = -1;
   nbBytes = temp;
 
   finish();
   DumpToFile();
 }
 /* -------------------------------------------------------------------------- */
 
 
 inline void Base64Writer::DumpToFile(){
   file.write((char*)&buffer[0],buffer.size());
 }
 /* -------------------------------------------------------------------------- */
 
 
 inline void Base64Writer::ClearBuffer(){
   buffer.clear();
   nbBytes = 0;
 }
 /* -------------------------------------------------------------------------- */
 
 
 inline void Base64Writer::CreateHeader(){
   ClearBuffer();
   push<int>(0);
 }
 
 /* -------------------------------------------------------------------------- */
 
 inline Base64Writer::Base64Writer(File & f):
   file(f){
   linelength = 0;
   InitBase64Stuff();
   n = 0;
   start = -1;
   igroup[0] = 0;
   igroup[1] = 0;
   igroup[2] = 0;
   ogroup[0] = 0;
   ogroup[1] = 0;
   ogroup[2] = 0;
   ogroup[3] = 0;
 }
 /* -------------------------------------------------------------------------- */
 
 #if defined(__INTEL_COMPILER)
 /// remark #981: operands are evaluated in unspecified order
 #pragma warning ( pop )
 #endif //defined(__INTEL_COMPILER)
 
 
 
 
 __END_IOHELPER__
 
 
 
 #endif /* __IOHLPER_BASE64_H__ */
 
diff --git a/third-party/iohelper/src/container_array.hh b/third-party/iohelper/src/container_array.hh
index cd1e96559..f409d672e 100644
--- a/third-party/iohelper/src/container_array.hh
+++ b/third-party/iohelper/src/container_array.hh
@@ -1,138 +1,138 @@
 /**
  * @file   container_array.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *
  * @date creation: Fri Oct 12 2012
  * @date last modification: Tue Feb 05 2013
  *
  * @brief  container array header
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * IOHelper 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.
  *
  * IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __IOHELPER_CONTAINER_ARRAY_HH__
 #define __IOHELPER_CONTAINER_ARRAY_HH__
 /* -------------------------------------------------------------------------- */
 
 __BEGIN_IOHELPER__
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 class ContainerArray {
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
 
   class iterator: public ::iohelper::iterator<T, iterator> {
   public:
 
     iterator(T * ptr, UInt dimension, UInt increment, const ElemType & el_type = MAX_ELEM_TYPE){
       this->ptr = ptr;
       this->increment = increment;
       this->dimension = dimension;
       this->el_type = el_type;
     };
 
     bool operator!=(const iterator & it) const {
       return it.ptr != this->ptr;
     };
 
     iterator & operator++() { ptr += increment; return *this; };
 
     IOHelperVector<T> operator*(){
        return IOHelperVector<T>(ptr, increment);
     };
 
     virtual ElemType element_type() { return el_type; }
     
   private:
 
     T * ptr;
     UInt increment;
     UInt dimension;
     ElemType el_type;
   };
 
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
 
   ContainerArray(T * data, UInt dimension, UInt size, UInt stride=1,ElemType el_type = MAX_ELEM_TYPE){
     this->data = data;
     this->dimension = dimension;
     if (this->data == NULL) this->_size = 0;
     else this->_size = size;
     this->stride = stride;
     this->el_type = el_type;
   };
 
-  virtual ~ContainerArray(){};
+  virtual ~ContainerArray() = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 
   iterator begin(){
     return iterator(data,dimension,stride*dimension,el_type);
   };
   iterator end(){
     return iterator(data+_size*dimension*stride,dimension,stride*dimension);
   };
 
   UInt getDim(){return dimension;};
   UInt size(){return _size;};
   bool isHomogeneous(){return true;};
 
   DataType getDataType() { return ::iohelper::getDataType<T>(); }
 
   const ElemType & getElemType() { return el_type;}
   void setElemType(const ElemType & type) { el_type = type;}
 
 public:
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
 
   T * data;
   UInt dimension;
   UInt stride;
   UInt _size;
   ElemType el_type;
 };
 
 /* -------------------------------------------------------------------------- */
 
 
 __END_IOHELPER__
 
 #endif /* __IOHELPER_ITERATOR_ARRAY_HH__ */
diff --git a/third-party/iohelper/src/dumper.hh b/third-party/iohelper/src/dumper.hh
index db8e438fc..e25a00724 100644
--- a/third-party/iohelper/src/dumper.hh
+++ b/third-party/iohelper/src/dumper.hh
@@ -1,327 +1,327 @@
 /**
  * @file   dumper.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Mar 11 2010
  * @date last modification: Wed Nov 13 2013
  *
  * @brief  dumper interface
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * IOHelper 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.
  *
  * IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __IOHELPER_DUMPER_H__
 #define __IOHELPER_DUMPER_H__
 /* -------------------------------------------------------------------------- */
 #include <map>
 #include <string>
 #include "iohelper_common.hh"
 #include "field_interface.hh"
 #include "field.hh"
 #include "variable_interface.hh"
 #include "variable.hh"
 #include "container_array.hh"
 /* -------------------------------------------------------------------------- */
 #include "visitor.hh"
 /* -------------------------------------------------------------------------- */
 
 #if !defined(_WIN32)
 #  define IOHELPER_DIRECTORY_SEPARATOR '/'
 #  define iohelper_mkdir(path, mode) mkdir(path, mode)
 #else
 #  define IOHELPER_DIRECTORY_SEPARATOR '\\'
 #  define iohelper_mkdir(path, mode) mkdir(path)
 #  include <io.h>
 #endif
 
 __BEGIN_IOHELPER__
 
 /** Class Dumper
  * Interface of a dumper
  */
 
 
 class Dumper {
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
  public:
   Dumper(const std::string prefix, const std::string & base_name);
   Dumper(const std::string prefix);
   virtual ~Dumper();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 
   //! dump to file
   virtual void dump(const std::string & name = std::string(),
                     UInt count = UInt(-1));
   //! initialisation of the dumper
   void init();
 
   //! TODO set comment
   void printNodeDataFields();
 
   //! dump of field information
   virtual void dumpDescription(__attribute__((unused)) const char descr_sep = ' ') {};
 
 public:
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 
   //! give vector with coordinates
   void setPoints(Real * points, int dimension, int nb, const std::string & name);
 
   //! set number of filtered elements
   void setNumberFilteredElements(int nb_filtered);
 
   //! give vector to connectivity
   virtual void setConnectivity(int * connectivity,
                                ElemType element_type,
                                UInt nb_elem,
                                int mode);
 
   //! give vector to per node data
   template <typename T>
   void addNodeDataField(const std::string & name,
                         T * data,
                         UInt dimension,
                         UInt size,
                         UInt stride=1);
 
   //! give a generic container as per node data
   template <typename Cont>
   void addNodeDataField(const std::string & name, Cont & data);
 
   //! give vector to per element data
   template <typename T>
   void addElemDataField(const std::string & name,
                         T * data,
                         ElemType elem_type,
                         UInt dimension,
                         UInt size,
                         UInt stride=1);
 
   //! give a generic container as per elem data
   template <typename Cont>
   void addElemDataField(const std::string & name, Cont & data);
 
   //! give a generic container as per node data
   template <typename VarType>
   void addVariable(const std::string & name, VarType & data);
 
   //! set mode
   virtual void setMode(int mode){ this->mode = mode; }
 
   //! set rank and world size params for parallel treatment
   void setParallelContext(int me, int wld_size, int root=0);
 
   //! set current value for the dump step
   void setDumpStep(int s) { dump_step = s; };
   Int getDumpStep() { return dump_step; };
   Int getDumpStepWidth() { return dump_step_width; };
 
   //! increment the dumpstep
   void incDumpStep(UInt s = 1) { dump_step += s; };
 
   void setPrefix(const std::string & prefix) {
     this->prefix = this->checkDirectoryName(prefix);
   };
 
   virtual void activateTimeDescFiles(Real delta_t, Real initial_time = 0.);
 
   void setTimeStep(Real delta_t) { this->time_step = delta_t; }
   void setCurrentTime(Real time) { this->current_time = time; }
 
   void setTimeDescriptionFileName(const std::string & name) { this->time_description_file_name = name; }
 
 protected:
   static std::string checkDirectoryName(std::string fname);
 
   std::string getFolder(const std::string & key);
 
   //! get file name with relative path
   std::string getRelativeFilePath(const std::string & name,
                                   const std::string & key,
                                   UInt proc);
 
   std::string getRelativeFilePath(const std::string & name,
                                   const std::string & key);
 
   std::string getAbsoluteFilePath(const std::string & name,
                                   const std::string & key,
                                   UInt proc);
 
   std::string getAbsoluteFilePath(const std::string & name,
                                   const std::string & key);
 
   std::string getFileName(const std::string & name,
                           const std::string & key,
                           UInt proc);
 
   std::string getFileName(const std::string & name,
                           const std::string & key);
 
   std::string getRelativeFolderPath(const std::string & folder);
   std::string getAbsoluteFolderPath(const std::string & folder);
 
   //! get base_name
   std::string getBaseName();
   void setBaseName(const std::string & name);
 
 
 public:
   enum DumpFlag {
     _df_no_flag = 0x0,
     _df_counter = 0x1,
     _df_proc_id = 0x2
   };
 
 protected:
   struct DumpOptions {
   private:
     std::string folder;
   public:
     std::string extension;
     DumpFlag dump_flags;
   public:
     void setFolder(const std::string & fld);
     const std::string & getFolder() const;
   };
 
   typedef std::map<std::string, DumpOptions> DumpOptionsMap;
 
 protected:
   void registerDumpOptions(const std::string & key,
                            const std::string & folder,
                            const std::string & extension,
                            DumpFlag dump_flag = _df_no_flag);
 
   DumpOptions & getDumpOptions(const std::string & key);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   std::string base_name;
   std::string prefix;
 
   DumpOptionsMap dump_options;
 
   UInt dump_step;
   UInt dump_step_width;
 
 protected:
   //! current delta t
   Real time_step;
 
   //! current time (dah!)
   Real current_time;
   //! if implemented the dumper will write a time description file
   bool write_time_desc_file;
 
   //! flag to produce zipped files
   UInt mode;
 
   typedef std::map<std::string, FieldInterface *>  field_map;
   typedef std::map<std::string, VariableInterface *>  variable_map;
 
   //! vector of additional per node data
   field_map per_node_data;
   //! vector of additional per element data
   field_map per_element_data;
   //! map of global variables
   variable_map global_data;
   //! for parallel runs is the total number of processors
   Int world_size;
   //! for parallel runs is rank of the process
   Int my_rank;
   //! fortran or C style connectivity indexing
   Int connectivity_mode;
   //! for parallel runs is rank of the process that should write the data to file
   Int root_rank;
   //! number of zeros to put to my_rank when creating files
   Int my_rank_width;
 
   //! file name for the time description files (if not set use the first base name)
   std::string time_description_file_name;
 };
 
 
 inline Dumper::DumpFlag operator|(const Dumper::DumpFlag & a, const Dumper::DumpFlag & b) {
-  Dumper::DumpFlag tmp = Dumper::DumpFlag(UInt(a) | UInt(b));
+  auto tmp = Dumper::DumpFlag(UInt(a) | UInt(b));
   return tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Dumper::addNodeDataField(const std::string & name, T * data,UInt dimension,
                               UInt size, UInt stride) {
 
-  ContainerArray<T> * cont = new ContainerArray<T>(data,dimension,size,stride);
+  auto * cont = new ContainerArray<T>(data, dimension, size, stride);
   addNodeDataField(name,*cont);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename Cont>
 void Dumper::addNodeDataField(const std::string & name, Cont & data){
-  Field<Cont> *test = new Field<Cont>(data,name);
+  auto * test = new Field<Cont>(data, name);
   per_node_data[name] = test;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename VarType>
 void Dumper::addVariable(const std::string & name, VarType & data) {
-  Variable<VarType> * vari = new Variable<VarType>(data,name);
+  auto * vari = new Variable<VarType>(data, name);
   global_data[name] = vari;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Dumper::addElemDataField(const std::string & name,
                               T * data,
                               ElemType elem_type,
                               UInt dimension,
                               UInt size, UInt stride){
 
-  ContainerArray<T> * cont = new ContainerArray<T>(data,dimension,size,stride);
+  auto * cont = new ContainerArray<T>(data, dimension, size, stride);
   cont->setElemType(elem_type);
   addElemDataField(name,*cont);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename Cont>
 void Dumper::addElemDataField(const std::string & name, Cont & data){
-  Field<Cont> *test = new Field<Cont>(data,name);
+  auto * test = new Field<Cont>(data, name);
   per_element_data[name] = test;
 }
 
 /* -------------------------------------------------------------------------- */
 
 __END_IOHELPER__
 
 #endif /* __IOHELPER_DUMPER_H__ */
diff --git a/third-party/iohelper/src/dumper_lammps.hh b/third-party/iohelper/src/dumper_lammps.hh
index 49bd11b7e..f2365eff3 100644
--- a/third-party/iohelper/src/dumper_lammps.hh
+++ b/third-party/iohelper/src/dumper_lammps.hh
@@ -1,144 +1,144 @@
 /**
  * @file   dumper_lammps.hh
  *
  * @author Till Junge <till.junge@epfl.ch>
  *
  * @date creation: Thu Nov 25 2010
  * @date last modification: Tue Jun 04 2013
  *
  * @brief  header for lammps dumper
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * IOHelper 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.
  *
  * IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __IOHELPER_DUMPER_LAMMPS_H__
 #define __IOHELPER_DUMPER_LAMMPS_H__
 /* -------------------------------------------------------------------------- */
 #include "dumper.hh"
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 
 __BEGIN_IOHELPER__
 
 enum LammpsAtomStyle {atomic, bond}; //please extend ad libidum
 
 template<LammpsAtomStyle style>
 class DumperLammps: public Dumper, public Visitor {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
+  DumperLammps(Real * bounds = nullptr, const std::string & prefix = "./");
 
-  DumperLammps(Real * bounds = NULL, const std::string & prefix = "./");
-
-  virtual ~DumperLammps(){}
+  ~DumperLammps() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   //! dump to file
-  void dump(const std::string & basename = std::string(), UInt count = UInt(-1));
-  void dumpHead(Real * bounds = NULL);
+  void dump(const std::string & basename = std::string(),
+            UInt count = UInt(-1)) override;
+  void dumpHead(Real * bounds = nullptr);
   template<typename T>
   void visitField(T & cont);
 
   void dumpFinalize();
   //! set mode for file creation : TEXT, BASE64, COMPRESSED
-  void setMode(int mode){Dumper::setMode(mode);}
+  void setMode(int mode) override { Dumper::setMode(mode); }
   void dumpAdd(int grain_id = 1);
   void setEmbeddedValue(__attribute__((unused)) const std::string & name,
 			__attribute__((unused)) int value){}
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   //position of where the number of atoms is printed;
   std::streampos nb_atom_position;
   //current number of atoms printed to the file
   unsigned long int curr_nb_atom;
   std::fstream lammps_dump_file;
   Real * bounds;
 
   //! flag to produce zipped files
   bool flag_compressed;
   //! current values
   int grain_id;
 };
 
 /* -------------------------------------------------------------------------- */
 template<>
 template <typename T>
 void DumperLammps<bond>::visitField(T & visited) {
 
   typename T::iterator it = visited.begin();
   typename T::iterator end = visited.end();
 
   UInt dim = visited.getDim();
 
   for (; it != end ; ++it) {
     this->lammps_dump_file << this->curr_nb_atom + 1 << " "
                            << this->grain_id + 2 << " 1 ";
     for (UInt i = 0 ;  i <  dim ; ++i) {
       this->lammps_dump_file << (*it)[i] << " ";
     }
     this->lammps_dump_file << std::endl;
     ++this->curr_nb_atom;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template<>
 template <typename T>
 void DumperLammps<atomic>::visitField(T & visited) {
 
   typename T::iterator it = visited.begin();
   typename T::iterator end = visited.end();
 
   UInt dim = visited.getDim();
 
   for (; it != end ; ++it) {
     this->lammps_dump_file << this->curr_nb_atom + 1 << " 1 ";
     for (UInt i = 0 ;  i <  dim ; ++i) {
       this->lammps_dump_file << (*it)[i] << " ";
     }
     this->lammps_dump_file << std::endl;
     ++this->curr_nb_atom;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 __END_IOHELPER__
 
 /* -------------------------------------------------------------------------- */
 #include "field_inline_impl.cc"
 /* -------------------------------------------------------------------------- */
 
 
 
 #endif /* __IOHELPER_DUMPER_LAMMPS_H__ */
diff --git a/third-party/iohelper/src/dumper_paraview.hh b/third-party/iohelper/src/dumper_paraview.hh
index 382f99a1c..560403da1 100644
--- a/third-party/iohelper/src/dumper_paraview.hh
+++ b/third-party/iohelper/src/dumper_paraview.hh
@@ -1,106 +1,108 @@
 /**
  * @file   dumper_paraview.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *
  * @date creation: Thu Mar 11 2010
  * @date last modification: Wed Jun 05 2013
  *
  * @brief  header for paraview dumper
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * IOHelper 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.
  *
  * IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __IOHELPER_DUMPER_PARAVIEW_H__
 #define __IOHELPER_DUMPER_PARAVIEW_H__
 /* -------------------------------------------------------------------------- */
 #include <map>
 #include <string>
 #include "dumper.hh"
 				    //#include "field.hh"
 #include "paraview_helper.hh"
 /* -------------------------------------------------------------------------- */
 
 __BEGIN_IOHELPER__
 
 /** Class DumperParaview
  * Implementation of a dumper to paraview vtu files
  */
 class DumperParaview : public Dumper {
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
 
   DumperParaview(const std::string & prefix = std::string("./"));
-  ~DumperParaview();
+  ~DumperParaview() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 
   //! dump to file
-  void dump(const std::string & name = std::string(""), UInt count = UInt(-1));
+  void dump(const std::string & name = std::string(""),
+            UInt count = UInt(-1)) override;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 
   //! set mode for file creation : TEXT, BASE64, COMPRESSED
-  void setMode(Int mode);
+  void setMode(Int mode) override;
 
   //! set the sub directory where to store the vtu files
   void setVTUSubDirectory(const std::string & sub);
 
   //! push a single field nodal with templated type
   template <typename T> void pushNodeField(ParaviewHelper & paraHelper, Field<T> & f);
   //! push a single element field with templated type
   template <typename T> void pushElemField(ParaviewHelper & paraHelper, Field<T> & f);
 
   //! give vector to connectivity
-  virtual void setConnectivity(int * connectivity, ElemType element_type, UInt nb_elem, int mode);
+  void setConnectivity(int * connectivity, ElemType element_type, UInt nb_elem,
+                       int mode) override;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 
 private:
 
   //! flag to produce zipped files
   bool flag_compressed;
 
   //! offset to compute connectivities
   Int mode_offset;
 
   //! subdirectory where to put the vtu files
   //std::string vtu_subdirectory; //became sub_folder in dumper.hh
   std::vector< std::pair<Real, std::string> > pvtu_file_names;
 };
 
 
 /* -------------------------------------------------------------------------- */
 
 __END_IOHELPER__
 
 
 
 #endif /* __IOHELPER_DUMPER_PARAVIEW_H__ */
diff --git a/third-party/iohelper/src/dumper_text.hh b/third-party/iohelper/src/dumper_text.hh
index 3f53e0b6d..5df40e265 100644
--- a/third-party/iohelper/src/dumper_text.hh
+++ b/third-party/iohelper/src/dumper_text.hh
@@ -1,196 +1,196 @@
 /**
  * @file   dumper_text.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Tue May 14 2013
  * @date last modification: Tue Sep 02 2014
  *
  * @brief  header for dumper text
  *
  * @section LICENSE
  *
  * Copyright (©) 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * IOHelper 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.
  *
  * IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __IOHLPER_DUMPER_TEXT_H__
 #define __IOHLPER_DUMPER_TEXT_H__
 /* -------------------------------------------------------------------------- */
 #include <map>
 #include <string>
 #include "dumper.hh"
 #include "file_manager.hh"
 /* -------------------------------------------------------------------------- */
 
 __BEGIN_IOHELPER__
 
 /** Class DumperText
  * Implementation of a dumper to text file
  */
 
 class DumperText : public Dumper, public Visitor {
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
   
 public:
   
   DumperText(TextDumpMode md = _tdm_space, 
 	     const std::string & prefix = "./",
 	     bool file_per_time_step = false);
-  virtual ~DumperText();
-  
+  ~DumperText() override;
+
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
-  
-  void dump(const std::string & name, UInt count);
+
+  void dump(const std::string & name, UInt count) override;
   void setEmbeddedValue(__attribute__((unused)) const std::string & name,
 			__attribute__((unused)) int value) {};
 
-  virtual void dumpDescription(const char descr_sep = ' ');
+  void dumpDescription(const char descr_sep = ' ') override;
   virtual void dumpFieldDescription(const char descr_sep = ' ');
   virtual void dumpTimeDescription(const char descr_sep = ' ');
   
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 
   void setDataSubDirectory(const std::string & name);
   std::string getDataSubDirectory();
   void setDataFileExtensions(const std::string & ext);
   void setDumpMode(const TextDumpMode & mode);
 
   void setPrecision(UInt prec) { this->precision = prec; };
  
   //! visitor system
   template <typename T> void visitField(T & visited);
   template <typename T> void visitVariable(T & visited);
   
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
 
   typedef std::map<std::string, File *> FileMap;
 
   /**
    * another base name so that you will never understand how iohelper
    * does what it does (now useless so it is commented but not removed
    * for historical reasons)
    */
   //  std::string yet_another_base_name;
 
   /// name of simulation, time and field description options
   std::string sim_name;
   std::string time_name;
   std::string field_name;
   char description_sep;
 
   /// this is a separator !!
   TextDumpMode dump_mode;
   char separator;
   char comment;
   UInt precision;
   bool file_per_time_step;
 
   bool is_first_dump;
 
   FileMap file_map;
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void DumperText::visitField(T & visited) {
   File file;
   
   if (this->file_per_time_step || this->is_first_dump) {
     file.open(this->getAbsoluteFilePath(this->getBaseName() + "_" + visited.getName(),
 					"data_fields"),
 	      std::fstream::out);
   }
   else {
     file.open(this->getAbsoluteFilePath(this->getBaseName() + "_" + visited.getName(),
 					"data_fields"),
 	      std::fstream::out | std::fstream::app);
   }
   file << std::scientific << std::setprecision(this->precision);
 
   typename T::iterator it = visited.begin();
   typename T::iterator end = visited.end();
   
   UInt dim = visited.getDim();
   
   for (; it != end; ++it) {
     for (UInt i=0; i<dim; ++i) {
       if (i != 0) 
 	file << this->separator;
       file << (*it)[i];
     }
     file << std::endl;
   }
 
   file << std::endl;  
   file.close();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void DumperText::visitVariable(T & visited) {
 
   // only root rank dumps variables
   if (this->my_rank != this->root_rank)
     return;
 
   const std::string & name = visited.getName();
 
-  FileMap::iterator it  = this->file_map.find(name);
-  FileMap::iterator end =  this->file_map.end();
+  auto it = this->file_map.find(name);
+  auto end = this->file_map.end();
 
   File * file;
   if (it == end) {
-    File * new_file = new File;
+    auto * new_file = new File;
     new_file->open(this->getAbsoluteFilePath(this->getBaseName() + "_" + name,
 					     "data_variables"), 
 		   std::fstream::out);
     this->file_map[name] = new_file;
     file = new_file;
     (*file) << std::scientific << std::setprecision(this->precision);
   }
   else {
     file = it->second;
   }
 
   UInt dim = visited.getDim();
   
   //  File file = it->second;
   for (UInt i=0; i<dim; ++i) {
     if (i != 0) 
       (*file) << this->separator;
     (*file) << (*visited)[i];
   }
   (*file) << std::endl;
   
 }
 
 /* -------------------------------------------------------------------------- */
 __END_IOHELPER__
 
 #endif /* __IOHLPER_DUMPER_TEXT_H__ */
diff --git a/third-party/iohelper/src/field.hh b/third-party/iohelper/src/field.hh
index 44565d2aa..4dc312ca0 100644
--- a/third-party/iohelper/src/field.hh
+++ b/third-party/iohelper/src/field.hh
@@ -1,139 +1,137 @@
 /**
  * @file   field.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Till Junge <till.junge@epfl.ch>
  *
  * @date creation: Thu Mar 11 2010
  * @date last modification: Tue Feb 05 2013
  *
  * @brief  description of field
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * IOHelper 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.
  *
  * IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __IOHELPER_FIELD_HH__
 #define __IOHELPER_FIELD_HH__
 /* -------------------------------------------------------------------------- */
 #include "field_interface.hh"
 // #include "paraview_helper.hh"
 // #include "dumper_lammps.hh"
 /* -------------------------------------------------------------------------- */
 
 __BEGIN_IOHELPER__
 
 template <class Cont>
 class Field : public FieldInterface {
 
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
-
-  typedef typename Cont::iterator iterator;
+  using iterator = typename Cont::iterator;
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-
-  Field(Cont & c, const std::string name):my_field(c), name(name){};
-  virtual ~Field(){};
+  Field(Cont & c, const std::string & name) : my_field(c), name(name){};
+  ~Field() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
 
   //! return true if the data is a constant size per element
-  inline bool isHomogeneous();
+  inline bool isHomogeneous() override;
   //! return the size per element (valid only if isHomogeneous is true)
-  inline UInt getDim();
+  inline UInt getDim() override;
   //! return the number of stored items (elements, nodes, etc...)
-  inline UInt size();
+  inline UInt size() override;
   //! return the description name of the container
-  inline std::string getName();
+  inline std::string getName() override;
 
   //! accept to be visited by a visitor
-  void accept(Visitor & v);
+  void accept(Visitor & v) override;
 
   //! begin method
   iterator begin(){return my_field.begin();}
   //! end method
   iterator end(){return my_field.end();}
 
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 
-  inline DataType getDataType() { return my_field.getDataType(); }
+  inline DataType getDataType() override { return my_field.getDataType(); }
 
 public:
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
 
   Cont & my_field;
 
   std::string name;
 };
 /* -------------------------------------------------------------------------- */
 
 template <class Cont>
 bool Field<Cont>::isHomogeneous(){
   return my_field.isHomogeneous();
 }
 
 /* -------------------------------------------------------------------------- */
 
 
 template <class Cont>
 UInt Field<Cont>::getDim(){
   return my_field.getDim();
 }
 
 /* -------------------------------------------------------------------------- */
 
 
 template <class Cont>
 std::string Field<Cont>::getName(){
   return name;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <class Cont>
 UInt Field<Cont>::size(){
   return my_field.size();
 }
 
 /* -------------------------------------------------------------------------- */
 
 
 
 
 __END_IOHELPER__
 
 
 #endif /* __IOHELPER_FIELD_HH__ */
diff --git a/third-party/iohelper/src/field_inline_impl.cc b/third-party/iohelper/src/field_inline_impl.cc
index 906873ea2..1cee7d51b 100644
--- a/third-party/iohelper/src/field_inline_impl.cc
+++ b/third-party/iohelper/src/field_inline_impl.cc
@@ -1,61 +1,61 @@
 /**
  * @file   field_inline_impl.cc
  *
  * @author Till Junge <till.junge@epfl.ch>
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *
  * @date creation: Wed Oct 31 2012
  * @date last modification: Tue Jun 04 2013
  *
  * @brief  inline implementation of dumper visitor
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * IOHelper 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.
  *
  * IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #include "paraview_helper.hh"
 #include "dumper_lammps.hh"
 #include "dumper_text.hh"
 
 #ifndef __IOHELPER_FIELD_INLINE_IMPL_CC__
 #define __IOHELPER_FIELD_INLINE_IMPL_CC__
 
 /* -------------------------------------------------------------------------- */
 __BEGIN_IOHELPER__
 
 template <class Cont>
 inline void Field<Cont>::accept(Visitor & v){
-  if (ParaviewHelper * ptr_ph = dynamic_cast<ParaviewHelper*>(&v)){
+  if (auto * ptr_ph = dynamic_cast<ParaviewHelper *>(&v)) {
     ptr_ph->visitField(*this);
-  } else if (iohelper::DumperLammps<iohelper::bond> * ptr_dlb = dynamic_cast<DumperLammps<bond>*>(&v)) {
+  } else if (auto * ptr_dlb = dynamic_cast<DumperLammps<bond> *>(&v)) {
     ptr_dlb->visitField(*this);
-  } else if (DumperLammps<iohelper::atomic> * ptr_dla = dynamic_cast<DumperLammps<atomic>*>(&v)){
+  } else if (auto * ptr_dla = dynamic_cast<DumperLammps<atomic> *>(&v)) {
     ptr_dla->visitField(*this);
-  } else if (DumperText * ptr_txt = dynamic_cast<DumperText*>(&v)){
+  } else if (auto * ptr_txt = dynamic_cast<DumperText *>(&v)) {
     ptr_txt->visitField(*this);
   }
 }
 
 __END_IOHELPER__
 /* -------------------------------------------------------------------------- */
 
 #endif /* __IOHELPER_FIELD_INLINE_IMPL_CC__ */
diff --git a/third-party/iohelper/src/field_interface.hh b/third-party/iohelper/src/field_interface.hh
index 9c2ed4650..083f5ecd3 100644
--- a/third-party/iohelper/src/field_interface.hh
+++ b/third-party/iohelper/src/field_interface.hh
@@ -1,84 +1,83 @@
 /**
  * @file   field_interface.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *
  * @date creation: Wed Dec 14 2011
  * @date last modification: Tue Feb 05 2013
  *
  * @brief  header for the field interface
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * IOHelper 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.
  *
  * IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __IOHELPER_CONTAINER_INTERFACE_HH__
 #define __IOHELPER_CONTAINER_INTERFACE_HH__
 /* -------------------------------------------------------------------------- */
 #include "visitor.hh"
 /* -------------------------------------------------------------------------- */
 
 
 __BEGIN_IOHELPER__
 
 class FieldInterface {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-
-  FieldInterface(){};
-  virtual ~FieldInterface(){};
+  FieldInterface() = default;
+  virtual ~FieldInterface() = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
 
   virtual void accept(Visitor & v) = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
 
   //! return true if the data is a constant size per element
   virtual bool isHomogeneous()=0;
   //! return the size per element (valid only if isHomogeneous is true)
   virtual UInt getDim()=0;
   //! return the description name of the container
   virtual std::string getName()=0;
   //! return the number of stored items (elements, nodes, etc...)
   virtual UInt size()=0;
 
   virtual DataType getDataType()=0;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
 
 };
 
 
 /* -------------------------------------------------------------------------- */
 
 __END_IOHELPER__
 
 #endif /* __IOHELPER_CONTAINER_INTERFACE_HH__ */
diff --git a/third-party/iohelper/src/file_manager.hh b/third-party/iohelper/src/file_manager.hh
index 38e09f379..16f56ab18 100644
--- a/third-party/iohelper/src/file_manager.hh
+++ b/third-party/iohelper/src/file_manager.hh
@@ -1,352 +1,351 @@
 /**
  * @file   file_manager.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *
  * @date creation: Thu Mar 11 2010
  * @date last modification: Thu Dec 06 2012
  *
  * @brief  file manager header
  *
  * @section LICENSE
  *
  * Copyright (©) 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * IOHelper 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.
  *
  * IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __IOHELPER_FILE_MANAGER_H__
 #define __IOHELPER_FILE_MANAGER_H__
 /* -------------------------------------------------------------------------- */
 #include <zlib.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <string>
 #include <iostream>
 #include <fstream>
 #include <typeinfo>
 #include "iohelper_common.hh"
 /* -------------------------------------------------------------------------- */
 
 __BEGIN_IOHELPER__
 
 template <class charT, class Traits=std::char_traits<charT> >
 class GZfstream : public std::basic_fstream<charT,Traits> {
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
 
   GZfstream();
   GZfstream(const std::string & fname,
 		     std::fstream::openmode mode = std::fstream::out,
 		     bool compr=false);
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 
   ///! opening methods
   inline void open(const std::string & name,
 		   std::fstream::openmode mode = std::fstream::out,
 		   bool compr= false);
   // inline void close();
 
   // // //! writing methods
   // template <typename T> GZfstream & operator << (const T & v);
   // inline GZfstream & operator << (std::ostream& (*op)(std::ostream&)){};
   // inline GZfstream & write(const void * buffer,std::streamsize n);
   // inline GZfstream & flush();
   // // //! reading methods
   // template <typename T> GZfstream & operator >> (T & v);
   // inline GZfstream & read(void * buffer,std::streamsize n);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 
 
  private:
 
 // #ifdef USING_ZLIB
 //   gzFile gzfile;
 // #endif
 
 //   int compressed;
 
 };
 
 
 // /* -------------------------------------------------------------------------- */
 
 
 template <class charT, class Traits>
  inline GZfstream<charT,Traits>::GZfstream():
    std::basic_fstream<charT,Traits>(){
 //     compressed = 0;
 // #ifdef USING_ZLIB
 //     gzfile = NULL;
 // #endif
 }
 
 // /* -------------------------------------------------------------------------- */
 
 template <class charT, class Traits>
 inline GZfstream<charT,Traits>::GZfstream(const std::string & fname,
 					  std::fstream::openmode mode,bool) :
     std::basic_fstream<charT,Traits>(fname.c_str(),mode){
   //  compressed = compr;
 // #ifdef USING_ZLIB
 //   gzfile = NULL;
 // #endif
 //  open(fname,mode,compressed);
 }
 
 // /* -------------------------------------------------------------------------- */
 
 // // inline void GZfstream::printf(const std::string & formated, ...){
 // //   if (!opened) {
 // //     FATAL("Warning : file not opened " << name);
 // //   }
 
 
 // //   //  if (!opened) return;
 
 // //   if (_file == NULL) FATAL("fichier non ouvert mais ce n'est pas normal");
 
 // //   char buf[512];
 
 // //   va_list list;
 // //   va_start(list,formated);
 // //   int len = vsprintf(buf,formated.c_str(),list);
 // //   va_end(list);
 
 // // #ifdef USING_ZLIB
 // //     if (compressed){
 // //       gzwrite(gzfile,buf,len);
 // //       return;
 // //     }
 // //   else
 // // #endif
 // //     fwrite(buf,len,1,_file);
 
 // // }
 
 // /* -------------------------------------------------------------------------- */
 
 
 // // inline void GZfstream::gets(std::string & buf){
 // //   char * ret;
 // //   const UInt len = 255;
 // //   char buffer[len] = "";
 
 // //   if (!opened) {
 // //     FATAL("Warning : file not opened " << name);
 // //   }
 // //   if (_file == NULL) FATAL("file not opened: exit");
 
 // //   DUMP("read to buf (" << buf << ") at most " << len << " characters");
 // // #ifdef USING_ZLIB
 // //     if (compressed){
 // //       ret = gzgets(gzfile,buffer,len);
 // //     }
 // //   else
 // // #endif
 // //     ret = fgets(buffer,len,_file);
 
 // //     if (ret == NULL) throw;
 
 // //     DUMP("read to buf (" << buf << ") at most " << len << " characters");
 
 // //     buf = buffer;
 // // }
 
 // /* -------------------------------------------------------------------------- */
 
 
 // template <class charT, class Traits>
 // inline void GZfstream<charT,Traits>::close(){
 
 // #ifdef USING_ZLIB
 //   if (this->is_open() && compressed){
 //     gzclose(gzfile);
 //     gzfile = NULL;
 //   }
 // #endif
 // }
 
 // /* -------------------------------------------------------------------------- */
 
 
 template <class charT, class Traits>
 inline void GZfstream<charT,Traits>::open(const std::string & fname,
 					  std::fstream::openmode mode,
 					  bool){
   std::basic_fstream<charT,Traits>::open(fname.c_str(),mode);
 
 //   if (this->is_open()) this->close();
 
 //   compressed = compr;
 //   this->open(fname.c_str(),mode);
 //   if (!this->is_open()) FATAL("Could not open file "<< fname);
 
 // #ifdef USING_ZLIB
 //   if (compressed){
 //     std::stringstream _mode;
 //     if (mode & std::fstream::in) _mode  << "r";
 //     if (mode & std::fstream::out) _mode << "w";
 //     if (mode & std::fstream::app) _mode << "a";
 //     if (mode & std::fstream::binary) _mode << "b";
 
 //     std::cerr << typeid(*this->rdbuf()).name() << std::endl;
 //     int fd = this->rdbuf()->_M_file->fd();
 
 //     //gzfile = gzdopen(this->rdbuf()->fd(),_mode.str().c_str());
 //     throw;
 //   }
 // #endif
 
 //   DUMP("file " << name << " opened , compressed = " << compressed);
 }
 
 // /* -------------------------------------------------------------------------- */
 
 
 // // inline int GZfstream::dumpchar(int c){
 // //   if (!opened) {
 // //     FATAL("Warning : file not opened " << name);
 // //   }
 
 // //   //  if (!opened) return EOF;
 
 // // #ifdef USING_ZLIB
 // //   if (compressed){
 // //     int res = gzputc(gzfile,c);
 // //     //DUMP("file opened in compressed form " << name);
 // //     if (c != res)
 // //       FATAL("j'ai pas ecrit ce que je voulais (compressed) " << res);
 // //     return res;
 // //   }
 // //   else
 // // #endif
 // //     if (c != putc(c,_file))
 // //       FATAL("j'ai pas ecrit ce que je voulais");
 // //   return c;
 // // }
 // /* -------------------------------------------------------------------------- */
 
 
 
 // // inline int GZfstream::seek(int offset,int set){
 // //   if (!opened) {
 // //     FATAL("Warning : file not opened " << name);
 // //   }
 
 
 // // #ifdef USING_ZLIB
 // //   if (compressed){
 // //     return gzseek(gzfile, offset,set);
 // //   }
 // //   else
 // // #endif
 // //     return fseek(_file,offset,set);
 // // }
 
 // // /* -------------------------------------------------------------------------- */
 
 
 // // inline int GZfstream::tell(){
 // //   if (!opened) {
 // //     FATAL("Warning : file not opened " << name);
 // //   }
 
 // // #ifdef USING_ZLIB
 // //   if (compressed){
 // //     return gztell(gzfile);
 // //   }
 // //   else
 // // #endif
 
 // //     return ftell(_file);
 // // }
 
 // // /* -------------------------------------------------------------------------- */
 
 // //template <class charT, class Traits>
 // //inline GZfstream<charT,Traits> & GZfstream<charT,Traits>::read(void * buffer,
 // //							       std::streamsize size){
 // //   if (!opened) {
 // //     FATAL("Warning : file not opened " << name);
 // //   }
 
 
 // // #ifdef USING_ZLIB
 // //   if (compressed){
 // //     return gzread(gzfile,buffer,size*number);
 // //   }
 // //   else
 // // #endif
 // //     return fread(buffer,size,number,_file);
 // //}
 
 // /* -------------------------------------------------------------------------- */
 
 
 // // template <class charT, class Traits>
 // // inline GZfstream<charT,Traits> & GZfstream<charT,Traits>::write(const void * buffer,
 // // 								std::streamsize size){
 // //   //  if (!this->is_open()) throw std::ios_base::failure("file not opened");
 
 // //   Int nwrite;
 // // #ifdef USING_ZLIB
 // //   if (compressed) nwrite = gzwrite(gzfile,buffer,size);
 // //   else
 // // #endif
 // //     this->write(buffer,size);
 
 // //   //  if (nwrite == 0) throw std::ios_base::failure("could not write any byte");
 
 // //   return *this;
 // // }
 
 // /* -------------------------------------------------------------------------- */
 
 
 // // template <class charT, class Traits>
 // // inline GZfstream<charT,Traits> & GZfstream<charT,Traits>::flush(){
 // //   //  if (!this->is_open()) throw std::ios_base::failure("file not opened");
 
 // // #ifdef USING_ZLIB
 // //   if (compressed){
 // //      gzflush(gzfile,Z_SYNC_FLUSH);
 // //   }
 // //   else
 // // #endif
 // //     this->flush();
 // // }
 
-
-typedef GZfstream<char> File;
+using File = GZfstream<char>;
 
 __END_IOHELPER__
 
 
 
 
 #endif /* __IOHELPER_FILE_MANAGER_H__ */
diff --git a/third-party/iohelper/src/iohelper_common.hh b/third-party/iohelper/src/iohelper_common.hh
index 42972b264..7acab3a40 100644
--- a/third-party/iohelper/src/iohelper_common.hh
+++ b/third-party/iohelper/src/iohelper_common.hh
@@ -1,297 +1,295 @@
 /**
  * @file   iohelper_common.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Mar 11 2010
  * @date last modification: Thu Oct 10 2013
  *
  * @brief  header for common types
  *
  * @section LICENSE
  *
  * Copyright (©) 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * IOHelper 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.
  *
  * IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __IOHELPER_COMMON_H__
 #define __IOHELPER_COMMON_H__
 /* -------------------------------------------------------------------------- */
 
 #define USING_ZLIB
 #include <iostream>
 #include <string>
 #include <sstream>
 
 #define __BEGIN_IOHELPER__ namespace iohelper {
 #define __END_IOHELPER__ }
 
 #include <string.h>
 #include <stdlib.h>
 
 
 /* -------------------------------------------------------------------------- */
 
 __BEGIN_IOHELPER__
 
-typedef unsigned int UInt;
-typedef int Int;
-typedef double Real;
+using UInt = unsigned int;
+using Int = int;
+using Real = double;
 
 /* -------------------------------------------------------------------------- */
 enum DataType {
   _bool,
   _uint,
   _int,
   _float,
   _double,
   _int64,
   _uint64
 };
 
 enum IndexingMode{
   C_MODE       = 0,
   FORTRAN_MODE = 1
 };
 
 /* -------------------------------------------------------------------------- */
 
 #if __cplusplus <= 199711L
 enum ElemType {
 #else
 enum ElemType : unsigned int {
 #endif
   TRIANGLE1 ,
   TRIANGLE2 ,
   TETRA1    ,
   TETRA2    ,
   POINT_SET ,
   LINE1     ,
   LINE2     ,
   QUAD1     ,
   QUAD2     ,
   HEX1      ,
   HEX2      ,
   BEAM2     ,
   BEAM3     ,
   PRISM1    ,
   PRISM2    ,
   COH2D4    ,
   COH2D6    ,
   COH3D6    ,
   COH3D12   ,
   COH3D8    ,
   MAX_ELEM_TYPE
 };
 
 /* -------------------------------------------------------------------------- */
 
 enum FileStorageMode{
   TEXT       = 0,
   BASE64     = 1,
   COMPRESSED = 2
 };
 
 enum TextDumpMode {
   _tdm_space,
   _tdm_csv
 };
 
 /* -------------------------------------------------------------------------- */
 static UInt nb_node_per_elem[MAX_ELEM_TYPE] __attribute__((unused)) = {
   3,   // TRIANGLE1
   6,   // TRIANGLE2
   4,   // TETRA1
  10,   // TETRA2
   1,   // POINT_SET
   2,   // LINE1
   3,   // LINE2
   4,   // QUAD1
   8,   // QUAD2
   8,   // HEX1
  20,   // HEX2
   2,   // BEAM2
   2,   // BEAM3
   6,   // PRISM1
  15,   // PRISM2
   4,   // COH2D4
   6,   // COH2D6
   6,   // COH3D6
  12,   // COH3D12
   8,   // COH3D8
 };
 
 /* -------------------------------------------------------------------------- */
 static UInt nb_quad_points[MAX_ELEM_TYPE] __attribute__((unused)) = {
   1,   // TRIANGLE1
   3,   // TRIANGLE2
   1,   // TETRA1
   4,   // TETRA2
   0,   // POINT_SET
   1,   // LINE1
   2,   // LINE2
   4,   // QUAD1
   9,   // QUAD2
   8,   // HEX1
  27,   // HEX2
   2,   // BEAM2
   3,   // BEAM3
   6,   // PRISM1
   8,   // PRISM2
   1,   // COH2D4
   2,   // COH2D6
   1,   // COH3D6
   3,   // COH3D12
   1,   // COH3D8
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 class IOHelperVector {
 public:
-  virtual ~IOHelperVector() {}
+  virtual ~IOHelperVector() = default;
 
   inline IOHelperVector(T * ptr, UInt size){
     this->ptr = ptr;
     this->_size = size;
   };
 
   inline UInt size() const {return _size;};
 
   inline const T & operator[] (UInt i) const {
     return ptr[i];
   };
 
   inline const T * getPtr() const {
     return ptr;
   };
 
 private:
   T* ptr;
   UInt _size;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Iterator interface                                                         */
 /* -------------------------------------------------------------------------- */
 template< typename T, class daughter, class ret_cont = IOHelperVector<T> > class iterator {
 public:
-  typedef ret_cont type;
+  using type = ret_cont;
 
-  virtual ~iterator() {}
+  virtual ~iterator() = default;
   virtual bool operator!=(const daughter & it) const = 0;
   virtual daughter & operator++() = 0;
   virtual ret_cont operator*() = 0;
   //! This function is only for the element iterators
   virtual ElemType element_type() { return MAX_ELEM_TYPE; }
 };
 
 /* -------------------------------------------------------------------------- */
 
 class IOHelperException : public std::exception {
 
 public:
   enum ErrorType {
     _et_non_homogeneous_data,
     _et_unknown_visitor_stage,
     _et_file_error,
     _et_missing_field,
     _et_data_type,
     _et_options_error
 };
 
 public:
-
-  IOHelperException(const std::string & message, const ErrorType type) throw() {
+  IOHelperException(const std::string & message,
+                    const ErrorType type) noexcept {
     this->message = message;
     this->type    = type;
   };
 
-  ~IOHelperException() throw(){};
+  ~IOHelperException() noexcept override = default;
 
-  virtual const char* what() const throw(){
-    return message.c_str();
-  };
+  const char * what() const noexcept override { return message.c_str(); };
 
 private:
 
   std::string message;
   ErrorType type;
 };
 
 /* -------------------------------------------------------------------------- */
 
 #define IOHELPER_THROW(x,type) {					\
     std::stringstream ioh_throw_sstr;					\
     ioh_throw_sstr << __FILE__ << ":" << __LINE__ << ":"		\
 		   << __PRETTY_FUNCTION__ << ": " << x;			\
     std::string ioh_message(ioh_throw_sstr.str());			\
     throw ::iohelper::IOHelperException(ioh_message,			\
 					::iohelper::IOHelperException::type); \
   }
 
 /* -------------------------------------------------------------------------- */
 
 
 template <typename T> DataType getDataType();
 
 #define DEFINE_GET_DATA_TYPE(type, data_type )				\
   template <> inline DataType getDataType<type>() { return data_type; }
 
 DEFINE_GET_DATA_TYPE(bool, _bool)
 DEFINE_GET_DATA_TYPE(ElemType, _int)
 DEFINE_GET_DATA_TYPE(int, _int)
 DEFINE_GET_DATA_TYPE(unsigned int, _uint)
 DEFINE_GET_DATA_TYPE(float, _float)
 DEFINE_GET_DATA_TYPE(double, _double)
 DEFINE_GET_DATA_TYPE(long int, _int64)
 DEFINE_GET_DATA_TYPE(unsigned long int, _uint64)
 
 #undef DEFINE_GET_DATA_TYPE
 
 inline std::ostream & operator <<(std::ostream & stream,  DataType type)
 {
   switch(type)
     {
     case _bool   : stream << "bool"    ; break;
     case _uint   : stream << "uint32"  ; break;
     case _int	 : stream << "int32"   ; break;
     case _float  : stream << "float32" ; break;
     case _double : stream << "float64" ; break;
     case _uint64 : stream << "uint64"  ; break;
     case _int64	 : stream << "int64"   ; break;
     }
   return stream;
 }
 
 inline std::ostream & operator <<(std::ostream & stream,  TextDumpMode mode)
 {
   switch(mode)
     {
     case _tdm_space : stream << "space" ; break;
     case _tdm_csv   : stream << "csv"   ; break;
     }
   return stream;
 }
 
 
 __END_IOHELPER__
 
 #endif /* __IOHELPER_COMMON_H__ */
diff --git a/third-party/iohelper/src/paraview_helper.hh b/third-party/iohelper/src/paraview_helper.hh
index 1343c248f..bf5f24ced 100644
--- a/third-party/iohelper/src/paraview_helper.hh
+++ b/third-party/iohelper/src/paraview_helper.hh
@@ -1,259 +1,259 @@
 /**
  * @file   paraview_helper.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *
  * @date creation: Thu Mar 11 2010
  * @date last modification: Wed Jun 05 2013
  *
  * @brief  paraview helper header
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * IOHelper 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.
  *
  * IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __IOHELPER_PARAVIEW_HELPER_H__
 #define __IOHELPER_PARAVIEW_HELPER_H__
 /* -------------------------------------------------------------------------- */
 #include "base64.hh"
 #include <iomanip>
 #include <map>
 #include "visitor.hh"
 #include "field_interface.hh"
 /* -------------------------------------------------------------------------- */
 
 __BEGIN_IOHELPER__
 
 // Taken from vtkCellType.h
 enum VTKCellType {
   // Linear cells
   VTK_EMPTY_CELL = 0,
   VTK_VERTEX = 1,
   VTK_POLY_VERTEX = 2,
   VTK_LINE = 3,
   VTK_POLY_LINE = 4,
   VTK_TRIANGLE = 5,
   VTK_TRIANGLE_STRIP = 6,
   VTK_POLYGON = 7,
   VTK_PIXEL = 8,
   VTK_QUAD = 9,
   VTK_TETRA = 10,
   VTK_VOXEL = 11,
   VTK_HEXAHEDRON = 12,
   VTK_WEDGE = 13,
   VTK_PYRAMID = 14,
   VTK_PENTAGONAL_PRISM = 15,
   VTK_HEXAGONAL_PRISM = 16,
 
   // Quadratic, isoparametric cells
   VTK_QUADRATIC_EDGE = 21,
   VTK_QUADRATIC_TRIANGLE = 22,
   VTK_QUADRATIC_QUAD = 23,
   VTK_QUADRATIC_POLYGON = 36,
   VTK_QUADRATIC_TETRA = 24,
   VTK_QUADRATIC_HEXAHEDRON = 25,
   VTK_QUADRATIC_WEDGE = 26,
   VTK_QUADRATIC_PYRAMID = 27,
   VTK_BIQUADRATIC_QUAD = 28,
   VTK_TRIQUADRATIC_HEXAHEDRON = 29,
   VTK_QUADRATIC_LINEAR_QUAD = 30,
   VTK_QUADRATIC_LINEAR_WEDGE = 31,
   VTK_BIQUADRATIC_QUADRATIC_WEDGE = 32,
   VTK_BIQUADRATIC_QUADRATIC_HEXAHEDRON = 33,
   VTK_BIQUADRATIC_TRIANGLE = 34,
 
   // Polyhedron cell (consisting of polygonal faces)
   VTK_POLYHEDRON = 42,
 
   // Higher order cells in parametric form
   VTK_PARAMETRIC_CURVE = 51,
   VTK_PARAMETRIC_SURFACE = 52,
   VTK_PARAMETRIC_TRI_SURFACE = 53,
   VTK_PARAMETRIC_QUAD_SURFACE = 54,
   VTK_PARAMETRIC_TETRA_REGION = 55,
   VTK_PARAMETRIC_HEX_REGION = 56,
 
   // Higher order cells
   VTK_HIGHER_ORDER_EDGE = 60,
   VTK_HIGHER_ORDER_TRIANGLE = 61,
   VTK_HIGHER_ORDER_QUAD = 62,
   VTK_HIGHER_ORDER_POLYGON = 63,
   VTK_HIGHER_ORDER_TETRAHEDRON = 64,
   VTK_HIGHER_ORDER_WEDGE = 65,
   VTK_HIGHER_ORDER_PYRAMID = 66,
   VTK_HIGHER_ORDER_HEXAHEDRON = 67,
 
   VTK_NUMBER_OF_CELL_TYPES
 };
 
 
 inline std::ostream & operator <<(std::ostream & stream, const VTKCellType & type) {
   stream << UInt(type);
   return stream;
 }
 
 
 class ParaviewHelper : public Visitor {
 
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 
   enum Stage{
     _s_writePosition,
     _s_writeFieldProperty,
     _s_writeField,
     _s_writeConnectivity,
     _s_writeElemType,
     _s_buildOffsets
   };
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
  public:
 
   ParaviewHelper(File & f, UInt mode);
-  virtual ~ParaviewHelper();
+  ~ParaviewHelper() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 
 
   //! write the PVTU file
   template <typename T>
   void writePVTU(T & per_node_data, T & per_elem_data,
 		 const std::vector<std::string> & vtus);
 
   //! write the PVD file for time description
   static void writeTimePVD(const std::string & filename,
 			   const std::vector< std::pair<Real, std::string> > & pvtus);
 
   //! write the header of a vtu file
   void writeHeader(int nb_nodes,int nb_elems);
   //! write a field
   template <typename T> void writeField(T & data);
   //! write a connectivity field
   template <typename T>  void writeConnectivity(T & data);
   //! write an element type field
   template <typename T> void writeElemType(T & data);
   //! write the field properties
   template <typename T> void writeFieldProperty(T & data);
   //! write the connectivities offset
   template <typename T> void writeOffsets(T & data);
 
 
   template <typename T>
   void pushDataFields(T & per_node_data, T & per_elem_data);
 
   //! push the position field to the paraview file
   void pushPosition(FieldInterface & f);
   //! push a field to the paraview file
   void pushField(FieldInterface & f);
   //! build the offset from connectivities
   void buildOffsets(FieldInterface & f);
   //! push a connectivity field
   void pushConnectivity(FieldInterface & f);
   //! push a element type field
   void pushElemType(FieldInterface & f);
 
   //! get the formated vtu name
   // static std::string getVTUName(const std::string & basename, UInt proc);
 
   //! push a small array of values
   template <template<typename T> class Cont, typename T>
   void pushData(const Cont<T> & n);
 
   //! push a small array of values of homogeneous values with padding to size dim
   template <template<typename T> class Cont, typename T>
   inline void pushData(const Cont<T> & n, UInt dim);
 
   //! pushing datum
   template <typename T> void pushDatum(const T & n, UInt size = 3);
 
   //! visitor system
   template <typename T> void visitField(T & visited);
 private:
 
   void setMode(int mode);
 
   std::string dataTypeToStr(DataType data_type);
 
   /* ------------------------------------------------------------------------ */
   /* Methods for writing control sequences in the paraview files              */
   /* ------------------------------------------------------------------------ */
 
 public:
   void startDofList(int dimension);
   void endDofList();
   void startCells();
   void endCells();
   void startCellsConnectivityList();
   void endCellsConnectivityList();
   void startCellsoffsetsList();
   void endCellsoffsetsList();
   void startCellstypesList();
   void endCellstypesList();
   void startPointDataList();
   void endPointDataList();
   void startCellDataList();
   void endCellDataList();
   void startData(const std::string & name, int nb_components, const std::string & type);
   void PDataArray(const std::string & name, int nb_components, const std::string & type);
   void endData();
   void write_conclusion();
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
 
   Base64Writer b64;
   int bflag;
 
   File & file;
   long header_offset;
 
   unsigned int compteur;
 
   Stage current_stage;
 
   bool position_flag;
 
   //! mapping between iohelper elements and paraview elements
   std::map<ElemType, VTKCellType> paraview_code_type;
 
   //! mapping of the connectivities between iohelper and paraview
   std::map<ElemType, UInt *> write_reorder;
 };
 
 /* -------------------------------------------------------------------------- */
 #include "paraview_helper.tcc"
 /* -------------------------------------------------------------------------- */
 
 
 
 
 __END_IOHELPER__
 
 
 
 #endif /* __IOHELPER_PARAVIEW_HELPER_H__ */
diff --git a/third-party/iohelper/src/paraview_helper.tcc b/third-party/iohelper/src/paraview_helper.tcc
index 6afdb9259..7f19f4513 100644
--- a/third-party/iohelper/src/paraview_helper.tcc
+++ b/third-party/iohelper/src/paraview_helper.tcc
@@ -1,309 +1,309 @@
 #include <cassert>
 
 #if defined(__INTEL_COMPILER)
 #pragma warning ( push )
 /// remark #981: operands are evaluated in unspecified order
 #pragma warning ( disable : 981 )
 #endif //defined(__INTEL_COMPILER)
 
 
 inline std::string ParaviewHelper::dataTypeToStr(DataType data_type) {
   std::string str;
   switch(data_type) {
   case _bool   : str = "UInt8"  ; break;
   case _uint   : str = "UInt32" ; break;
   case _int    : str = "Int32"  ; break;
   case _float  : str = "Float32"; break;
   case _double : str = "Float64"; break;
   case _uint64 : str = "UInt64" ; break;
   case _int64  : str = "Int64"  ; break;
   }
   return str;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void ParaviewHelper::visitField(T & visited){
   this->position_flag = false;
   switch (current_stage){
   case _s_writeFieldProperty:   writeFieldProperty(visited); break;
   case _s_writePosition:        this->position_flag = true;  /* FALLTHRU */
   // [[fallthrough]] un-comment when compiler gets it
   case _s_writeField:           writeField(visited);         break;
   case _s_writeConnectivity:    writeConnectivity(visited);  break;
   case _s_writeElemType:        writeElemType(visited);      break;
   case _s_buildOffsets:         writeOffsets(visited);       break;
   default:
     std::stringstream sstr;
     sstr << "the stage " << current_stage << " is not a known paraviewhelper stage";
     IOHELPER_THROW(sstr.str(),
 		   IOHelperException::_et_unknown_visitor_stage);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void ParaviewHelper::writeFieldProperty(T & data){
   if (data.isHomogeneous() == false)
     IOHELPER_THROW(std::string("try to write field property of a non homogeneous field"),
 		   IOHelperException::_et_non_homogeneous_data);
 
   UInt dim = data.getDim();
   std::string name = data.getName();
   PDataArray(name, dim, dataTypeToStr(data.getDataType()));
 }
 
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void ParaviewHelper::writeField(T & data){
   typename T::iterator it = data.begin();
   typename T::iterator end = data.end();
 
   compteur = 0;
   UInt dim;
   if(data.isHomogeneous()) {
     dim = data.getDim();
     if(position_flag)
       dim = 3;
     for (; it != end; ++it)
       pushData((*it), dim);
   }
   else {
     for (; it != end; ++it)
       pushData((*it));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void ParaviewHelper::writeConnectivity(T & data) {
   typename T::iterator it = data.begin();
   typename T::iterator end = data.end();
 
   for (; it != end; ++it) {
-    ElemType type = (ElemType) it.element_type();
+    auto type = (ElemType)it.element_type();
     //typename T::iterator::type & n = *it;
     UInt dim = (*it).size();
     assert(nb_node_per_elem[type] == dim);
     UInt * reorder = this->write_reorder[type];
     for (UInt i = 0; i < dim; ++i) {
       this->pushDatum((*it)[reorder[i]], dim);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void ParaviewHelper::writeElemType(T & data){
   typename T::iterator it = data.begin();
   typename T::iterator end = data.end();
 
   for (; it != end; ++it) {
-    ElemType type = (ElemType) it.element_type();
+    auto type = (ElemType)it.element_type();
     this->pushDatum(this->paraview_code_type[type], 1);
   }
 }
 
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void ParaviewHelper::writeOffsets(T & data){
 
   typename T::iterator it = data.begin();
   typename T::iterator end = data.end();
 
   UInt count = 0;
   for (; it != end; ++it) {
     count += (*it).size();
     pushDatum(count);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <template<typename T> class Cont, typename T>
 inline void ParaviewHelper::pushData(const Cont<T> & n, UInt dim){
   for (UInt i = 0; i < n.size(); ++i) {
     pushDatum<T>(n[i], dim);
   }
 
   for (UInt i = n.size(); i < dim; ++i) { T t = T(); this->pushDatum<T>(t, dim); }
 }
 
 /* -------------------------------------------------------------------------- */
 template <template<typename T> class Cont, typename T>
 inline void ParaviewHelper::pushData(const Cont<T> & n) {
   for (UInt i = 0; i < n.size(); ++i) {
     pushDatum<T>(n[i], n.size());
   }
 }
 
 
 /* -------------------------------------------------------------------------- */
 inline void ParaviewHelper::setMode(int mode){
   bflag = BASE64 & mode;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void ParaviewHelper::writePVTU(T & per_node_data, T & per_elem_data,
 				      const std::vector<std::string> & vtus){
 
   current_stage = _s_writeFieldProperty;
 
   file << "<VTKFile type=\"PUnstructuredGrid\" version=\"0.1\" " << std::endl;
   file << "byte_order=\"LittleEndian\">" << std::endl;
   file << " <PUnstructuredGrid GhostLevel=\"0\">" << std::endl;
 
   file << "  <PPoints>" << std::endl;
   file << "   <PDataArray type=\"Float64\" NumberOfComponents=\"3\" format=\"";
   if (bflag == BASE64) file << "binary";
   else file << "ascii";
   file << "\" />" << std::endl;
   file << "  </PPoints>" << std::endl;
 
   file << "  <PPointData>" << std::endl;
   typename T::iterator itNodeField = per_node_data.begin();
   typename T::iterator endNodeField = per_node_data.end();
   for ( ; itNodeField != endNodeField ; ++itNodeField)
     if ((*itNodeField).first != "positions")
       (*itNodeField).second->accept(*this);
 
   file << "  </PPointData>" << std::endl;
 
   file << "  <PCellData>" << std::endl;
   typename T::iterator itElemField = per_elem_data.begin();
   typename T::iterator endElemField = per_elem_data.end();
   for (; itElemField != endElemField ; ++itElemField) {
     std::string name = (*itElemField).first;
     if (name == "connectivities" ||
 	name == "element_type") continue;
 
     (*itElemField).second->accept(*this);
   }
   file << "  </PCellData>" << std::endl;
 
   for (UInt l = 0 ; l < vtus.size() ; ++l)
     file << "  <Piece Source=\"" << vtus[l] << "\" />" << std::endl;
 
   file << " </PUnstructuredGrid>" << std::endl;
   file << "</VTKFile>" << std::endl;
   file.close();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void ParaviewHelper::pushDataFields(T & per_node_data, T & per_elem_data){
 
   startPointDataList();
   {
   typename T::iterator itNodeField = per_node_data.begin();
   typename T::iterator endNodeField = per_node_data.end();
   for ( ; itNodeField != endNodeField ; ++itNodeField) {
     std::string name = (*itNodeField).first;
     if (name == "positions") continue;
     FieldInterface & f = *(*itNodeField).second;
     startData(f.getName(), f.getDim(), dataTypeToStr(f.getDataType()));
     pushField(f);
     endData();
   }
   }
   endPointDataList();
 
   startCellDataList();
   {
   typename T::iterator itElemField = per_elem_data.begin();
   typename T::iterator endElemField = per_elem_data.end();
   for ( ; itElemField != endElemField ; ++itElemField) {
     std::string name = (*itElemField).first;
     if (name == "connectivities" ||
 	name == "element_type") continue;
 
     FieldInterface & f = *(*itElemField).second;
     startData(f.getName(),f.getDim(), dataTypeToStr(f.getDataType()));
     pushField(f);
     endData();
   }
   }
   endCellDataList();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline  void ParaviewHelper::pushDatum(const T & n,
 				       __attribute__((unused)) UInt size){
   if (bflag == BASE64)
     b64.push<T>(n);
   else{
     if (compteur == 0)
       file << "      ";
     ++compteur;
     file << n << " ";
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline  void ParaviewHelper::pushDatum<double>(const double & n,
 					       UInt size){
   if (bflag == BASE64)
     b64.push<double>(n);
   else {
     if (compteur % size == 0)
       file << "     ";
     file << std::setw(22);
     file << std::setprecision(15);
     file << std::scientific;
     file << n;
     file << " ";
     ++compteur;
     if (compteur % size == 0)
       file << std::endl;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline  void ParaviewHelper::pushDatum<ElemType>(const ElemType & type,
 						 __attribute__((unused)) UInt size){
   UInt n = this->paraview_code_type[type];
   pushDatum<UInt>(n);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void ParaviewHelper::pushPosition(FieldInterface & f){
   current_stage = _s_writePosition;
   f.accept(*this);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void ParaviewHelper::pushField(FieldInterface & f){
   current_stage = _s_writeField;
   f.accept(*this);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void ParaviewHelper::pushConnectivity(FieldInterface & f) {
   current_stage = _s_writeConnectivity;
   f.accept(*this);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void ParaviewHelper::pushElemType(FieldInterface & f) {
   current_stage = _s_writeElemType;
   f.accept(*this);
 }
 
 
 /* -------------------------------------------------------------------------- */
 inline void ParaviewHelper::buildOffsets(FieldInterface & f){
   current_stage = _s_buildOffsets;
   f.accept(*this);
 }
 /* -------------------------------------------------------------------------- */
 
 #if defined(__INTEL_COMPILER)
 #pragma warning ( pop )
 #endif //defined(__INTEL_COMPILER)
diff --git a/third-party/iohelper/src/variable.hh b/third-party/iohelper/src/variable.hh
index cb2dc8a29..538613c51 100644
--- a/third-party/iohelper/src/variable.hh
+++ b/third-party/iohelper/src/variable.hh
@@ -1,84 +1,86 @@
 /**
  * @file   variable.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Tue Jun 04 2013
  * @date last modification: Tue Jun 04 2013
  *
  * @brief  for dump of global variables
  *
  * @section LICENSE
  *
  * Copyright (©) 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * IOHelper 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.
  *
  * IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __IOHELPER_VARIABLE_HH__
 #define __IOHELPER_VARIABLE_HH__
 /* -------------------------------------------------------------------------- */
 #include "variable_interface.hh"
 /* -------------------------------------------------------------------------- */
 
 __BEGIN_IOHELPER__
 
 template <class Cont>
 class Variable : public VariableInterface {
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-  Variable(Cont & c, const std::string name) : my_variable(c), name(name) {};
-  virtual ~Variable() {};
+  Variable(Cont & c, const std::string & name) : my_variable(c), name(name){};
+  ~Variable() override = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   //! accept to be visited by a visitor
-  inline void accept(Visitor & v) const;
+  inline void accept(Visitor & v) const override;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
-  inline DataType getDataType() const { return my_variable.getDataType(); }
+  inline DataType getDataType() const override {
+    return my_variable.getDataType();
+  }
 
   //! return the dim
-  inline UInt getDim() const { return my_variable.getDim(); }
+  inline UInt getDim() const override { return my_variable.getDim(); }
 
   //! return the description name of the container
-  inline std::string getName() const { return name; }
+  inline std::string getName() const override { return name; }
 
   inline const Cont & operator*() const { return my_variable; } 
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   Cont & my_variable;
 
   std::string name;
 };
 
 /* -------------------------------------------------------------------------- */
 
 __END_IOHELPER__
 
 #endif /* __IOHELPER_VARIABLE_HH__ */
diff --git a/third-party/iohelper/src/variable_inline_impl.cc b/third-party/iohelper/src/variable_inline_impl.cc
index 1cceeb47c..6e9fecd0a 100644
--- a/third-party/iohelper/src/variable_inline_impl.cc
+++ b/third-party/iohelper/src/variable_inline_impl.cc
@@ -1,62 +1,62 @@
 /**
  * @file   variable_inline_impl.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Tue Jun 04 2013
  * @date last modification: Tue Jun 04 2013
  *
  * @brief  inline implementation of dumper visitor
  *
  * @section LICENSE
  *
  * Copyright (©) 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * IOHelper 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.
  *
  * IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "paraview_helper.hh"
 #include "dumper_lammps.hh"
 #include "dumper_text.hh"
 
 #ifndef __IOHELPER_VARIABLE_INLINE_IMPL_CC__
 #define __IOHELPER_VARIABLE_INLINE_IMPL_CC__
 
 /* -------------------------------------------------------------------------- */
 __BEGIN_IOHELPER__
 
 template <class Cont>
 inline void Variable<Cont>::accept(Visitor & v) const {
-  if (DumperText * ptr_txt = dynamic_cast<DumperText*>(&v)){
+  if (auto * ptr_txt = dynamic_cast<DumperText *>(&v)) {
     ptr_txt->visitVariable(*this);
   }
   /*
     else if (ParaviewHelper * ptr_ph = dynamic_cast<ParaviewHelper*>(&v)){
     ptr_ph->visitVariable(*this);
   } else if (iohelper::DumperLammps<iohelper::bond> * ptr_dlb = dynamic_cast<DumperLammps<bond>*>(&v)) {
     ptr_dlb->visitVariable(*this);
   } else if (DumperLammps<iohelper::atomic> * ptr_dla = dynamic_cast<DumperLammps<atomic>*>(&v)){
     ptr_dla->visitVariable(*this);
     }
   */
 }
 
 /* -------------------------------------------------------------------------- */
 
 __END_IOHELPER__
 
 #endif /* __IOHELPER_VARIABLE_INLINE_IMPL_CC__ */
diff --git a/third-party/iohelper/src/variable_interface.hh b/third-party/iohelper/src/variable_interface.hh
index a8b81e98e..b92832ca2 100644
--- a/third-party/iohelper/src/variable_interface.hh
+++ b/third-party/iohelper/src/variable_interface.hh
@@ -1,80 +1,79 @@
 /**
  * @file   variable_interface.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Tue Jun 04 2013
  * @date last modification: Tue Jun 04 2013
  *
  * @brief  variable interface
  *
  * @section LICENSE
  *
  * Copyright (©) 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * IOHelper 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.
  *
  * IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __IOHELPER_VARIABLE_INTERFACE_HH__
 #define __IOHELPER_VARIABLE_INTERFACE_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "visitor.hh"
 
 /* -------------------------------------------------------------------------- */
 __BEGIN_IOHELPER__
 
 class VariableInterface {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-
-  VariableInterface() {};
-  virtual ~VariableInterface() {};
+  VariableInterface() = default;
+  virtual ~VariableInterface() = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
 
   virtual void accept(Visitor & v) const = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
 
   //! return the size per element (valid only if isHomogeneous is true)
   virtual UInt getDim() const = 0;
   //! return the description name of the container
   virtual std::string getName() const = 0;
 
   virtual DataType getDataType() const = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
 
 };
 
 /* -------------------------------------------------------------------------- */
 
 __END_IOHELPER__
 
 #endif /* __IOHELPER_VARIABLE_INTERFACE_HH__ */
diff --git a/third-party/iohelper/src/visitor.hh b/third-party/iohelper/src/visitor.hh
index fd336e07b..6b7b5981d 100644
--- a/third-party/iohelper/src/visitor.hh
+++ b/third-party/iohelper/src/visitor.hh
@@ -1,68 +1,67 @@
 /**
  * @file   visitor.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *
  * @date creation: Fri Oct 12 2012
  * @date last modification: Thu Nov 01 2012
  *
  * @brief  visitor interface
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * IOHelper 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.
  *
  * IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __IOHELPER_VISITOR_HH__
 #define __IOHELPER_VISITOR_HH__
 /* -------------------------------------------------------------------------- */
 
 __BEGIN_IOHELPER__
 
 class Visitor {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-
-  Visitor(){};
-  virtual ~Visitor(){};
+  Visitor() = default;
+  virtual ~Visitor() = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
 
 };
 
 /* -------------------------------------------------------------------------- */
 
 __END_IOHELPER__
 
 #endif /* __IOHELPER_VISITOR_HH__ */