diff --git a/.clang-tidy b/.clang-tidy
index 7d637c829..badab5d0e 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,4 +1,4 @@
-Checks:          'modernize-*'
+Checks:          'modernize-use-override'
 AnalyzeTemporaryDtors: false
 HeaderFilterRegex: '.*'
 FormatStyle:     file
diff --git a/cmake/AkantuCleaning.cmake b/cmake/AkantuCleaning.cmake
index 1b3d80aee..f41eb399e 100644
--- a/cmake/AkantuCleaning.cmake
+++ b/cmake/AkantuCleaning.cmake
@@ -1,66 +1,77 @@
 #===============================================================================
 # @file   AkantuCleaning.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Thu Jun 1, 2017
 #
 # @brief  set of tools to clean the code
 #
 # @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/>.
 #===============================================================================
 
 # Adding clang-format target if executable is found
 find_program(CLANG_FORMAT "clang-format")
 mark_as_advanced(CLANG_FORMAT)
 macro(register_code_to_format)
   if(CLANG_FORMAT)
     add_custom_target(
       clang-format-all
       COMMAND ${CLANG_FORMAT}
       -i
       -style=file
       ${ARGN}
       )
   endif()
 endmacro()
 
 # Adding clang-tidy target if executable is found
 find_program(CLANG_TIDY "clang-tidy")
 mark_as_advanced(CLANG_TIDY)
 macro(register_target_to_tidy target)
   if(CLANG_TIDY)
     get_target_property(_sources ${target} SOURCES)
 
     set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE BOOL
       "Enable/Disable output of compile commands during generation" FORCE)
 
-    add_custom_target(
-      clang-tidy-${target}
-      COMMAND ${CLANG_TIDY}
-        -quiet
-        -p=${PROJECT_BINARY_DIR}
-        -export-fixes=${PROJECT_BINARY_DIR}/clang-tidy-${target}.yaml
-        ${_sources}
-      COMMENT "Tidying ${target}"
-      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-      )
+    file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/clang-tidy)
+
+    set(_depends)
+
+    foreach(_src ${_sources})
+      get_filename_component(_src_dir ${_src} DIRECTORY)
+      file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/clang-tidy/${_src_dir})
+
+      add_custom_command(
+        OUTPUT ${PROJECT_BINARY_DIR}/clang-tidy/${_src}.yaml
+        COMMAND ${CLANG_TIDY}
+         -p=${PROJECT_BINARY_DIR}
+         -export-fixes=${PROJECT_BINARY_DIR}/clang-tidy/${_src}.yaml
+        ${_src}
+        COMMENT "Tidying ${_src}"
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        )
+
+      list(APPEND _depends ${PROJECT_BINARY_DIR}/clang-tidy/${_src}.yaml)
+    endforeach()
+    add_custom_target(clang-tidy DEPENDS ${_depends})
   endif()
 endmacro()
diff --git a/src/common/aka_array_tmpl.hh b/src/common/aka_array_tmpl.hh
index e20a4dcf0..174f8e1c0 100644
--- a/src/common/aka_array_tmpl.hh
+++ b/src/common/aka_array_tmpl.hh
@@ -1,1549 +1,1538 @@
 /**
  * @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 {
 
 /* -------------------------------------------------------------------------- */
 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);
 // }
 
 /* -------------------------------------------------------------------------- */
 /**
  * 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>
 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);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * 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);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * 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>
 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);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 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.getSize(), false);
 
   T * tmp = values + nb_component * old_size;
   std::uninitialized_copy(
       other.storage(), other.storage() + other.getSize() * 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(NULL) {
   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(NULL) {
   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 = NULL;
   } else {
     values = static_cast<T *>(malloc(nb_component * size * sizeof(T)));
     AKANTU_DEBUG_ASSERT(values != NULL,
                         "Cannot allocate "
                             << printMemorySize<T>(size * nb_component) << " ("
                             << id << ")");
   }
 
   if (values == NULL) {
     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 = NULL;
       } else {
         auto * tmp_ptr = static_cast<T *>(
             realloc(values, new_size * nb_component * sizeof(T)));
 
         if (tmp_ptr == NULL) {
           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 != NULL,
         "Cannot allocate " << printMemorySize<T>(size_to_alloc * nb_component));
     if (tmp_ptr == NULL) {
       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>
 Int Array<T, is_scal>::find(const T & elem) const {
   AKANTU_DEBUG_IN();
   UInt i = 0;
   for (; (i < size) && (values[i] != elem); ++i)
     ;
 
   AKANTU_DEBUG_OUT();
   return (i == size) ? -1 : (Int)i;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal> Int 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 -1;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <template <typename> class C>
 inline Int Array<T, is_scal>::find(const C<T> & elem) {
   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.getSize(); ++i) {
         stream << "{";
         for (UInt j = 0; j < vect.getNbComponent(); ++j) {
           stream << vect(i, j);
           if (j != vect.getNbComponent() - 1)
             stream << ", ";
         }
         stream << "}";
         if (i != vect.getSize() - 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; }
 
 /* -------------------------------------------------------------------------- */
 /* Iterators                                                                  */
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <class R, class IR, bool is_r_scal>
 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() : initial(NULL), ret(NULL), ret_ptr(NULL){};
 
   iterator_internal(pointer_type data, UInt _offset)
       : _offset(_offset), initial(data), ret(NULL), ret_ptr(data) {
     AKANTU_DEBUG_ERROR(
         "The constructor should never be called it is just an ugly trick...");
   }
 
   iterator_internal(pointer wrapped)
       : _offset(wrapped->size()), initial(wrapped->storage()),
         ret(const_cast<internal_pointer>(wrapped)),
         ret_ptr(wrapped->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 = new internal_value_type(*it.ret, false);
     }
   }
 
   virtual ~iterator_internal() { delete ret; };
 
   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 = new 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;
   };
   inline iterator_internal & operator++() {
     ret_ptr += _offset;
     return *this;
   };
   inline iterator_internal & operator--() {
     ret_ptr -= _offset;
     return *this;
   };
 
   inline iterator_internal & operator+=(const UInt n) {
     ret_ptr += _offset * n;
     return *this;
   }
   inline iterator_internal & operator-=(const UInt n) {
     ret_ptr -= _offset * n;
     return *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 iterator_internal operator+(difference_type n) {
     iterator_internal tmp(*this);
     tmp += n;
     return tmp;
   }
   inline iterator_internal operator-(difference_type n) {
     iterator_internal tmp(*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;
   internal_pointer ret;
   pointer_type ret_ptr;
 };
 
 /* -------------------------------------------------------------------------- */
 /**
  * Specialization for scalar types
  */
 template <class T, bool is_scal>
 template <class R, class IR>
 class Array<T, is_scal>::iterator_internal<R, IR, true> {
 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 = NULL,
-                    __attribute__((unused)) UInt _offset = 1)
+  iterator_internal(pointer data = nullptr, UInt _offset = 1)
       : _offset(_offset), ret(data), initial(data){};
-  iterator_internal(const iterator_internal & it) {
-    if (this != &it) {
-      this->ret = it.ret;
-      this->initial = it.initial;
-    }
-  }
+  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) {
-    if (this != &it) {
-      this->ret = it.ret;
-      this->initial = it.initial;
-    }
-    return *this;
-  }
+  inline iterator_internal & operator=(const iterator_internal & it) = default;
 
   UInt getCurrentIndex() {
     return (this->ret - this->initial) / this->_offset;
   };
 
   inline reference operator*() { return *ret; };
   inline const_reference operator*() const { return *ret; };
   inline pointer operator->() { return ret; };
   inline iterator_internal & operator++() {
     ++ret;
     return *this;
   };
   inline iterator_internal & operator--() {
     --ret;
     return *this;
   };
 
   inline iterator_internal & operator+=(const UInt n) {
     ret += n;
     return *this;
   }
   inline iterator_internal & operator-=(const UInt n) {
     ret -= n;
     return *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 iterator_internal operator-(difference_type n) {
     return iterator_internal(ret - n);
   }
   inline iterator_internal operator+(difference_type n) {
     return iterator_internal(ret + n);
   }
 
   inline difference_type operator-(const iterator_internal & b) {
     return ret - b.ret;
   }
 
   inline pointer data() const { return ret; }
   inline difference_type offset() const { return _offset; }
 
 protected:
   difference_type _offset;
   pointer ret;
   pointer initial;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Begin/End functions implementation                                         */
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 /**
  * Get an iterator that behaves like a pointer akantu::Vector<T> * to the
  * first tuple of the array.
  * @param n vector size. Has to be equal to nb_component. This unfortunate
  * redundancy is necessary to distinguish it from ::begin() which it
  * overloads. If compiled in debug mode, an incorrect value of n will result
  * in an exception being thrown. Optimized code will fail in an unpredicted
  * manner.
  * @return a vector_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::vector_iterator
 Array<T, is_scal>::begin(UInt n) {
   AKANTU_DEBUG_ASSERT(nb_component == n,
                       "The iterator is not compatible with the type Array("
                           << n << ")");
   return vector_iterator(new Vector<T>(values, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get an iterator that behaves like a pointer akantu::Vector<T> * pointing
  * *past* the last tuple of the array.
  * @param n vector size. see Array::begin(UInt n) for more
  * @return a vector_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::vector_iterator
 Array<T, is_scal>::end(UInt n) {
   AKANTU_DEBUG_ASSERT(nb_component == n,
                       "The iterator is not compatible with the type Array("
                           << n << ")");
   return vector_iterator(new Vector<T>(values + nb_component * size, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get a const iterator that behaves like a pointer akantu::Vector<T> * to the
  * first tuple of the array.
  * @param n vector size. see Array::begin(UInt n) for more
  * @return a vector_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_vector_iterator
 Array<T, is_scal>::begin(UInt n) const {
   AKANTU_DEBUG_ASSERT(nb_component == n,
                       "The iterator is not compatible with the type Array("
                           << n << ")");
   return const_vector_iterator(new Vector<T>(values, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get a const iterator that behaves like a pointer akantu::Vector<T> * pointing
  * *past* the last tuple of the array.
  * @param n vector size. see Array::begin(UInt n) for more
  * @return a const_vector_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_vector_iterator
 Array<T, is_scal>::end(UInt n) const {
   AKANTU_DEBUG_ASSERT(nb_component == n,
                       "The iterator is not compatible with the type Array("
                           << n << ")");
   return const_vector_iterator(new Vector<T>(values + nb_component * size, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get an iterator that behaves like a pointer akantu::Vector<T> * to the
  * first tuple of the array.
  *
  * The reinterpret iterators allow to iterate over an array in any way that
  * preserves the number of entries of the array. This can for instance be use
  * full if the shape of the data in an array is not initially known.
  * @param n vector size.
  * @param size number of tuples in array. n times size must match the number
  * of entries of the array. If compiled in debug mode, an incorrect
  * combination of n and size will result
  * in an exception being thrown. Optimized code will fail in an unpredicted
  * manner.
  * @return a vector_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::vector_iterator
 Array<T, is_scal>::begin_reinterpret(UInt n,
                                      __attribute__((unused)) UInt size) {
   AKANTU_DEBUG_ASSERT(n * size == this->nb_component * this->size,
                       "The new values for size ("
                           << size << ") and nb_component (" << n
                           << ") are not compatible with the one of this array("
                           << this->size << "," << this->nb_component << ")");
   return vector_iterator(new Vector<T>(values, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get an iterator that behaves like a pointer akantu::Vector<T> * pointing
  * *past* the last tuple of the array.
  * @param n vector size.
  * @param size number of tuples in array. See Array::begin_reinterpret(UInt n,
  * UInt size)
  * @return a vector_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::vector_iterator
 Array<T, is_scal>::end_reinterpret(UInt n, UInt size) {
   AKANTU_DEBUG_ASSERT(n * size == this->nb_component * this->size,
                       "The new values for size ("
                           << size << ") and nb_component (" << n
                           << ") are not compatible with the one of this array("
                           << this->size << "," << this->nb_component << ")");
   return vector_iterator(new Vector<T>(values + n * size, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get a const iterator that behaves like a pointer akantu::Vector<T> * to the
  * first tuple of the array.
  * @param n vector size.
  * @param size number of tuples in array. See Array::begin_reinterpret(UInt n,
  * UInt size)
  * @return a const_vector_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_vector_iterator
 Array<T, is_scal>::begin_reinterpret(UInt n,
                                      __attribute__((unused)) UInt size) const {
   AKANTU_DEBUG_ASSERT(n * size == this->nb_component * this->size,
                       "The new values for size ("
                           << size << ") and nb_component (" << n
                           << ") are not compatible with the one of this array("
                           << this->size << "," << this->nb_component << ")");
   return const_vector_iterator(new Vector<T>(values, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get a const iterator that behaves like a pointer akantu::Vector<T> * pointing
  * *past* the last tuple of the array.
  * @param n vector size.
  * @param size number of tuples in array. See Array::begin_reinterpret(UInt n,
  * UInt size)
  * @return a const_vector_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_vector_iterator
 Array<T, is_scal>::end_reinterpret(UInt n, UInt size) const {
   AKANTU_DEBUG_ASSERT(n * size == this->nb_component * this->size,
                       "The new values for size ("
                           << size << ") and nb_component (" << n
                           << ") are not compatible with the one of this array("
                           << this->size << "," << this->nb_component << ")");
   return const_vector_iterator(new Vector<T>(values + n * size, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get an iterator that behaves like a pointer akantu::Matrix<T> * to the
  * first tuple of the array.
  * @param m number of rows
  * @param n number of columns. m times n has to equal nb_component.
  * If compiled in debug mode, an incorrect combination of m and n will result
  * in an exception being thrown. Optimized code will fail in an unpredicted
  * manner.
  * @return a matrix_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::matrix_iterator
 Array<T, is_scal>::begin(UInt m, UInt n) {
   AKANTU_DEBUG_ASSERT(nb_component == n * m,
                       "The iterator is not compatible with the type Matrix("
                           << m << "," << n << ")");
   return matrix_iterator(new Matrix<T>(values, m, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get an iterator that behaves like a pointer akantu::Matrix<T> * pointing
  * *past* the last tuple of the array.
  * @param m number of rows
  * @param n number of columns. See Array::begin(UInt m, UInt n)
  * @return a matrix_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::matrix_iterator
 Array<T, is_scal>::end(UInt m, UInt n) {
   AKANTU_DEBUG_ASSERT(nb_component == n * m,
                       "The iterator is not compatible with the type Matrix("
                           << m << "," << n << ")");
   return matrix_iterator(new Matrix<T>(values + nb_component * size, m, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get a const iterator that behaves like a pointer akantu::Matrix<T> * to the
  * first tuple of the array.
  * @param m number of rows
  * @param n number of columns. See Array::begin(UInt m, UInt n)
  * @return a matrix_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_matrix_iterator
 Array<T, is_scal>::begin(UInt m, UInt n) const {
   AKANTU_DEBUG_ASSERT(nb_component == n * m,
                       "The iterator is not compatible with the type Matrix("
                           << m << "," << n << ")");
   return const_matrix_iterator(new Matrix<T>(values, m, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get a const iterator that behaves like a pointer akantu::Matrix<T> * pointing
  * *past* the last tuple of the array.
  * @param m number of rows
  * @param n number of columns. See Array::begin(UInt m, UInt n)
  * @return a const_matrix_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_matrix_iterator
 Array<T, is_scal>::end(UInt m, UInt n) const {
   AKANTU_DEBUG_ASSERT(nb_component == n * m,
                       "The iterator is not compatible with the type Matrix("
                           << m << "," << n << ")");
   return const_matrix_iterator(
       new Matrix<T>(values + nb_component * size, m, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get an iterator that behaves like a pointer akantu::Matrix<T> * to the
  * first tuple of the array.
  *
  * The reinterpret iterators allow to iterate over an array in any way that
  * preserves the number of entries of the array. This can for instance be use
  * full if the shape of the data in an array is not initially known.
  * @param m number of rows
  * @param n number of columns
  * @param size number of tuples in array. m times n times size must match the
  *number
  * of entries of the array. If compiled in debug mode, an incorrect
  * combination of m, n and size will result
  * in an exception being thrown. Optimized code will fail in an unpredicted
  * manner.
  * @return a matrix_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::matrix_iterator
 Array<T, is_scal>::begin_reinterpret(UInt m, UInt n,
                                      __attribute__((unused)) UInt size) {
   AKANTU_DEBUG_ASSERT(n * m * size == this->nb_component * this->size,
                       "The new values for size ("
                           << size << ") and nb_component (" << m << "," << n
                           << " = " << n * m
                           << ") are not compatible with the one of this array("
                           << this->size << "," << this->nb_component << ")");
   return matrix_iterator(new Matrix<T>(values, m, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get an iterator that behaves like a pointer akantu::Matrix<T> * pointing
  * *past* the last tuple of the array.
  * @param m number of rows
  * @param n number of columns
  * @param size number of tuples in array. See Array::begin_reinterpret(UInt m,
  * UInt n, UInt size)
  * @return a matrix_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::matrix_iterator
 Array<T, is_scal>::end_reinterpret(UInt m, UInt n, UInt size) {
   AKANTU_DEBUG_ASSERT(n * m * size == this->nb_component * this->size,
                       "The new values for size ("
                           << size << ") and nb_component (" << m << "," << n
                           << " = " << n * m
                           << ") are not compatible with the one of this array("
                           << this->size << "," << this->nb_component << ")");
   return matrix_iterator(new Matrix<T>(values + n * m * size, m, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get a const iterator that behaves like a pointer akantu::Matrix<T> * to the
  * first tuple of the array.
  * @param m number of rows
  * @param n number of columns
  * @param size number of tuples in array. See Array::begin_reinterpret(UInt m,
  * UInt n, UInt size)
  * @return a const_matrix_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_matrix_iterator
 Array<T, is_scal>::begin_reinterpret(UInt m, UInt n,
                                      __attribute__((unused)) UInt size) const {
   AKANTU_DEBUG_ASSERT(n * m * size == this->nb_component * this->size,
                       "The new values for size ("
                           << size << ") and nb_component (" << m << "," << n
                           << " = " << n * m
                           << ") are not compatible with the one of this array("
                           << this->size << "," << this->nb_component << ")");
   return const_matrix_iterator(new Matrix<T>(values, m, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get a const iterator that behaves like a pointer akantu::Matrix<T> * pointing
  * *past* the last tuple of the array.
  * @param m number of rows
  * @param n number of columns
  * @param size number of tuples in array. See Array::begin_reinterpret(UInt m,
  * UInt n, UInt size)
  * @return a const_matrix_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_matrix_iterator
 Array<T, is_scal>::end_reinterpret(UInt m, UInt n, UInt size) const {
   AKANTU_DEBUG_ASSERT(n * m * size == this->nb_component * this->size,
                       "The new values for size ("
                           << size << ") and nb_component (" << m << "," << n
                           << " = " << n * m
                           << ") are not compatible with the one of this array("
                           << this->size << "," << this->nb_component << ")");
   return const_matrix_iterator(new Matrix<T>(values + n * m * size, m, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /** Get an iterator that behaves like a pointer T * to the
  *  first entry in the member array values
  *  @return a scalar_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::scalar_iterator Array<T, is_scal>::begin() {
   AKANTU_DEBUG_ASSERT(
       nb_component == 1,
       "this iterator cannot be used on a vector which has nb_component != 1");
   return scalar_iterator(values);
 }
 
 /* -------------------------------------------------------------------------- */
 /*! Get an iterator that behaves like a pointer T * that points *past* the
  *  last entry in the member array values
  *  @return a scalar_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::scalar_iterator Array<T, is_scal>::end() {
   AKANTU_DEBUG_ASSERT(
       nb_component == 1,
       "this iterator cannot be used on a array which has nb_component != 1");
   return scalar_iterator(values + size);
 }
 
 /* -------------------------------------------------------------------------- */
 /*! Get a const iterator that behaves like a pointer T * to the
  *  first entry in the member array values
  *  @return a const_scalar_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_scalar_iterator
 Array<T, is_scal>::begin() const {
   AKANTU_DEBUG_ASSERT(
       nb_component == 1,
       "this iterator cannot be used on a array which has nb_component != 1");
   return const_scalar_iterator(values);
 }
 
 /* -------------------------------------------------------------------------- */
 /*! Get a const iterator that behaves like a pointer T * that points *past* the
  *  last entry in the member array values
  *  @return a const_scalar_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_scalar_iterator
 Array<T, is_scal>::end() const {
   AKANTU_DEBUG_ASSERT(
       nb_component == 1,
       "this iterator cannot be used on a array which has nb_component != 1");
   return const_scalar_iterator(values + size);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::scalar_iterator
 Array<T, is_scal>::begin_reinterpret(__attribute__((unused)) UInt new_size) {
   AKANTU_DEBUG_ASSERT(new_size == this->nb_component * this->size,
                       "The new values for size ("
                           << new_size
                           << ") is not compatible with the one of this array("
                           << this->size << "," << this->nb_component << ")");
   return scalar_iterator(values);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::scalar_iterator
 Array<T, is_scal>::end_reinterpret(UInt new_size) {
   AKANTU_DEBUG_ASSERT(new_size == this->nb_component * this->size,
                       "The new values for size ("
                           << new_size
                           << ") is not compatible with the one of this array("
                           << this->size << "," << this->nb_component << ")");
   return scalar_iterator(values + new_size);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_scalar_iterator
 Array<T, is_scal>::begin_reinterpret(__attribute__((unused))
                                      UInt new_size) const {
   AKANTU_DEBUG_ASSERT(new_size == this->nb_component * this->size,
                       "The new values for size ("
                           << new_size
                           << ") is not compatible with the one of this array("
                           << this->size << "," << this->nb_component << ")");
   return const_scalar_iterator(values);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_scalar_iterator
 Array<T, is_scal>::end_reinterpret(UInt new_size) const {
   AKANTU_DEBUG_ASSERT(new_size == this->nb_component * this->size,
                       "The new values for size ("
                           << new_size
                           << ") is not compatible with the one of this array("
                           << this->size << "," << this->nb_component << ")");
   return const_scalar_iterator(values + new_size);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <typename R>
 class Array<T, is_scal>::const_iterator : public iterator_internal<const R, R> {
 public:
   typedef iterator_internal<const R, 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<R> & it) : parent(it) {}
 
   inline const_iterator operator+(difference_type n) {
     return parent::operator+(n);
   }
   inline const_iterator operator-(difference_type n) {
     return parent::operator-(n);
   }
   inline difference_type operator-(const const_iterator & b) {
     return parent::operator-(b);
   }
 
   inline const_iterator & operator++() {
     parent::operator++();
     return *this;
   };
   inline const_iterator & operator--() {
     parent::operator--();
     return *this;
   };
   inline const_iterator & operator+=(const UInt n) {
     parent::operator+=(n);
     return *this;
   }
 };
 // #endif
 
 // #if defined(AKANTU_CORE_CXX11)
 //   template<class R> using iterator = iterator_internal<R>;
 // #else
 template <class T, class R, bool issame = is_same<T, R>::value>
 struct ConstConverterIteratorHelper {
   using const_iterator = typename Array<T>::template const_iterator<R>;
   using iterator = typename Array<T>::template iterator<R>;
   static inline const_iterator convert(const iterator & it) {
     return const_iterator(new R(*it, false));
   }
 };
 
 template <class T, class R> struct ConstConverterIteratorHelper<T, R, true> {
   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(), it.offset());
   }
 };
 
 template <class T, bool is_scal>
 template <typename R>
 class Array<T, is_scal>::iterator : public iterator_internal<R> {
 public:
   using parent = iterator_internal<R>;
   using value_type = typename parent::value_type;
   using pointer = typename parent::pointer;
   using reference = typename parent::reference;
   using difference_type = typename parent::difference_type;
   using iterator_category = typename parent::iterator_category;
 
 public:
   iterator() : parent(){};
   iterator(pointer_type data, UInt offset) : parent(data, offset){};
   iterator(pointer warped) : parent(warped) {}
   iterator(const parent & it) : parent(it) {}
   //    iterator(const iterator<R> & it) : parent(it) {}
 
   operator const_iterator<R>() {
     return ConstConverterIteratorHelper<T, R>::convert(*this);
   }
 
   inline iterator operator+(difference_type n) {
     return parent::operator+(n);
     ;
   }
   inline iterator operator-(difference_type n) {
     return parent::operator-(n);
     ;
   }
   inline difference_type operator-(const iterator & b) {
     return parent::operator-(b);
   }
 
   inline iterator & operator++() {
     parent::operator++();
     return *this;
   };
   inline iterator & operator--() {
     parent::operator--();
     return *this;
   };
   inline iterator & operator+=(const UInt n) {
     parent::operator+=(n);
     return *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;
 }
 
 
 } // akantu
 
 #endif /* __AKANTU_AKA_ARRAY_TMPL_HH__ */
diff --git a/src/common/aka_error.cc b/src/common/aka_error.cc
index e71573b08..3801b8cb6 100644
--- a/src/common/aka_error.cc
+++ b/src/common/aka_error.cc
@@ -1,351 +1,352 @@
 /**
  * @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_config.hh"
 #include "aka_error.hh"
 #include "aka_common.hh"
+#include "aka_config.hh"
 /* -------------------------------------------------------------------------- */
-#include <iostream>
 #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 <cmath>
-#include <cstring>
 #include <map>
 #include <sys/types.h>
 #include <unistd.h>
 
 #if defined(AKANTU_CORE_CXX11)
-#  include <chrono>
+#include <chrono>
 #elif defined(AKANTU_USE_OBSOLETE_GETTIMEOFDAY)
-#  include <sys/time.h>
+#include <sys/time.h>
 #else
-#  include <time.h>
+#include <time.h>
 #endif
 
 #ifdef AKANTU_USE_MPI
 #include <mpi.h>
 #endif
 
 #define __BEGIN_AKANTU_DEBUG__                                                 \
   namespace akantu {                                                           \
   namespace debug {
 #define __END_AKANTU_DEBUG__                                                   \
   }                                                                            \
   }
 
 /* -------------------------------------------------------------------------- */
 
 __BEGIN_AKANTU_DEBUG__
 
 static void printBacktraceAndExit(int sig) {
   if (debugger.printBacktrace())
     printBacktrace(sig);
   debugger.exit(-50);
 }
 
 /* ------------------------------------------------------------------------ */
 void initSignalHandler() {
   std::signal(SIGSEGV, &printBacktraceAndExit);
   std::signal(SIGABRT, &printBacktraceAndExit);
 }
 
 /* ------------------------------------------------------------------------ */
 std::string demangle(const char * symbol) {
   int status;
   std::string result;
   char * demangled_name;
 
   if ((demangled_name = abi::__cxa_demangle(symbol, NULL, 0, &status)) !=
       NULL) {
     result = demangled_name;
     free(demangled_name);
   } else {
     result = symbol;
   }
 
   return result;
 }
 
 /* ------------------------------------------------------------------------ */
-#if (defined(READLINK_COMMAND) || defined(ADDR2LINK_COMMAND)) &&        \
-  (not defined(_WIN32))
+#if (defined(READLINK_COMMAND) || defined(ADDR2LINK_COMMAND)) &&               \
+    (not defined(_WIN32))
 std::string exec(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) != NULL)
       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);
 
   /// -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);
       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
 }
 
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 Debugger::Debugger() {
   cout = &std::cerr;
   level = dblWarning;
   parallel_context = "";
   file_open = false;
   print_backtrace = false;
 }
 
 /* ------------------------------------------------------------------------ */
 Debugger::~Debugger() {
   if (file_open) {
     dynamic_cast<std::ofstream *>(cout)->close();
     delete cout;
   }
 }
 
 /* ------------------------------------------------------------------------ */
 void Debugger::exit(int status) {
   if (status != EXIT_SUCCESS && status != -50) {
 #ifndef AKANTU_NDEBUG
     int * a = NULL;
     *a = 1;
 #endif
     if (this->print_backtrace)
       akantu::debug::printBacktrace(15);
   }
 
 #ifdef AKANTU_USE_MPI
   if (status != EXIT_SUCCESS)
     MPI_Abort(MPI_COMM_WORLD, MPI_ERR_UNKNOWN);
 #endif
 
   std::exit(
       status); // not  called when compiled  with MPI  due to  MPI_Abort, but
   // MPI_Abort does not have the noreturn attribute
 }
 
 /*------------------------------------------------------------------------- */
 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
-    throw(akantu::debug::Exception) {
+    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();
+    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;
+    *(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());
   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); }
 
 __END_AKANTU_DEBUG__
diff --git a/src/common/aka_error.hh b/src/common/aka_error.hh
index d10e1a59e..055b1e008 100644
--- a/src/common/aka_error.hh
+++ b/src/common/aka_error.hh
@@ -1,340 +1,332 @@
 /**
  * @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/>.
  *
  */
-
-/* -------------------------------------------------------------------------- */
-#ifndef __AKANTU_ERROR_HH__
-#define __AKANTU_ERROR_HH__
-
 /* -------------------------------------------------------------------------- */
-#include <cstdlib>
-#include <ostream>
 #include <sstream>
 #include <typeinfo>
 #include <utility>
 /* -------------------------------------------------------------------------- */
-namespace akantu {
 
+/* -------------------------------------------------------------------------- */
+#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);
 
   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:
     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() throw() override = default;
+    ~Exception() noexcept override = default;
 
     /* ---------------------------------------------------------------------- */
     /*  Methods */
     /* ---------------------------------------------------------------------- */
   public:
-    const char * what() const throw() override { return _info.c_str(); }
+    const char * what() const noexcept override { return _info.c_str(); }
 
-    virtual const char * info() const throw() {
+    virtual const std::string info() const noexcept {
       std::stringstream stream;
       stream << debug::demangle(typeid(*this).name()) << " : " << _info << " ["
              << _file << ":" << _line << "]";
-      return stream.str().c_str();
+      return stream.str();
     }
 
   public:
-    void setInfo(std::string info) { _info = info; }
-    void setFile(std::string file) { _file = file; }
+    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                                                          */
     /* ---------------------------------------------------------------------- */
   private:
     /// exception description and additionals
     std::string _info;
 
     /// file it is thrown from
     std::string _file;
 
     /// ligne it is thrown from
     unsigned int _line{0};
   };
 
   /// 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();
 
     void exit(int status) __attribute__((noreturn));
 
     void throwException(const std::string & info, const std::string & file,
-                        unsigned int line, __attribute__((unused)) bool silent,
-                        __attribute__((unused))
-                        const std::string & location) const
-        throw(akantu::debug::Exception) __attribute__((noreturn));
+                        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
-        throw(Except) __attribute__((noreturn));
+        noexcept(false) __attribute__((noreturn));
     /*----------------------------------------------------------------------- */
     template <class Except>
     void throwCustomException(const Except & ex, const std::string & file,
-                              unsigned int line) const throw(Except)
+                              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_EXCEPTION(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 (!(test)) {                                                             \
-      AKANTU_DEBUG_("!!! ", ::akantu::dblAssert, "assert [" << #test << "] "   \
-                                                            << info);          \
+      AKANTU_DEBUG_("!!! ", ::akantu::dblAssert,                               \
+                    "assert [" << #test << "] " << info);                      \
       ::akantu::debug::debugger.exit(EXIT_FAILURE);                            \
     }                                                                          \
   } while (false)
 
 #define AKANTU_DEBUG_ERROR(info)                                               \
   do {                                                                         \
     AKANTU_DEBUG_("!!! ", ::akantu::dblError, info);                           \
     ::akantu::debug::debugger.exit(EXIT_FAILURE);                              \
   } 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 throw(Except) {
+                                      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 throw(Except) {
+                                      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/fe_engine/element_type_conversion.hh b/src/fe_engine/element_type_conversion.hh
index 76b3d9b56..bbd629113 100644
--- a/src/fe_engine/element_type_conversion.hh
+++ b/src/fe_engine/element_type_conversion.hh
@@ -1,54 +1,53 @@
 /**
  * @file   element_type_conversion.hh
  *
  * @author Nicolas Richart
  *
  * @date creation  Thu Jul 27 2017
  *
  * @brief conversion between different types
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "element_class.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_ELEMENT_TYPE_CONVERSION_HH__
 #define __AKANTU_ELEMENT_TYPE_CONVERSION_HH__
 
 namespace akantu {
 
 template<class InType, class OutType>
 OutType convertType(const InType &) { return OutType(); }
 
 template<>
 inline InterpolationType convertType<ElementType, InterpolationType>(const ElementType & type) {
   InterpolationType itp_type = _itp_not_defined;
 #define GET_ITP(type) itp_type = ElementClassProperty<type>::interpolation_type;
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_ITP);
 #undef GET_ITP
   return itp_type;
 }
 
-
 } // namespace akantu
 
 #endif /* __AKANTU_ELEMENT_TYPE_CONVERSION_HH__ */
diff --git a/src/fe_engine/fe_engine_inline_impl.cc b/src/fe_engine/fe_engine_inline_impl.cc
index ac8311869..a4350ad4c 100644
--- a/src/fe_engine/fe_engine_inline_impl.cc
+++ b/src/fe_engine/fe_engine_inline_impl.cc
@@ -1,198 +1,199 @@
 /**
  * @file   fe_engine_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Jul 20 2010
  * @date last modification: Sat Sep 05 2015
  *
  * @brief  Implementation of the inline functions 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 "mesh.hh"
 #include "element_class.hh"
+/* -------------------------------------------------------------------------- */
 #include "element_type_conversion.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_FE_ENGINE_INLINE_IMPL_CC__
 #define __AKANTU_FE_ENGINE_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline Real FEEngine::getElementInradius(const Matrix<Real> & coord,
                                          const ElementType & type) {
   AKANTU_DEBUG_IN();
 
   Real inradius = 0;
 
 #define GET_INRADIUS(type) inradius = ElementClass<type>::getInradius(coord);
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_INRADIUS);
 #undef GET_INRADIUS
 
   AKANTU_DEBUG_OUT();
   return inradius;
 }
 
 /* -------------------------------------------------------------------------- */
 inline InterpolationType
 FEEngine::getInterpolationType(const ElementType & type) {
   return convertType<ElementType, InterpolationType>(type);
 }
 
 /* -------------------------------------------------------------------------- */
 /// @todo rewrite this function in order to get the cohesive element
 /// type directly from the facet
 #if defined(AKANTU_COHESIVE_ELEMENT)
 inline ElementType FEEngine::getCohesiveElementType(const ElementType & type) {
   AKANTU_DEBUG_IN();
 
   ElementType ctype;
 #define GET_COHESIVE_TYPE(type)                                                \
   ctype = CohesiveFacetProperty<type>::cohesive_type;
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_COHESIVE_TYPE);
 #undef GET_COHESIVE_TYPE
 
   AKANTU_DEBUG_OUT();
   return ctype;
 }
 #else
 inline ElementType
 FEEngine::getCohesiveElementType(__attribute__((unused))
                                  const ElementType & type_facet) {
   return _not_defined;
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_IGFEM)
 } // akantu
 #include "igfem_helper.hh"
 namespace akantu {
 
 inline Vector<ElementType>
 FEEngine::getIGFEMElementTypes(const ElementType & type) {
 
 #define GET_IGFEM_ELEMENT_TYPES(type)                                          \
   return IGFEMHelper::getIGFEMElementTypes<type>();
 
   AKANTU_BOOST_REGULAR_ELEMENT_SWITCH(GET_IGFEM_ELEMENT_TYPES);
 
 #undef GET_IGFEM_ELEMENT_TYPES
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void FEEngine::extractNodalToElementField(const Mesh & mesh,
                                           const Array<T> & nodal_f,
                                           Array<T> & elemental_f,
                                           const ElementType & type,
                                           const GhostType & ghost_type,
                                           const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_degree_of_freedom = nodal_f.getNbComponent();
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   UInt * conn_val = mesh.getConnectivity(type, ghost_type).storage();
 
   if (filter_elements != empty_filter) {
     nb_element = filter_elements.getSize();
   }
 
   elemental_f.resize(nb_element);
 
   T * nodal_f_val = nodal_f.storage();
   T * f_val = elemental_f.storage();
 
   UInt * el_conn;
   for (UInt el = 0; el < nb_element; ++el) {
     if (filter_elements != empty_filter)
       el_conn = conn_val + filter_elements(el) * nb_nodes_per_element;
     else
       el_conn = conn_val + el * nb_nodes_per_element;
 
     for (UInt n = 0; n < nb_nodes_per_element; ++n) {
       UInt node = *(el_conn + n);
       std::copy(nodal_f_val + node * nb_degree_of_freedom,
                 nodal_f_val + (node + 1) * nb_degree_of_freedom, f_val);
       f_val += nb_degree_of_freedom;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void FEEngine::filterElementalData(const Mesh & mesh, const Array<T> & elem_f,
                                    Array<T> & filtered_f,
                                    const ElementType & type,
                                    const GhostType & ghost_type,
                                    const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (nb_element == 0) {
     filtered_f.resize(0);
     return;
   }
 
   UInt nb_degree_of_freedom = elem_f.getNbComponent();
   UInt nb_data_per_element = elem_f.getSize() / nb_element;
 
   if (filter_elements != empty_filter) {
     nb_element = filter_elements.getSize();
   }
 
   filtered_f.resize(nb_element * nb_data_per_element);
 
   T * elem_f_val = elem_f.storage();
   T * f_val = filtered_f.storage();
 
   UInt el_offset;
   for (UInt el = 0; el < nb_element; ++el) {
     if (filter_elements != empty_filter)
       el_offset = filter_elements(el);
     else
       el_offset = el;
 
     std::copy(elem_f_val +
                   el_offset * nb_data_per_element * nb_degree_of_freedom,
               elem_f_val +
                   (el_offset + 1) * nb_data_per_element * nb_degree_of_freedom,
               f_val);
     f_val += nb_degree_of_freedom * nb_data_per_element;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // akantu
 
 #endif /* __AKANTU_FE_ENGINE_INLINE_IMPL_CC__ */