diff --git a/examples/explicit/explicit_dynamic.cc b/examples/explicit/explicit_dynamic.cc
index e640a7344..c03506e49 100644
--- a/examples/explicit/explicit_dynamic.cc
+++ b/examples/explicit/explicit_dynamic.cc
@@ -1,106 +1,113 @@
 /**
  * @file   explicit_dynamic.cc
  *
  * @author Seyedeh Mohadeseh Taheri Mousavi <mohadeseh.taherimousavi@epfl.ch>
  *
  * @date creation: Sun Jul 12 2015
  * @date last modification: Mon Jan 18 2016
  *
  * @brief  This code refers to the explicit dynamic example from the user manual
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
   initialize("material.dat", argc, argv);
 
   const UInt spatial_dimension = 3;
   const Real pulse_width = 2.;
   const Real A = 0.01;
   Real time_step;
   Real time_factor = 0.8;
   UInt max_steps = 1000;
 
   Mesh mesh(spatial_dimension);
 
-  mesh.read("bar.msh");
+  if(Communicator::getStaticCommunicator().whoAmI() == 0)
+    mesh.read("bar.msh");
+
+  mesh.distribute();
+
+  mesh.makePeriodic(_x);
+  mesh.makePeriodic(_y);
+  mesh.makePeriodic(_z);
 
   SolidMechanicsModel model(mesh);
 
   /// model initialization
   model.initFull(_analysis_method = _explicit_lumped_mass);
 
   time_step = model.getStableTimeStep();
   std::cout << "Time Step = " << time_step * time_factor << "s (" << time_step
             << "s)" << std::endl;
   model.setTimeStep(time_step * time_factor);
 
   /// boundary and initial conditions
   Array<Real> & displacement = model.getDisplacement();
   const Array<Real> & nodes = mesh.getNodes();
 
   for (UInt n = 0; n < mesh.getNbNodes(); ++n) {
-    Real x = nodes(n);
+    Real x = nodes(n) - 2;
     // Sinus * Gaussian
     Real L = pulse_width;
     Real k = 0.1 * 2 * M_PI * 3 / L;
     displacement(n) = A * sin(k * x) * exp(-(k * x) * (k * x) / (L * L));
   }
 
   std::ofstream energy;
   energy.open("energy.csv");
 
   energy << "id,rtime,epot,ekin,tot" << std::endl;
 
   model.setBaseName("explicit_dynamic");
   model.addDumpField("displacement");
   model.addDumpField("velocity");
   model.addDumpField("acceleration");
   model.addDumpField("stress");
   model.dump();
 
   for (UInt s = 1; s <= max_steps; ++s) {
     model.solveStep();
 
     Real epot = model.getEnergy("potential");
     Real ekin = model.getEnergy("kinetic");
 
     energy << s << "," << s * time_step << "," << epot << "," << ekin << ","
            << epot + ekin << "," << std::endl;
 
     if (s % 10 == 0)
       std::cout << "passing step " << s << "/" << max_steps << std::endl;
     model.dump();
   }
 
   energy.close();
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/src/common/aka_array.cc b/src/common/aka_array.cc
index 9c273ed17..b31c3248d 100644
--- a/src/common/aka_array.cc
+++ b/src/common/aka_array.cc
@@ -1,123 +1,117 @@
 /**
  * @file   aka_array.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Feb 20 2018
  *
  * @brief  Implementation of akantu::Array
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <memory>
 #include <utility>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "aka_common.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* Functions ArrayBase                                                       */
 /* -------------------------------------------------------------------------- */
-ArrayBase::ArrayBase(ID id)
-    : id(std::move(id)), allocated_size(0), size_(0), nb_component(1),
-      size_of_type(0) {}
-
-/* -------------------------------------------------------------------------- */
-ArrayBase::~ArrayBase() = default;
 
 /* -------------------------------------------------------------------------- */
 void ArrayBase::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
   stream << space << "ArrayBase [" << std::endl;
   stream << space << " + size             : " << size_ << std::endl;
   stream << space << " + nb component     : " << nb_component << std::endl;
   stream << space << " + allocated size   : " << allocated_size << std::endl;
   Real mem_size = (allocated_size * nb_component * size_of_type) / 1024.;
   stream << space << " + size of type     : " << size_of_type << "B"
          << std::endl;
   stream << space << " + memory allocated : " << mem_size << "kB" << std::endl;
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 template <> UInt Array<Real>::find(const Real & elem) const {
   AKANTU_DEBUG_IN();
 
   Real epsilon = std::numeric_limits<Real>::epsilon();
   auto it = std::find_if(begin(), end(), [&elem, &epsilon](auto && a) {
     return std::abs(a - elem) <= epsilon;
   });
 
   AKANTU_DEBUG_OUT();
   return (it != end()) ? end() - it : UInt(-1);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 Array<ElementType> & Array<ElementType>::operator*=(__attribute__((unused))
                                                     const ElementType & alpha) {
   AKANTU_TO_IMPLEMENT();
   return *this;
 }
 
 template <>
 Array<ElementType> & Array<ElementType>::
 operator-=(__attribute__((unused)) const Array<ElementType> & vect) {
   AKANTU_TO_IMPLEMENT();
   return *this;
 }
 
 template <>
 Array<ElementType> & Array<ElementType>::
 operator+=(__attribute__((unused)) const Array<ElementType> & vect) {
   AKANTU_TO_IMPLEMENT();
   return *this;
 }
 
 template <>
 Array<char> & Array<char>::operator*=(__attribute__((unused))
                                       const char & alpha) {
   AKANTU_TO_IMPLEMENT();
   return *this;
 }
 
 template <>
 Array<char> & Array<char>::operator-=(__attribute__((unused))
                                       const Array<char> & vect) {
   AKANTU_TO_IMPLEMENT();
   return *this;
 }
 
 template <>
 Array<char> & Array<char>::operator+=(__attribute__((unused))
                                       const Array<char> & vect) {
   AKANTU_TO_IMPLEMENT();
   return *this;
 }
 
 } // namespace akantu
diff --git a/src/common/aka_array.hh b/src/common/aka_array.hh
index a75bd18ed..2a36fd1e7 100644
--- a/src/common/aka_array.hh
+++ b/src/common/aka_array.hh
@@ -1,371 +1,381 @@
 /**
  * @file   aka_array.hh
  *
  * @author Till Junge <till.junge@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Jan 16 2018
  *
  * @brief  Array container for Akantu
  * This container differs from the std::vector from the fact it as 2 dimensions
  * a main dimension and the size stored per entries
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_VECTOR_HH__
 #define __AKANTU_VECTOR_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 /* -------------------------------------------------------------------------- */
 #include <typeinfo>
 #include <vector>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /// class that afford to store vectors in static memory
 class ArrayBase {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-  explicit ArrayBase(ID id = "");
+  explicit ArrayBase(ID id = "") : id(std::move(id)) {}
+
+  ArrayBase(const ArrayBase & other) = default;
+  ArrayBase(ArrayBase && other) = default;
+
+  ArrayBase & operator=(const ArrayBase & other) = default;
+  //ArrayBase & operator=(ArrayBase && other) = default;
+
+  virtual ~ArrayBase() = default;
+
 
-  virtual ~ArrayBase();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the amount of space allocated in bytes
   inline UInt getMemorySize() const;
 
   /// set the size to zero without freeing the allocated space
   inline void empty();
 
   /// function to print the containt of the class
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors */
   /* ------------------------------------------------------------------------ */
 public:
   /// Get the real size allocated in memory
   AKANTU_GET_MACRO(AllocatedSize, allocated_size, UInt);
   /// Get the Size of the Array
   UInt getSize() const __attribute__((deprecated)) { return size_; }
   UInt size() const { return size_; }
   /// Get the number of components
   AKANTU_GET_MACRO(NbComponent, nb_component, UInt);
   /// Get the name of th array
   AKANTU_GET_MACRO(ID, id, const ID &);
   /// Set the name of th array
   AKANTU_SET_MACRO(ID, id, const ID &);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// id of the vector
   ID id;
 
   /// the size allocated
   UInt allocated_size{0};
 
   /// the size used
   UInt size_{0};
 
   /// number of components
   UInt nb_component{1};
 
   /// size of the stored type
   UInt size_of_type{0};
 };
 
 /* -------------------------------------------------------------------------- */
 namespace {
   template <std::size_t dim, typename T> struct IteratorHelper {};
 
   template <typename T> struct IteratorHelper<0, T> { using type = T; };
   template <typename T> struct IteratorHelper<1, T> { using type = Vector<T>; };
   template <typename T> struct IteratorHelper<2, T> { using type = Matrix<T>; };
   template <typename T> struct IteratorHelper<3, T> {
     using type = Tensor3<T>;
   };
 
   template <std::size_t dim, typename T>
   using IteratorHelper_t = typename IteratorHelper<dim, T>::type;
 } // namespace
 
 /* -------------------------------------------------------------------------- */
 template <typename T, bool is_scal> class Array : public ArrayBase {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   using value_type = T;
   using reference = value_type &;
   using pointer_type = value_type *;
   using const_reference = const value_type &;
 
+  inline ~Array() override;
+
   /// Allocation of a new vector
   explicit inline Array(UInt size = 0, UInt nb_component = 1,
                         const ID & id = "");
 
   /// Allocation of a new vector with a default value
   Array(UInt size, UInt nb_component, const value_type def_values[],
         const ID & id = "");
 
   /// Allocation of a new vector with a default value
   Array(UInt size, UInt nb_component, const_reference value,
         const ID & id = "");
 
   /// Copy constructor (deep copy if deep=true)
-  Array(const Array<value_type, is_scal> & vect, bool deep = true,
+  Array(const Array<value_type, is_scal> & vect, //bool deep = true,
         const ID & id = "");
 
 #ifndef SWIG
   /// Copy constructor (deep copy)
   explicit Array(const std::vector<value_type> & vect);
 #endif
 
-  inline ~Array() override;
+  // copy operator
+  Array & operator=(const Array & other);
+
+  // move constructor
+  Array(Array && other);
 
-  Array & operator=(const Array & a) {
-    /// this is to let STL allocate and copy arrays in the case of
-    /// std::vector::resize
-    AKANTU_DEBUG_ASSERT(this->size_ == 0, "Cannot copy akantu::Array");
-    return const_cast<Array &>(a);
-  }
+  // move assign
+  Array & operator=(Array && other);
 
 #ifndef SWIG
   /* ------------------------------------------------------------------------ */
   /* Iterator                                                                 */
   /* ------------------------------------------------------------------------ */
   /// \todo protected: does not compile with intel  check why
 public:
   template <class R, class it, class IR = R,
             bool is_tensor_ = is_tensor<R>::value>
   class iterator_internal;
 
 public:
   /* ------------------------------------------------------------------------ */
 
   /* ------------------------------------------------------------------------ */
   template <typename R = T> class const_iterator;
   template <typename R = T> class iterator;
 
   /* ------------------------------------------------------------------------ */
 
   /// iterator for Array of nb_component = 1
   using scalar_iterator = iterator<T>;
   /// const_iterator for Array of nb_component = 1
   using const_scalar_iterator = const_iterator<T>;
 
   /// iterator returning Vectors of size n  on entries of Array with
   /// nb_component = n
   using vector_iterator = iterator<Vector<T>>;
   /// const_iterator returning Vectors of n size on entries of Array with
   /// nb_component = n
   using const_vector_iterator = const_iterator<Vector<T>>;
 
   /// iterator returning Matrices of size (m, n) on entries of Array with
   /// nb_component = m*n
   using matrix_iterator = iterator<Matrix<T>>;
   /// const iterator returning Matrices of size (m, n) on entries of Array with
   /// nb_component = m*n
   using const_matrix_iterator = const_iterator<Matrix<T>>;
 
   /// iterator returning Tensor3 of size (m, n, k) on entries of Array with
   /// nb_component = m*n*k
   using tensor3_iterator = iterator<Tensor3<T>>;
   /// const iterator returning Tensor3 of size (m, n, k) on entries of Array
   /// with nb_component = m*n*k
   using const_tensor3_iterator = const_iterator<Tensor3<T>>;
 
   /* ------------------------------------------------------------------------ */
   template <typename... Ns> inline decltype(auto) begin(Ns &&... n);
   template <typename... Ns> inline decltype(auto) end(Ns &&... n);
 
   template <typename... Ns> inline decltype(auto) begin(Ns &&... n) const;
   template <typename... Ns> inline decltype(auto) end(Ns &&... n) const;
 
   template <typename... Ns> inline decltype(auto) begin_reinterpret(Ns &&... n);
   template <typename... Ns> inline decltype(auto) end_reinterpret(Ns &&... n);
 
   template <typename... Ns>
   inline decltype(auto) begin_reinterpret(Ns &&... n) const;
   template <typename... Ns>
   inline decltype(auto) end_reinterpret(Ns &&... n) const;
 #endif // SWIG
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// append a tuple of size nb_component containing value
   inline void push_back(const_reference value);
 /// append a vector
 // inline void push_back(const value_type new_elem[]);
 
 #ifndef SWIG
   /// append a Vector or a Matrix
   template <template <typename> class C,
             typename = std::enable_if_t<is_tensor<C<T>>::value>>
   inline void push_back(const C<T> & new_elem);
   /// append the value of the iterator
   template <typename Ret> inline void push_back(const iterator<Ret> & it);
 
   /// erase the value at position i
   inline void erase(UInt i);
   /// ask Nico, clarify
   template <typename R> inline iterator<R> erase(const iterator<R> & it);
 #endif
 
   /// changes the allocated size but not the size
   virtual void reserve(UInt size);
 
   /// change the size of the Array
   virtual void resize(UInt size);
 
   /// change the size of the Array and initialize the values
   virtual void resize(UInt size, const T & val);
 
   /// change the number of components by interlacing data
   /// @param multiplicator number of interlaced components add
   /// @param block_size blocks of data in the array
   /// Examaple for block_size = 2, multiplicator = 2
   /// array = oo oo oo -> new array = oo nn nn oo nn nn oo nn nn
   void extendComponentsInterlaced(UInt multiplicator, UInt stride);
 
   /// search elem in the vector, return  the position of the first occurrence or
   /// -1 if not found
   UInt find(const_reference elem) const;
 
   /// @see Array::find(const_reference elem) const
   UInt find(T elem[]) const;
 
 #ifndef SWIG
   /// @see Array::find(const_reference elem) const
   template <template <typename> class C,
             typename = std::enable_if_t<is_tensor<C<T>>::value>>
   inline UInt find(const C<T> & elem);
 #endif
 
   /// set all entries of the array to 0
   inline void clear() { std::fill_n(values, size_ * nb_component, T()); }
 
   /// set all entries of the array to the value t
   /// @param t value to fill the array with
   inline void set(T t) { std::fill_n(values, size_ * nb_component, t); }
 
 #ifndef SWIG
   /// set all tuples of the array to a given vector or matrix
   /// @param vm Matrix or Vector to fill the array with
   template <template <typename> class C,
             typename = std::enable_if_t<is_tensor<C<T>>::value>>
   inline void set(const C<T> & vm);
 #endif
 
   /// Append the content of the other array to the current one
   void append(const Array<T> & other);
 
   /// copy another Array in the current Array, the no_sanity_check allows you to
   /// force the copy in cases where you know what you do with two non matching
   /// Arrays in terms of n
   void copy(const Array<T, is_scal> & other, bool no_sanity_check = false);
 
   /// give the address of the memory allocated for this vector
   T * storage() const { return values; };
 
   /// function to print the containt of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
 protected:
   /// perform the allocation for the constructors
   void allocate(UInt size, UInt nb_component = 1);
 
   /// resize initializing with uninitialized_fill if fill is set
   void resizeUnitialized(UInt new_size, bool fill, const T & val = T());
 
   /* ------------------------------------------------------------------------ */
   /* Operators                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// substraction entry-wise
   Array<T, is_scal> & operator-=(const Array<T, is_scal> & other);
   /// addition entry-wise
   Array<T, is_scal> & operator+=(const Array<T, is_scal> & other);
   /// multiply evry entry by alpha
   Array<T, is_scal> & operator*=(const T & alpha);
 
   /// check if the array are identical entry-wise
   bool operator==(const Array<T, is_scal> & other) const;
   /// @see Array::operator==(const Array<T, is_scal> & other) const
   bool operator!=(const Array<T, is_scal> & other) const;
 
   /// return a reference to the j-th entry of the i-th tuple
   inline reference operator()(UInt i, UInt j = 0);
   /// return a const reference to the j-th entry of the i-th tuple
   inline const_reference operator()(UInt i, UInt j = 0) const;
 
   /// return a reference to the ith component of the 1D array
   inline reference operator[](UInt i);
   /// return a const reference to the ith component of the 1D array
   inline const_reference operator[](UInt i) const;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// array of values
   T * values; // /!\ very dangerous
 };
 
 /* -------------------------------------------------------------------------- */
 /* Inline Functions Array<T, is_scal>                                         */
 /* -------------------------------------------------------------------------- */
 template <typename T, bool is_scal>
 inline std::ostream & operator<<(std::ostream & stream,
                                  const Array<T, is_scal> & _this) {
   _this.printself(stream);
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /* Inline Functions ArrayBase                                                 */
 /* -------------------------------------------------------------------------- */
 inline std::ostream & operator<<(std::ostream & stream,
                                  const ArrayBase & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #include "aka_array_tmpl.hh"
 #include "aka_types.hh"
 
 #endif /* __AKANTU_VECTOR_HH__ */
diff --git a/src/common/aka_array_tmpl.hh b/src/common/aka_array_tmpl.hh
index e5145384e..44dc7e3e3 100644
--- a/src/common/aka_array_tmpl.hh
+++ b/src/common/aka_array_tmpl.hh
@@ -1,1278 +1,1307 @@
 /**
  * @file   aka_array_tmpl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Jul 15 2010
  * @date last modification: Tue Feb 20 2018
  *
  * @brief  Inline functions of the classes Array<T> and ArrayBase
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 /* Inline Functions Array<T>                                                 */
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 /* -------------------------------------------------------------------------- */
 #include <memory>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_ARRAY_TMPL_HH__
 #define __AKANTU_AKA_ARRAY_TMPL_HH__
 
 namespace akantu {
 
 namespace debug {
   struct ArrayException : public Exception {};
 } // namespace debug
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline T & Array<T, is_scal>::operator()(UInt i, UInt j) {
   AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < size_) && (j < nb_component),
                       "The value at position ["
                           << i << "," << j << "] is out of range in array \""
                           << id << "\"");
   return values[i * nb_component + j];
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline const T & Array<T, is_scal>::operator()(UInt i, UInt j) const {
   AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < size_) && (j < nb_component),
                       "The value at position ["
                           << i << "," << j << "] is out of range in array \""
                           << id << "\"");
   return values[i * nb_component + j];
 }
 
 template <class T, bool is_scal>
 inline T & Array<T, is_scal>::operator[](UInt i) {
   AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < size_ * nb_component),
                       "The value at position ["
                           << i << "] is out of range in array \"" << id
                           << "\"");
   return values[i];
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline const T & Array<T, is_scal>::operator[](UInt i) const {
   AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < size_ * nb_component),
                       "The value at position ["
                           << i << "] is out of range in array \"" << id
                           << "\"");
   return values[i];
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * append a tuple to the array with the value value for all components
  * @param value the new last tuple or the array will contain nb_component copies
  * of value
  */
 template <class T, bool is_scal>
 inline void Array<T, is_scal>::push_back(const T & value) {
   resizeUnitialized(size_ + 1, true, value);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * append a tuple to the array
  * @param new_elem a C-array containing the values to be copied to the end of
  * the array */
 // template <class T, bool is_scal>
 // inline void Array<T, is_scal>::push_back(const T new_elem[]) {
 //   UInt pos = size_;
 
 //   resizeUnitialized(size_ + 1, false);
 
 //   T * tmp = values + nb_component * pos;
 //   std::uninitialized_copy(new_elem, new_elem + nb_component, tmp);
 // }
 
 /* -------------------------------------------------------------------------- */
 #ifndef SWIG
 /**
  * append a matrix or a vector to the array
  * @param new_elem a reference to a Matrix<T> or Vector<T> */
 template <class T, bool is_scal>
 template <template <typename> class C, typename>
 inline void Array<T, is_scal>::push_back(const C<T> & new_elem) {
   AKANTU_DEBUG_ASSERT(
       nb_component == new_elem.size(),
       "The vector("
           << new_elem.size()
           << ") as not a size compatible with the Array (nb_component="
           << nb_component << ").");
   UInt pos = size_;
   resizeUnitialized(size_ + 1, false);
 
   T * tmp = values + nb_component * pos;
   std::uninitialized_copy(new_elem.storage(), new_elem.storage() + nb_component,
                           tmp);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * append a tuple to the array
  * @param it an iterator to the tuple to be copied to the end of the array */
 template <class T, bool is_scal>
 template <class Ret>
 inline void
 Array<T, is_scal>::push_back(const Array<T, is_scal>::iterator<Ret> & it) {
   UInt pos = size_;
 
   resizeUnitialized(size_ + 1, false);
 
   T * tmp = values + nb_component * pos;
   T * new_elem = it.data();
   std::uninitialized_copy(new_elem, new_elem + nb_component, tmp);
 }
 #endif
 /* -------------------------------------------------------------------------- */
 /**
  * erase an element. If the erased element is not the last of the array, the
  * last element is moved into the hole in order to maintain contiguity. This
  * may invalidate existing iterators (For instance an iterator obtained by
  * Array::end() is no longer correct) and will change the order of the
  * elements.
  * @param i index of element to erase
  */
 template <class T, bool is_scal> inline void Array<T, is_scal>::erase(UInt i) {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG_ASSERT((size_ > 0), "The array is empty");
   AKANTU_DEBUG_ASSERT((i < size_),
                       "The element at position [" << i << "] is out of range ("
                                                   << i << ">=" << size_ << ")");
 
   if (i != (size_ - 1)) {
     for (UInt j = 0; j < nb_component; ++j) {
       values[i * nb_component + j] = values[(size_ - 1) * nb_component + j];
     }
   }
 
   resize(size_ - 1);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Subtract another array entry by entry from this array in place. Both arrays
  * must
  * have the same size and nb_component. If the arrays have different shapes,
  * code compiled in debug mode will throw an expeption and optimised code
  * will behave in an unpredicted manner
  * @param other array to subtract from this
  * @return reference to modified this
  */
 template <class T, bool is_scal>
 Array<T, is_scal> & Array<T, is_scal>::
 operator-=(const Array<T, is_scal> & vect) {
   AKANTU_DEBUG_ASSERT((size_ == vect.size_) &&
                           (nb_component == vect.nb_component),
                       "The too array don't have the same sizes");
 
   T * a = values;
   T * b = vect.storage();
   for (UInt i = 0; i < size_ * nb_component; ++i) {
     *a -= *b;
     ++a;
     ++b;
   }
 
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Add another array entry by entry to this array in place. Both arrays must
  * have the same size and nb_component. If the arrays have different shapes,
  * code compiled in debug mode will throw an expeption and optimised code
  * will behave in an unpredicted manner
  * @param other array to add to this
  * @return reference to modified this
  */
 template <class T, bool is_scal>
 Array<T, is_scal> & Array<T, is_scal>::
 operator+=(const Array<T, is_scal> & vect) {
   AKANTU_DEBUG_ASSERT((size_ == vect.size()) &&
                           (nb_component == vect.nb_component),
                       "The too array don't have the same sizes");
 
   T * a = values;
   T * b = vect.storage();
   for (UInt i = 0; i < size_ * nb_component; ++i) {
     *a++ += *b++;
   }
 
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Multiply all entries of this array by a scalar in place
  * @param alpha scalar multiplicant
  * @return reference to modified this
  */
 
 #ifndef SWIG
 template <class T, bool is_scal>
 Array<T, is_scal> & Array<T, is_scal>::operator*=(const T & alpha) {
   T * a = values;
   for (UInt i = 0; i < size_ * nb_component; ++i) {
     *a++ *= alpha;
   }
 
   return *this;
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 /**
  * Compare this array element by element to another.
  * @param other array to compare to
  * @return true it all element are equal and arrays have the same shape, else
  * false
  */
 template <class T, bool is_scal>
 bool Array<T, is_scal>::operator==(const Array<T, is_scal> & array) const {
   bool equal = nb_component == array.nb_component && size_ == array.size_ &&
                id == array.id;
   if (!equal)
     return false;
 
   if (values == array.storage())
     return true;
   else
     return std::equal(values, values + size_ * nb_component, array.storage());
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 bool Array<T, is_scal>::operator!=(const Array<T, is_scal> & array) const {
   return !operator==(array);
 }
 
 /* -------------------------------------------------------------------------- */
 #ifndef SWIG
 /**
  * set all tuples of the array to a given vector or matrix
  * @param vm Matrix or Vector to fill the array with
  */
 template <class T, bool is_scal>
 template <template <typename> class C, typename>
 inline void Array<T, is_scal>::set(const C<T> & vm) {
   AKANTU_DEBUG_ASSERT(
       nb_component == vm.size(),
       "The size of the object does not match the number of components");
   for (T * it = values; it < values + nb_component * size_;
        it += nb_component) {
     std::copy(vm.storage(), vm.storage() + nb_component, it);
   }
 }
 #endif
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 void Array<T, is_scal>::append(const Array<T> & other) {
   AKANTU_DEBUG_ASSERT(
       nb_component == other.nb_component,
       "Cannot append an array with a different number of component");
   UInt old_size = this->size_;
   this->resizeUnitialized(this->size_ + other.size(), false);
 
   T * tmp = values + nb_component * old_size;
   std::uninitialized_copy(other.storage(),
                           other.storage() + other.size() * nb_component, tmp);
 }
 
 /* -------------------------------------------------------------------------- */
 /* Functions Array<T, is_scal>                                                */
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(UInt size, UInt nb_component, const ID & id)
     : ArrayBase(id), values(nullptr) {
   AKANTU_DEBUG_IN();
   allocate(size, nb_component);
 
   if (!is_scal) {
     T val = T();
     std::uninitialized_fill(values, values + size * nb_component, val);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(UInt size, UInt nb_component, const T def_values[],
                          const ID & id)
     : ArrayBase(id), values(NULL) {
   AKANTU_DEBUG_IN();
   allocate(size, nb_component);
 
   T * tmp = values;
 
   for (UInt i = 0; i < size; ++i) {
     tmp = values + nb_component * i;
     std::uninitialized_copy(def_values, def_values + nb_component, tmp);
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(UInt size, UInt nb_component, const T & value,
                          const ID & id)
     : ArrayBase(id), values(nullptr) {
   AKANTU_DEBUG_IN();
   allocate(size, nb_component);
 
   std::uninitialized_fill_n(values, size * nb_component, value);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
-Array<T, is_scal>::Array(const Array<T, is_scal> & vect, bool deep,
-                         const ID & id)
+Array<T, is_scal>::Array(const Array<T, is_scal> & vect, 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;
-  }
+  // if (deep) {
+  allocate(vect.size_, vect.nb_component);
+  std::uninitialized_copy(vect.storage(), vect.storage() + size_ * nb_component,
+                          values);
+  // } 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();
 }
 
+/* -------------------------------------------------------------------------- */
+template <class T, bool is_scal>
+Array<T, is_scal> & Array<T, is_scal>::
+operator=(const Array<T, is_scal> & other) {
+  AKANTU_DEBUG_WARNING("You are copying the array "
+                       << id << " are you sure it is on purpose");
+
+  if (&other == this)
+    return *this;
+
+  allocate(other.size_, other.nb_component);
+  std::uninitialized_copy(other.storage(),
+                          other.storage() + size_ * nb_component, values);
+
+  return *this;
+}
+
+/* -------------------------------------------------------------------------- */
+template <class T, bool is_scal>
+Array<T, is_scal>::Array(Array<T, is_scal> && other)
+    : ArrayBase(other), values(std::exchange(other.values, nullptr)) {}
+
+/* -------------------------------------------------------------------------- */
+template <class T, bool is_scal>
+Array<T, is_scal> & Array<T, is_scal>::operator=(Array && other) {
+  if (&other == this)
+    return *this;
+
+  ArrayBase::operator=(other);
+  values = std::exchange(other.values, nullptr);
+
+  return *this;
+}
+
 /* -------------------------------------------------------------------------- */
 #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)
+    if (not is_scal) {
       for (UInt i = 0; i < size_ * nb_component; ++i) {
         T * obj = values + i;
         obj->~T();
       }
+    }
     free(values);
   }
   size_ = allocated_size = 0;
   AKANTU_DEBUG_OUT();
 }
 
-/* -------------------------------------------------------------------------- */
-/**
- * perform the allocation for the constructors
- * @param size is the size of the array
- * @param nb_component is the number of component of the array
- */
-template <class T, bool is_scal>
-void Array<T, is_scal>::allocate(UInt size, UInt nb_component) {
-  AKANTU_DEBUG_IN();
-  if (size == 0) {
-    values = nullptr;
-  } else {
-    values = static_cast<T *>(malloc(nb_component * size * sizeof(T)));
-    AKANTU_DEBUG_ASSERT(values != nullptr,
-                        "Cannot allocate "
-                            << printMemorySize<T>(size * nb_component) << " ("
-                            << id << ")");
-  }
-
-  if (values == nullptr) {
-    this->size_ = this->allocated_size = 0;
-  } else {
-    AKANTU_DEBUG(dblAccessory,
-                 "Allocated " << printMemorySize<T>(size * nb_component) << " ("
-                              << id << ")");
-    this->size_ = this->allocated_size = size;
-  }
-
-  this->size_of_type = sizeof(T);
-  this->nb_component = nb_component;
-
-  AKANTU_DEBUG_OUT();
-}
-
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 void Array<T, is_scal>::reserve(UInt new_size) {
   UInt tmp_size = this->size_;
   resizeUnitialized(new_size, false);
   this->size_ = tmp_size;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the size of the array and allocate or free memory if needed. If the
  * size increases, the new tuples are filled with zeros
  * @param new_size new number of tuples contained in the array */
 template <class T, bool is_scal> void Array<T, is_scal>::resize(UInt new_size) {
   resizeUnitialized(new_size, !is_scal);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the size of the array and allocate or free memory if needed. If the
  * size increases, the new tuples are filled with zeros
  * @param new_size new number of tuples contained in the array */
 template <class T, bool is_scal>
 void Array<T, is_scal>::resize(UInt new_size, const T & val) {
   this->resizeUnitialized(new_size, true, val);
 }
 
+/* -------------------------------------------------------------------------- */
+/**
+ * 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();
+
+  values = static_cast<T *>(malloc(nb_component * size * sizeof(T)));
+
+  if (values == nullptr and size != 0) {
+    this->size_ = this->allocated_size = 0;
+    AKANTU_EXCEPTION("Cannot allocate "
+                     << printMemorySize<T>(size * nb_component) << " (" << id
+                     << ")");
+  } 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();
+}
+
 /* -------------------------------------------------------------------------- */
 /**
  * change the size of the array and allocate or free memory if needed.
  * @param new_size new number of tuples contained in the array */
 template <class T, bool is_scal>
 void Array<T, is_scal>::resizeUnitialized(UInt new_size, bool fill,
                                           const T & val) {
   //  AKANTU_DEBUG_IN();
   // free some memory
   if (new_size <= allocated_size) {
     if (!is_scal) {
       T * old_values = values;
       if (new_size < size_) {
         for (UInt i = new_size * nb_component; i < size_ * nb_component; ++i) {
           T * obj = old_values + i;
           obj->~T();
         }
       }
     }
 
     if (allocated_size - new_size > AKANTU_MIN_ALLOCATION) {
       AKANTU_DEBUG(dblAccessory,
                    "Freeing " << printMemorySize<T>((allocated_size - size_) *
                                                     nb_component)
                               << " (" << id << ")");
 
       // Normally there are no allocation problem when reducing an array
       if (new_size == 0) {
         free(values);
         values = nullptr;
       } else {
         auto * tmp_ptr = static_cast<T *>(
             realloc(values, new_size * nb_component * sizeof(T)));
 
         if (tmp_ptr == nullptr) {
           AKANTU_EXCEPTION("Cannot free data ("
                            << id << ")"
                            << " [current allocated size : " << allocated_size
                            << " | "
                            << "requested size : " << new_size << "]");
         }
         values = tmp_ptr;
       }
       allocated_size = new_size;
     }
   } else {
     // allocate more memory
     UInt size_to_alloc = (new_size - allocated_size < AKANTU_MIN_ALLOCATION)
                              ? allocated_size + AKANTU_MIN_ALLOCATION
                              : new_size;
 
     auto * tmp_ptr = static_cast<T *>(
         realloc(values, size_to_alloc * nb_component * sizeof(T)));
     AKANTU_DEBUG_ASSERT(
         tmp_ptr != nullptr,
         "Cannot allocate " << printMemorySize<T>(size_to_alloc * nb_component));
     if (tmp_ptr == nullptr) {
       AKANTU_ERROR("Cannot allocate more data ("
                    << id << ")"
                    << " [current allocated size : " << allocated_size << " | "
                    << "requested size : " << new_size << "]");
     }
 
     AKANTU_DEBUG(dblAccessory,
                  "Allocating " << printMemorySize<T>(
                      (size_to_alloc - allocated_size) * nb_component));
 
     allocated_size = size_to_alloc;
     values = tmp_ptr;
   }
 
   if (fill && this->size_ < new_size) {
     std::uninitialized_fill(values + size_ * nb_component,
                             values + new_size * nb_component, val);
   }
 
   size_ = new_size;
   //  AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the number of components by interlacing data
  * @param multiplicator number of interlaced components add
  * @param block_size blocks of data in the array
  * Examaple for block_size = 2, multiplicator = 2
  * array = oo oo oo -> new array = oo nn nn oo nn nn oo nn nn */
 template <class T, bool is_scal>
 void Array<T, is_scal>::extendComponentsInterlaced(UInt multiplicator,
                                                    UInt block_size) {
   AKANTU_DEBUG_IN();
 
   if (multiplicator == 1)
     return;
 
   AKANTU_DEBUG_ASSERT(multiplicator > 1, "invalid multiplicator");
   AKANTU_DEBUG_ASSERT(nb_component % block_size == 0,
                       "stride must divide actual number of components");
 
   values = static_cast<T *>(
       realloc(values, nb_component * multiplicator * size_ * sizeof(T)));
 
   UInt new_component = nb_component / block_size * multiplicator;
 
   for (UInt i = 0, k = size_ - 1; i < size_; ++i, --k) {
     for (UInt j = 0; j < new_component; ++j) {
       UInt m = new_component - j - 1;
       UInt n = m / multiplicator;
       for (UInt l = 0, p = block_size - 1; l < block_size; ++l, --p) {
         values[k * nb_component * multiplicator + m * block_size + p] =
             values[k * nb_component + n * block_size + p];
       }
     }
   }
 
   nb_component = nb_component * multiplicator;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * search elem in the array, return  the position of the first occurrence or
  * -1 if not found
  *  @param elem the element to look for
  *  @return index of the first occurrence of elem or -1 if elem is not present
  */
 template <class T, bool is_scal>
 UInt Array<T, is_scal>::find(const T & elem) const {
   AKANTU_DEBUG_IN();
 
   auto begin = this->begin();
   auto end = this->end();
   auto it = std::find(begin, end, elem);
 
   AKANTU_DEBUG_OUT();
   return (it != end) ? it - begin : UInt(-1);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal> UInt Array<T, is_scal>::find(T elem[]) const {
   AKANTU_DEBUG_IN();
   T * it = values;
   UInt i = 0;
   for (; i < size_; ++i) {
     if (*it == elem[0]) {
       T * cit = it;
       UInt c = 0;
       for (; (c < nb_component) && (*cit == elem[c]); ++c, ++cit)
         ;
       if (c == nb_component) {
         AKANTU_DEBUG_OUT();
         return i;
       }
     }
     it += nb_component;
   }
   return UInt(-1);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <template <typename> class C, typename>
 inline UInt Array<T, is_scal>::find(const C<T> & elem) {
   AKANTU_DEBUG_ASSERT(elem.size() == nb_component,
                       "Cannot find an element with a wrong size ("
                           << elem.size() << ") != " << nb_component);
   return this->find(elem.storage());
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * copy the content of another array. This overwrites the current content.
  * @param other Array to copy into this array. It has to have the same
  * nb_component as this. If compiled in debug mode, an incorrect other will
  * result in an exception being thrown. Optimised code may result in
  * unpredicted behaviour.
  */
 template <class T, bool is_scal>
 void Array<T, is_scal>::copy(const Array<T, is_scal> & vect,
                              bool no_sanity_check) {
   AKANTU_DEBUG_IN();
 
   if (!no_sanity_check)
     if (vect.nb_component != nb_component)
       AKANTU_ERROR("The two arrays do not have the same number of components");
 
   resize((vect.size_ * vect.nb_component) / nb_component);
 
   T * tmp = values;
   std::uninitialized_copy(vect.storage(), vect.storage() + size_ * nb_component,
                           tmp);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_scal> class ArrayPrintHelper {
 public:
   template <typename T>
   static void print_content(const Array<T> & vect, std::ostream & stream,
                             int indent) {
     if (AKANTU_DEBUG_TEST(dblDump) || AKANTU_DEBUG_LEVEL_IS_TEST()) {
       std::string space;
       for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
         ;
 
       stream << space << " + values         : {";
       for (UInt i = 0; i < vect.size(); ++i) {
         stream << "{";
         for (UInt j = 0; j < vect.getNbComponent(); ++j) {
           stream << vect(i, j);
           if (j != vect.getNbComponent() - 1)
             stream << ", ";
         }
         stream << "}";
         if (i != vect.size() - 1)
           stream << ", ";
       }
       stream << "}" << std::endl;
     }
   }
 };
 
 template <> class ArrayPrintHelper<false> {
 public:
   template <typename T>
   static void print_content(__attribute__((unused)) const Array<T> & vect,
                             __attribute__((unused)) std::ostream & stream,
                             __attribute__((unused)) int indent) {}
 };
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 void Array<T, is_scal>::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   std::streamsize prec = stream.precision();
   std::ios_base::fmtflags ff = stream.flags();
 
   stream.setf(std::ios_base::showbase);
   stream.precision(2);
 
   stream << space << "Array<" << debug::demangle(typeid(T).name()) << "> ["
          << std::endl;
   stream << space << " + id             : " << this->id << std::endl;
   stream << space << " + size           : " << this->size_ << std::endl;
   stream << space << " + nb_component   : " << this->nb_component << std::endl;
   stream << space << " + allocated size : " << this->allocated_size
          << std::endl;
   stream << space << " + memory size    : "
          << printMemorySize<T>(allocated_size * nb_component) << std::endl;
   if (!AKANTU_DEBUG_LEVEL_IS_TEST())
     stream << space << " + address        : " << std::hex << this->values
            << std::dec << std::endl;
 
   stream.precision(prec);
   stream.flags(ff);
 
   ArrayPrintHelper<is_scal>::print_content(*this, stream, indent);
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 /* Inline Functions ArrayBase                                                */
 /* -------------------------------------------------------------------------- */
 
 inline UInt ArrayBase::getMemorySize() const {
   return allocated_size * nb_component * size_of_type;
 }
 
 inline void ArrayBase::empty() { size_ = 0; }
 
 #ifndef SWIG
 /* -------------------------------------------------------------------------- */
 /* Iterators                                                                  */
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <class R, class daughter, class IR, bool is_tensor>
 class Array<T, is_scal>::iterator_internal {
 public:
   using value_type = R;
   using pointer = R *;
   using reference = R &;
   using proxy = typename R::proxy;
   using const_proxy = const typename R::proxy;
   using const_reference = const R &;
   using internal_value_type = IR;
   using internal_pointer = IR *;
   using difference_type = std::ptrdiff_t;
   using iterator_category = std::random_access_iterator_tag;
 
 public:
   iterator_internal() = default;
 
   iterator_internal(pointer_type data, UInt _offset)
       : _offset(_offset), initial(data), ret(nullptr), ret_ptr(data) {
     AKANTU_ERROR(
         "The constructor should never be called it is just an ugly trick...");
   }
 
   iterator_internal(std::unique_ptr<internal_value_type> && wrapped)
       : _offset(wrapped->size()), initial(wrapped->storage()),
         ret(std::move(wrapped)), ret_ptr(ret->storage()) {}
 
   iterator_internal(const iterator_internal & it) {
     if (this != &it) {
       this->_offset = it._offset;
       this->initial = it.initial;
       this->ret_ptr = it.ret_ptr;
       this->ret = std::make_unique<internal_value_type>(*it.ret, false);
     }
   }
 
   iterator_internal(iterator_internal && it) = default;
 
   virtual ~iterator_internal() = default;
 
   inline iterator_internal & operator=(const iterator_internal & it) {
     if (this != &it) {
       this->_offset = it._offset;
       this->initial = it.initial;
       this->ret_ptr = it.ret_ptr;
       if (this->ret)
         this->ret->shallowCopy(*it.ret);
       else
         this->ret = std::make_unique<internal_value_type>(*it.ret, false);
     }
     return *this;
   }
 
   UInt getCurrentIndex() {
     return (this->ret_ptr - this->initial) / this->_offset;
   };
 
   inline reference operator*() {
     ret->values = ret_ptr;
     return *ret;
   };
   inline const_reference operator*() const {
     ret->values = ret_ptr;
     return *ret;
   };
   inline pointer operator->() {
     ret->values = ret_ptr;
     return ret.get();
   };
   inline daughter & operator++() {
     ret_ptr += _offset;
     return static_cast<daughter &>(*this);
   };
   inline daughter & operator--() {
     ret_ptr -= _offset;
     return static_cast<daughter &>(*this);
   };
 
   inline daughter & operator+=(const UInt n) {
     ret_ptr += _offset * n;
     return static_cast<daughter &>(*this);
   }
   inline daughter & operator-=(const UInt n) {
     ret_ptr -= _offset * n;
     return static_cast<daughter &>(*this);
   }
 
   inline proxy operator[](const UInt n) {
     ret->values = ret_ptr + n * _offset;
     return proxy(*ret);
   }
   inline const_proxy operator[](const UInt n) const {
     ret->values = ret_ptr + n * _offset;
     return const_proxy(*ret);
   }
 
   inline bool operator==(const iterator_internal & other) const {
     return this->ret_ptr == other.ret_ptr;
   }
   inline bool operator!=(const iterator_internal & other) const {
     return this->ret_ptr != other.ret_ptr;
   }
   inline bool operator<(const iterator_internal & other) const {
     return this->ret_ptr < other.ret_ptr;
   }
   inline bool operator<=(const iterator_internal & other) const {
     return this->ret_ptr <= other.ret_ptr;
   }
   inline bool operator>(const iterator_internal & other) const {
     return this->ret_ptr > other.ret_ptr;
   }
   inline bool operator>=(const iterator_internal & other) const {
     return this->ret_ptr >= other.ret_ptr;
   }
 
   inline daughter operator+(difference_type n) {
     daughter tmp(static_cast<daughter &>(*this));
     tmp += n;
     return tmp;
   }
   inline daughter operator-(difference_type n) {
     daughter tmp(static_cast<daughter &>(*this));
     tmp -= n;
     return tmp;
   }
 
   inline difference_type operator-(const iterator_internal & b) {
     return (this->ret_ptr - b.ret_ptr) / _offset;
   }
 
   inline pointer_type data() const { return ret_ptr; }
   inline difference_type offset() const { return _offset; }
 
 protected:
   UInt _offset{0};
   pointer_type initial{nullptr};
   std::unique_ptr<internal_value_type> ret{nullptr};
   pointer_type ret_ptr{nullptr};
 };
 
 /* -------------------------------------------------------------------------- */
 /**
  * Specialization for scalar types
  */
 template <class T, bool is_scal>
 template <class R, class daughter, class IR>
 class Array<T, is_scal>::iterator_internal<R, daughter, IR, false> {
 public:
   using value_type = R;
   using pointer = R *;
   using reference = R &;
   using const_reference = const R &;
   using internal_value_type = IR;
   using internal_pointer = IR *;
   using difference_type = std::ptrdiff_t;
   using iterator_category = std::random_access_iterator_tag;
 
 public:
   iterator_internal(pointer data = nullptr) : ret(data), initial(data){};
   iterator_internal(const iterator_internal & it) = default;
   iterator_internal(iterator_internal && it) = default;
 
   virtual ~iterator_internal() = default;
 
   inline iterator_internal & operator=(const iterator_internal & it) = default;
 
   UInt getCurrentIndex() { return (this->ret - this->initial); };
 
   inline reference operator*() { return *ret; };
   inline const_reference operator*() const { return *ret; };
   inline pointer operator->() { return ret; };
   inline daughter & operator++() {
     ++ret;
     return static_cast<daughter &>(*this);
   };
   inline daughter & operator--() {
     --ret;
     return static_cast<daughter &>(*this);
   };
 
   inline daughter & operator+=(const UInt n) {
     ret += n;
     return static_cast<daughter &>(*this);
   }
   inline daughter & operator-=(const UInt n) {
     ret -= n;
     return static_cast<daughter &>(*this);
   }
 
   inline reference operator[](const UInt n) { return ret[n]; }
 
   inline bool operator==(const iterator_internal & other) const {
     return ret == other.ret;
   }
   inline bool operator!=(const iterator_internal & other) const {
     return ret != other.ret;
   }
   inline bool operator<(const iterator_internal & other) const {
     return ret < other.ret;
   }
   inline bool operator<=(const iterator_internal & other) const {
     return ret <= other.ret;
   }
   inline bool operator>(const iterator_internal & other) const {
     return ret > other.ret;
   }
   inline bool operator>=(const iterator_internal & other) const {
     return ret >= other.ret;
   }
 
   inline daughter operator-(difference_type n) { return daughter(ret - n); }
   inline daughter operator+(difference_type n) { return daughter(ret + n); }
 
   inline difference_type operator-(const iterator_internal & b) {
     return ret - b.ret;
   }
 
   inline pointer data() const { return ret; }
 
 protected:
   pointer ret{nullptr};
   pointer initial{nullptr};
 };
 
 /* -------------------------------------------------------------------------- */
 /* Begin/End functions implementation                                         */
 /* -------------------------------------------------------------------------- */
 namespace detail {
   template <class Tuple, size_t... Is>
   constexpr auto take_front_impl(Tuple && t, std::index_sequence<Is...>) {
     return std::make_tuple(std::get<Is>(std::forward<Tuple>(t))...);
   }
 
   template <size_t N, class Tuple> constexpr auto take_front(Tuple && t) {
     return take_front_impl(std::forward<Tuple>(t),
                            std::make_index_sequence<N>{});
   }
 
   template <typename... V> constexpr auto product_all(V &&... v) {
     std::common_type_t<int, V...> result = 1;
     (void)std::initializer_list<int>{(result *= v, 0)...};
     return result;
   }
 
   template <typename... T> std::string to_string_all(T &&... t) {
     if (sizeof...(T) == 0)
       return "";
 
     std::stringstream ss;
     bool noComma = true;
     ss << "(";
     (void)std::initializer_list<bool>{
         (ss << (noComma ? "" : ", ") << t, noComma = false)...};
     ss << ")";
     return ss.str();
   }
 
   template <std::size_t N> struct InstantiationHelper {
     template <typename type, typename T, typename... Ns>
     static auto instantiate(T && data, Ns... ns) {
       return std::make_unique<type>(data, ns...);
     }
   };
 
   template <> struct InstantiationHelper<0> {
     template <typename type, typename T> static auto instantiate(T && data) {
       return data;
     }
   };
 
   template <typename Arr, typename T, typename... Ns>
   decltype(auto) get_iterator(Arr && array, T * data, Ns &&... ns) {
     using type = IteratorHelper_t<sizeof...(Ns) - 1, T>;
     using array_type = std::decay_t<Arr>;
     using iterator =
         std::conditional_t<std::is_const<std::remove_reference_t<Arr>>::value,
                            typename array_type::template const_iterator<type>,
                            typename array_type::template iterator<type>>;
     static_assert(sizeof...(Ns), "You should provide a least one size");
 
     if (array.getNbComponent() * array.size() !=
         product_all(std::forward<Ns>(ns)...)) {
       AKANTU_CUSTOM_EXCEPTION_INFO(
           debug::ArrayException(),
           "The iterator on "
               << debug::demangle(typeid(Arr).name())
               << to_string_all(array.size(), array.getNbComponent())
               << "is not compatible with the type "
               << debug::demangle(typeid(type).name()) << to_string_all(ns...));
     }
 
     auto && wrapped = aka::apply(
         [&](auto... n) {
           return InstantiationHelper<sizeof...(n)>::template instantiate<type>(
               data, n...);
         },
         take_front<sizeof...(Ns) - 1>(std::make_tuple(ns...)));
 
     return iterator(std::move(wrapped));
   }
 } // namespace detail
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::begin(Ns &&... ns) {
   return detail::get_iterator(*this, values, std::forward<Ns>(ns)..., size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::end(Ns &&... ns) {
   return detail::get_iterator(*this, values + nb_component * size_,
                               std::forward<Ns>(ns)..., size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::begin(Ns &&... ns) const {
   return detail::get_iterator(*this, values, std::forward<Ns>(ns)..., size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::end(Ns &&... ns) const {
   return detail::get_iterator(*this, values + nb_component * size_,
                               std::forward<Ns>(ns)..., size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::begin_reinterpret(Ns &&... ns) {
   return detail::get_iterator(*this, values, std::forward<Ns>(ns)...);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::end_reinterpret(Ns &&... ns) {
   return detail::get_iterator(
       *this, values + detail::product_all(std::forward<Ns>(ns)...),
       std::forward<Ns>(ns)...);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::begin_reinterpret(Ns &&... ns) const {
   return detail::get_iterator(*this, values, std::forward<Ns>(ns)...);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::end_reinterpret(Ns &&... ns) const {
   return detail::get_iterator(
       *this, values + detail::product_all(std::forward<Ns>(ns)...),
       std::forward<Ns>(ns)...);
 }
 
 /* -------------------------------------------------------------------------- */
 /* Views                                                                      */
 /* -------------------------------------------------------------------------- */
 namespace detail {
   template <typename Array, typename... Ns> class ArrayView {
     using tuple = std::tuple<Ns...>;
 
   public:
     ArrayView(Array && array, Ns... ns)
         : array(std::forward<Array>(array)), sizes(std::move(ns)...) {}
 
     ArrayView(ArrayView && array_view) = default;
 
     ArrayView & operator=(const ArrayView & array_view) = default;
     ArrayView & operator=(ArrayView && array_view) = default;
 
     decltype(auto) begin() {
       return aka::apply(
           [&](auto &&... ns) { return array.begin_reinterpret(ns...); }, sizes);
     }
 
     decltype(auto) begin() const {
       return aka::apply(
           [&](auto &&... ns) { return array.begin_reinterpret(ns...); }, sizes);
     }
 
     decltype(auto) end() {
       return aka::apply(
           [&](auto &&... ns) { return array.end_reinterpret(ns...); }, sizes);
     }
 
     decltype(auto) end() const {
       return aka::apply(
           [&](auto &&... ns) { return array.end_reinterpret(ns...); }, sizes);
     }
 
     decltype(auto) size() const {
       return std::get<std::tuple_size<tuple>::value - 1>(sizes);
     }
 
     decltype(auto) dims() const { return std::tuple_size<tuple>::value - 1; }
 
   private:
     Array array;
     tuple sizes;
   };
 } // namespace detail
 
 /* -------------------------------------------------------------------------- */
 template <typename Array, typename... Ns>
 decltype(auto) make_view(Array && array, Ns... ns) {
   static_assert(aka::conjunction<std::is_integral<std::decay_t<Ns>>...>::value,
                 "Ns should be integral types");
   auto size = std::forward<decltype(array)>(array).size() *
               std::forward<decltype(array)>(array).getNbComponent() /
               detail::product_all(ns...);
 
   return detail::ArrayView<Array, std::common_type_t<size_t, Ns>...,
                            std::common_type_t<size_t, decltype(size)>>(
       std::forward<Array>(array), std::move(ns)..., size);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <typename R>
 class Array<T, is_scal>::const_iterator
     : public iterator_internal<const R, Array<T, is_scal>::const_iterator<R>,
                                R> {
 public:
   using parent = iterator_internal<const R, const_iterator, R>;
   using value_type = typename parent::value_type;
   using pointer = typename parent::pointer;
   using reference = typename parent::reference;
   using difference_type = typename parent::difference_type;
   using iterator_category = typename parent::iterator_category;
 
 public:
   const_iterator() : parent(){};
   // const_iterator(pointer_type data, UInt offset) : parent(data, offset) {}
   // const_iterator(pointer warped) : parent(warped) {}
   // const_iterator(const parent & it) : parent(it) {}
 
   const_iterator(const const_iterator & it) = default;
   const_iterator(const_iterator && it) = default;
 
   template <typename P, typename = std::enable_if_t<not is_tensor<P>::value>>
   const_iterator(P * data) : parent(data) {}
 
   template <typename UP_P,
             typename =
                 std::enable_if_t<is_tensor<typename UP_P::element_type>::value>>
   const_iterator(UP_P && tensor) : parent(std::forward<UP_P>(tensor)) {}
 
   const_iterator & operator=(const const_iterator & it) = default;
 };
 
 template <class T, class R, bool is_tensor_ = is_tensor<R>::value>
 struct ConstConverterIteratorHelper {
   using const_iterator = typename Array<T>::template const_iterator<R>;
   using iterator = typename Array<T>::template iterator<R>;
 
   static inline const_iterator convert(const iterator & it) {
     return const_iterator(std::unique_ptr<R>(new R(*it, false)));
   }
 };
 
 template <class T, class R> struct ConstConverterIteratorHelper<T, R, false> {
   using const_iterator = typename Array<T>::template const_iterator<R>;
   using iterator = typename Array<T>::template iterator<R>;
   static inline const_iterator convert(const iterator & it) {
     return const_iterator(it.data());
   }
 };
 
 template <class T, bool is_scal>
 template <typename R>
 class Array<T, is_scal>::iterator
     : public iterator_internal<R, Array<T, is_scal>::iterator<R>> {
 public:
   using parent = iterator_internal<R, iterator>;
   using value_type = typename parent::value_type;
   using pointer = typename parent::pointer;
   using reference = typename parent::reference;
   using difference_type = typename parent::difference_type;
   using iterator_category = typename parent::iterator_category;
 
 public:
   iterator() : parent(){};
   iterator(const iterator & it) = default;
   iterator(iterator && it) = default;
 
   template <typename P, typename = std::enable_if_t<not is_tensor<P>::value>>
   iterator(P * data) : parent(data) {}
 
   template <typename UP_P,
             typename =
                 std::enable_if_t<is_tensor<typename UP_P::element_type>::value>>
   iterator(UP_P && tensor) : parent(std::forward<UP_P>(tensor)) {}
 
   iterator & operator=(const iterator & it) = default;
 
   operator const_iterator<R>() {
     return ConstConverterIteratorHelper<T, R>::convert(*this);
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <typename R>
 inline typename Array<T, is_scal>::template iterator<R>
 Array<T, is_scal>::erase(const iterator<R> & it) {
   T * curr = it.data();
   UInt pos = (curr - values) / nb_component;
   erase(pos);
   iterator<R> rit = it;
   return --rit;
 }
 #endif
 
 } // namespace akantu
 
 #endif /* __AKANTU_AKA_ARRAY_TMPL_HH__ */
diff --git a/src/common/aka_bbox.hh b/src/common/aka_bbox.hh
index 49aade47d..b0bc5710f 100644
--- a/src/common/aka_bbox.hh
+++ b/src/common/aka_bbox.hh
@@ -1,256 +1,261 @@
 /**
  * @file   aka_bbox.hh
  *
  * @author Nicolas Richart
  *
  * @date creation  Mon Feb 12 2018
  *
  * @brief A simple bounding box class
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "aka_iterators.hh"
 #include "aka_types.hh"
 #include "communicator.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_BBOX_HH__
 #define __AKANTU_AKA_BBOX_HH__
 
 namespace akantu {
 
 class BBox {
 public:
   BBox(UInt spatial_dimension)
       : dim(spatial_dimension),
         lower_bounds(spatial_dimension, std::numeric_limits<Real>::max()),
         upper_bounds(spatial_dimension, -std::numeric_limits<Real>::max()) {}
 
   BBox(const BBox & other)
       : dim(other.dim), empty{false}, lower_bounds(other.lower_bounds),
         upper_bounds(other.upper_bounds) {}
 
   BBox & operator=(const BBox & other) {
     if (this != &other) {
       this->dim = other.dim;
       this->lower_bounds = other.lower_bounds;
       this->upper_bounds = other.upper_bounds;
       this->empty = other.empty;
     }
     return *this;
   }
 
   inline BBox & operator+=(const Vector<Real> & position) {
     AKANTU_DEBUG_ASSERT(
         this->dim == position.size(),
         "You are adding a point of a wrong dimension to the bounding box");
 
     this->empty = false;
 
     for (auto s : arange(dim)) {
       lower_bounds(s) = std::min(lower_bounds(s), position(s));
       upper_bounds(s) = std::max(upper_bounds(s), position(s));
     }
     return *this;
   }
 
   /* ------------------------------------------------------------------------ */
   inline bool intersects(const BBox & other,
                          const SpatialDirection & direction) const {
     AKANTU_DEBUG_ASSERT(
         this->dim == other.dim,
         "You are intersecting bounding boxes of different dimensions");
     return Math::intersects(lower_bounds(direction), upper_bounds(direction),
                             other.lower_bounds(direction),
                             other.upper_bounds(direction));
   }
 
   inline bool intersects(const BBox & other) const {
     if (this->empty or other.empty)
       return false;
 
     bool intersects_ = true;
     for (auto s : arange(this->dim)) {
       intersects_ &= this->intersects(other, SpatialDirection(s));
     }
     return intersects_;
   }
 
   /* ------------------------------------------------------------------------ */
   inline BBox intersection(const BBox & other) const {
     AKANTU_DEBUG_ASSERT(
         this->dim == other.dim,
         "You are intersecting bounding boxes of different dimensions");
 
     BBox intersection_(this->dim);
     intersection_.empty = not this->intersects(other);
 
     if (intersection_.empty)
       return intersection_;
 
     for (auto s : arange(this->dim)) {
       // is lower point in range ?
       bool point1 = Math::is_in_range(other.lower_bounds(s), lower_bounds(s),
                                       upper_bounds(s));
 
       // is upper point in range ?
       bool point2 = Math::is_in_range(other.upper_bounds(s), lower_bounds(s),
                                       upper_bounds(s));
 
       if (point1 and not point2) {
         // |-----------|         this (i)
         //       |-----------|   other(i)
         //       1           2
         intersection_.lower_bounds(s) = other.lower_bounds(s);
         intersection_.upper_bounds(s) = upper_bounds(s);
       } else if (point1 && point2) {
         // |-----------------|   this (i)
         //   |-----------|       other(i)
         //   1           2
         intersection_.lower_bounds(s) = other.lower_bounds(s);
         intersection_.upper_bounds(s) = other.upper_bounds(s);
       } else if (!point1 && point2) {
         //       |-----------|   this (i)
         // |-----------|         other(i)
         // 1           2
         intersection_.lower_bounds(s) = this->lower_bounds(s);
         intersection_.upper_bounds(s) = other.upper_bounds(s);
       } else {
         //   |-----------|       this (i)
         // |-----------------|   other(i)
         // 1                 2
         intersection_.lower_bounds(s) = this->lower_bounds(s);
         intersection_.upper_bounds(s) = this->upper_bounds(s);
       }
     }
 
     return intersection_;
   }
 
   /* ------------------------------------------------------------------------ */
   inline bool contains(const Vector<Real> & point) const {
     return (point >= lower_bounds) and (point <= upper_bounds);
   }
 
   /* ------------------------------------------------------------------------ */
   inline void reset() {
     lower_bounds.set(std::numeric_limits<Real>::max());
     upper_bounds.set(-std::numeric_limits<Real>::max());
   }
 
   /* ------------------------------------------------------------------------ */
   const Vector<Real> & getLowerBounds() const { return lower_bounds; }
   const Vector<Real> & getUpperBounds() const { return upper_bounds; }
 
   Vector<Real> & getLowerBounds() { return lower_bounds; }
   Vector<Real> & getUpperBounds() { return upper_bounds; }
 
   /* ------------------------------------------------------------------------ */
   inline Real size(const SpatialDirection & direction) const {
     return upper_bounds(direction) - lower_bounds(direction);
   }
 
   Vector<Real> size() const {
     Vector<Real> size_(dim);
     for (auto s : arange(this->dim)) {
       size_(s) = this->size(SpatialDirection(s));
     }
     return size_;
   }
 
   inline operator bool() const { return not empty; }
 
   /* ------------------------------------------------------------------------ */
   BBox allSum(const Communicator & communicator) const {
     Matrix<Real> reduce_bounds(dim, 2);
 
     Vector<Real>(reduce_bounds(0)) = lower_bounds;
     Vector<Real>(reduce_bounds(1)) = Real(-1.) * upper_bounds;
 
     communicator.allReduce(reduce_bounds, SynchronizerOperation::_min);
 
     BBox global(dim);
     global.lower_bounds = Vector<Real>(reduce_bounds(0));
     global.upper_bounds = Real(-1.) * Vector<Real>(reduce_bounds(1));
     global.empty = false;
     return global;
   }
 
   std::vector<BBox> allGather(const Communicator & communicator) const {
     auto prank = communicator.whoAmI();
     auto nb_proc = communicator.getNbProc();
     Array<Real> bboxes_data(nb_proc, dim * 2 + 1);
 
     auto * base = bboxes_data.storage() + prank * (2 * dim + 1);
     Vector<Real>(base + dim * 0, dim) = lower_bounds;
     Vector<Real>(base + dim * 1, dim) = upper_bounds;
     base[dim * 2] = empty ? 1. : 0.; // ugly trick
 
     communicator.allGather(bboxes_data);
 
     std::vector<BBox> bboxes;
     bboxes.reserve(nb_proc);
 
     for (auto p : arange(nb_proc)) {
       bboxes.emplace_back(dim);
       auto & bbox = bboxes.back();
 
       auto * base = bboxes_data.storage() + p * (2 * dim + 1);
       bbox.lower_bounds = Vector<Real>(base + dim * 0, dim);
       bbox.upper_bounds = Vector<Real>(base + dim * 1, dim);
       bbox.empty = base[dim * 2] == 1. ? true : false;
     }
 
     return bboxes;
   }
 
-  std::vector<BBox> intersection(const BBox & other,
-                                 const Communicator & communicator) {
+  std::map<UInt, BBox> intersection(const BBox & other,
+                                    const Communicator & communicator) {
+    // todo: change for a custom reduction algorithm
     auto other_bboxes = other.allGather(communicator);
-    for (auto & bbox : other_bboxes) {
-      bbox = this->intersection(bbox);
+    std::map<UInt, BBox> intersections;
+    for (auto & bbox : enumerate(other_bboxes)) {
+      auto && tmp = this->intersection(std::get<1>(bbox));
+      if (tmp) {
+        intersections[std::get<0>(bbox)] = tmp;
+      }
     }
-    return other_bboxes;
+    return intersections;
   }
 
   void printself(std::ostream & stream) const {
     stream << "BBox[";
     if (not empty) {
       stream << lower_bounds << " - " << upper_bounds;
     }
     stream << "]";
   }
 
 protected:
   UInt dim;
   bool empty{true};
   Vector<Real> lower_bounds;
   Vector<Real> upper_bounds;
 };
 
 inline std::ostream & operator<<(std::ostream & stream, const BBox & bbox) {
   bbox.printself(stream);
   return stream;
 }
 
 } // akantu
 
 #endif /* __AKANTU_AKA_BBOX_HH__ */
diff --git a/src/mesh/mesh.hh b/src/mesh/mesh.hh
index b8cd5e9f6..6c34f792d 100644
--- a/src/mesh/mesh.hh
+++ b/src/mesh/mesh.hh
@@ -1,689 +1,694 @@
 
 /**
  * @file   mesh.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Mon Feb 19 2018
  *
  * @brief  the class representing the meshes
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __AKANTU_MESH_HH__
 #define __AKANTU_MESH_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "aka_bbox.hh"
 #include "aka_event_handler_manager.hh"
 #include "aka_memory.hh"
 #include "dumpable.hh"
 #include "element.hh"
 #include "element_class.hh"
 #include "element_type_map.hh"
 #include "group_manager.hh"
 #include "mesh_data.hh"
 #include "mesh_events.hh"
 /* -------------------------------------------------------------------------- */
 #include <set>
 #include <unordered_map>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 class Communicator;
 class ElementSynchronizer;
 class NodeSynchronizer;
 class PeriodicNodeSynchronizer;
 class MeshGlobalDataUpdater;
 } // namespace akantu
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* Mesh                                                                       */
 /* -------------------------------------------------------------------------- */
 
 /**
  * @class  Mesh this  contain the  coordinates of  the nodes  in  the Mesh.nodes
  * Array,  and the  connectivity. The  connectivity  are stored  in by  element
  * types.
  *
  * In order to loop on all element you have to loop on all types like this :
  * @code{.cpp}
  for(auto & type : mesh.elementTypes()) {
    UInt nb_element  = mesh.getNbElement(type);
    const Array<UInt> & conn = mesh.getConnectivity(type);
    for(UInt e = 0; e < nb_element; ++e) {
      ...
    }
  }
 
  or
 
  for_each_element(mesh, [](Element & element) {
     std::cout << element << std::endl
   });
  @endcode
 */
 class Mesh : protected Memory,
              public EventHandlerManager<MeshEventHandler>,
              public GroupManager,
              public Dumpable {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 private:
   /// default constructor used for chaining, the last parameter is just to
   /// differentiate constructors
   Mesh(UInt spatial_dimension, const ID & id, const MemoryID & memory_id,
        Communicator & communicator);
 
 public:
   /// constructor that create nodes coordinates array
   Mesh(UInt spatial_dimension, const ID & id = "mesh",
        const MemoryID & memory_id = 0);
 
   /// mesh not distributed and not using the default communicator
   Mesh(UInt spatial_dimension, Communicator & communicator,
        const ID & id = "mesh", const MemoryID & memory_id = 0);
 
   /**
    * constructor that use an existing nodes coordinates
    * array, by getting the vector of coordinates
    */
   Mesh(UInt spatial_dimension, const std::shared_ptr<Array<Real>> & nodes,
        const ID & id = "mesh", const MemoryID & memory_id = 0);
 
   ~Mesh() override;
 
   /// read the mesh from a file
   void read(const std::string & filename,
             const MeshIOType & mesh_io_type = _miot_auto);
   /// write the mesh to a file
   void write(const std::string & filename,
              const MeshIOType & mesh_io_type = _miot_auto);
 
 protected:
   void makeReady();
 
 private:
   /// initialize the connectivity to NULL and other stuff
   void init();
 
   /// function that computes the bounding box (fills xmin, xmax)
   void computeBoundingBox();
 
   /* ------------------------------------------------------------------------ */
   /* Distributed memory methods and accessors                                 */
   /* ------------------------------------------------------------------------ */
 public:
   /// patitionate the mesh among the processors involved in their computation
   virtual void distribute(Communicator & communicator);
   virtual void distribute();
 
   /// defines is the mesh is distributed or not
   inline bool isDistributed() const { return this->is_distributed; }
 
   /* ------------------------------------------------------------------------ */
   /* Periodicity methods and accessors                                        */
   /* ------------------------------------------------------------------------ */
 public:
   /// set the periodicity in a given direction
   void makePeriodic(const SpatialDirection & direction);
   void makePeriodic(const SpatialDirection & direction, const ID & list_1,
                     const ID & list_2);
 
 protected:
   void makePeriodic(const SpatialDirection & direction,
                     const Array<UInt> & list_1, const Array<UInt> & list_2);
 
   /// Removes the face that the mesh is periodic
   void wipePeriodicInfo();
 
   inline void addPeriodicSlave(UInt slave, UInt master);
 
   template <typename T>
   void synchronizePeriodicSlaveDataWithMaster(Array<T> & data);
 
   // update the periodic synchronizer (creates it if it does not exists)
   void updatePeriodicSynchronizer();
 
 public:
   /// defines if the mesh is periodic or not
   inline bool isPeriodic() const { return (this->is_periodic != 0); }
 
   inline bool isPeriodic(const SpatialDirection & direction) const {
     return ((this->is_periodic & (1 << direction)) != 0);
   }
 
+  class PeriodicSlaves;
+
   /// get the master node for a given slave nodes, except if node not a slave
   inline UInt getPeriodicMaster(UInt slave) const;
 
+  /// get an iterable list of slaves for a given master node
+  inline decltype(auto) getPeriodicSlaves(UInt master) const;
+
   /* ------------------------------------------------------------------------ */
   /* General Methods                                                          */
   /* ------------------------------------------------------------------------ */
 public:
   /// function to print the containt of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
   /// extract coordinates of nodes from an element
   template <typename T>
   inline void extractNodalValuesFromElement(const Array<T> & nodal_values,
                                             T * elemental_values,
                                             UInt * connectivity, UInt n_nodes,
                                             UInt nb_degree_of_freedom) const;
 
   // /// extract coordinates of nodes from a reversed element
   // inline void extractNodalCoordinatesFromPBCElement(Real * local_coords,
   //                                                   UInt * connectivity,
   //                                                   UInt n_nodes);
 
   /// add a Array of connectivity for the type <type>.
   inline void addConnectivityType(const ElementType & type,
                                   const GhostType & ghost_type = _not_ghost);
 
   /* ------------------------------------------------------------------------ */
   template <class Event> inline void sendEvent(Event & event) {
     //    if(event.getList().size() != 0)
     EventHandlerManager<MeshEventHandler>::sendEvent<Event>(event);
   }
 
   /// prepare the  event to remove the elements listed
   void eraseElements(const Array<Element> & elements);
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void removeNodesFromArray(Array<T> & vect,
                                    const Array<UInt> & new_numbering);
 
   /// initialize normals
   void initNormals();
 
   /// init facets' mesh
   Mesh & initMeshFacets(const ID & id = "mesh_facets");
 
   /// define parent mesh
   void defineMeshParent(const Mesh & mesh);
 
   /// get global connectivity array
   void getGlobalConnectivity(ElementTypeMapArray<UInt> & global_connectivity);
 
 public:
   void getAssociatedElements(const Array<UInt> & node_list,
                              Array<Element> & elements);
 
 private:
   /// fills the nodes_to_elements structure
   void fillNodesToElements();
 
   /// update the global ids, nodes type, ...
   std::tuple<UInt, UInt> updateGlobalData(NewNodesEvent & nodes_event,
                                           NewElementsEvent & elements_event);
 
   void registerGlobalDataUpdater(
       std::unique_ptr<MeshGlobalDataUpdater> && global_data_updater);
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the id of the mesh
   AKANTU_GET_MACRO(ID, Memory::id, const ID &);
 
   /// get the id of the mesh
   AKANTU_GET_MACRO(MemoryID, Memory::memory_id, const MemoryID &);
 
   /// get the spatial dimension of the mesh = number of component of the
   /// coordinates
   AKANTU_GET_MACRO(SpatialDimension, spatial_dimension, UInt);
 
   /// get the nodes Array aka coordinates
   AKANTU_GET_MACRO(Nodes, *nodes, const Array<Real> &);
   AKANTU_GET_MACRO_NOT_CONST(Nodes, *nodes, Array<Real> &);
 
   /// get the normals for the elements
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(Normals, normals, Real);
 
   /// get the number of nodes
   AKANTU_GET_MACRO(NbNodes, nodes->size(), UInt);
 
   /// get the Array of global ids of the nodes (only used in parallel)
   AKANTU_GET_MACRO(GlobalNodesIds, *nodes_global_ids, const Array<UInt> &);
   AKANTU_GET_MACRO_NOT_CONST(GlobalNodesIds, *nodes_global_ids, Array<UInt> &);
 
   /// get the global id of a node
   inline UInt getNodeGlobalId(UInt local_id) const;
 
   /// get the global id of a node
   inline UInt getNodeLocalId(UInt global_id) const;
 
   /// get the global number of nodes
   inline UInt getNbGlobalNodes() const;
 
   /// get the nodes type Array
   AKANTU_GET_MACRO(NodesFlags, *nodes_flags, const Array<NodeFlag> &);
 
 protected:
   AKANTU_GET_MACRO_NOT_CONST(NodesFlags, *nodes_flags, Array<NodeFlag> &);
 
 public:
   inline NodeFlag getNodeFlag(UInt local_id) const;
   inline Int getNodePrank(UInt local_id) const;
 
   /// say if a node is a pure ghost node
   inline bool isPureGhostNode(UInt n) const;
 
   /// say if a node is pur local or master node
   inline bool isLocalOrMasterNode(UInt n) const;
 
   inline bool isLocalNode(UInt n) const;
   inline bool isMasterNode(UInt n) const;
   inline bool isSlaveNode(UInt n) const;
 
   inline bool isPeriodicSlave(UInt n) const;
   inline bool isPeriodicMaster(UInt n) const;
 
   const Vector<Real> & getLowerBounds() const { return bbox.getLowerBounds(); }
   const Vector<Real> & getUpperBounds() const { return bbox.getUpperBounds(); }
   AKANTU_GET_MACRO(BBox, bbox, const BBox &);
 
   const Vector<Real> & getLocalLowerBounds() const {
     return bbox_local.getLowerBounds();
   }
   const Vector<Real> & getLocalUpperBounds() const {
     return bbox_local.getUpperBounds();
   }
   AKANTU_GET_MACRO(LocalBBox, bbox_local, const BBox &);
 
   /// get the connectivity Array for a given type
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Connectivity, connectivities, UInt);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(Connectivity, connectivities, UInt);
   AKANTU_GET_MACRO(Connectivities, connectivities,
                    const ElementTypeMapArray<UInt> &);
 
   /// get the number of element of a type in the mesh
   inline UInt getNbElement(const ElementType & type,
                            const GhostType & ghost_type = _not_ghost) const;
 
   /// get the number of element for a given ghost_type and a given dimension
   inline UInt getNbElement(const UInt spatial_dimension = _all_dimensions,
                            const GhostType & ghost_type = _not_ghost,
                            const ElementKind & kind = _ek_not_defined) const;
 
   /// compute the barycenter of a given element
   inline void getBarycenter(const Element & element,
                             Vector<Real> & barycenter) const;
 
   void getBarycenters(Array<Real> & barycenter, const ElementType & type,
                       const GhostType & ghost_type) const;
 
 #ifndef SWIG
   /// get the element connected to a subelement (element of lower dimension)
   const auto & getElementToSubelement() const;
 
   /// get the element connected to a subelement
   const auto &
   getElementToSubelement(const ElementType & el_type,
                          const GhostType & ghost_type = _not_ghost) const;
 
   /// get the element connected to a subelement
   auto & getElementToSubelement(const ElementType & el_type,
                                 const GhostType & ghost_type = _not_ghost);
 
   /// get the elements connected to a subelement
   const auto & getElementToSubelement(const Element & element) const;
 
   /// get the subelement (element of lower dimension) connected to a element
   const auto & getSubelementToElement() const;
 
   /// get the subelement connected to an element
   const auto &
   getSubelementToElement(const ElementType & el_type,
                          const GhostType & ghost_type = _not_ghost) const;
   /// get the subelement connected to an element
   auto & getSubelementToElement(const ElementType & el_type,
                                 const GhostType & ghost_type = _not_ghost);
 
   /// get the subelement (element of lower dimension) connected to a element
   VectorProxy<Element> getSubelementToElement(const Element & element) const;
 
   /// get connectivity of a given element
   inline VectorProxy<UInt> getConnectivity(const Element & element) const;
   inline Vector<UInt>
   getConnectivityWithPeriodicity(const Element & element) const;
 
 protected:
   inline auto & getElementToSubelement(const Element & element);
   inline VectorProxy<Element> getSubelementToElement(const Element & element);
   inline VectorProxy<UInt> getConnectivity(const Element & element);
 #endif
 
 public:
   /// register a new ElementalTypeMap in the MeshData
   template <typename T>
   inline ElementTypeMapArray<T> & registerData(const std::string & data_name);
 
   template <typename T>
   inline bool hasData(const ID & data_name, const ElementType & el_type,
                       const GhostType & ghost_type = _not_ghost) const;
 
   /// get a name field associated to the mesh
   template <typename T>
   inline const Array<T> &
   getData(const ID & data_name, const ElementType & el_type,
           const GhostType & ghost_type = _not_ghost) const;
 
   /// get a name field associated to the mesh
   template <typename T>
   inline Array<T> & getData(const ID & data_name, const ElementType & el_type,
                             const GhostType & ghost_type = _not_ghost);
 
   /// tells if the data data_name is contained in the mesh or not
   inline bool hasData(const ID & data_name) const;
 
   /// get a name field associated to the mesh
   template <typename T>
   inline const ElementTypeMapArray<T> & getData(const ID & data_name) const;
 
   /// get a name field associated to the mesh
   template <typename T>
   inline ElementTypeMapArray<T> & getData(const ID & data_name);
 
   template <typename T>
   ElementTypeMap<UInt> getNbDataPerElem(ElementTypeMapArray<T> & array,
                                         const ElementKind & element_kind);
 
   template <typename T>
   dumper::Field * createFieldFromAttachedData(const std::string & field_id,
                                               const std::string & group_name,
                                               const ElementKind & element_kind);
 
   /// templated getter returning the pointer to data in MeshData (modifiable)
   template <typename T>
   inline Array<T> &
   getDataPointer(const std::string & data_name, const ElementType & el_type,
                  const GhostType & ghost_type = _not_ghost,
                  UInt nb_component = 1, bool size_to_nb_element = true,
                  bool resize_with_parent = false);
 
   template <typename T>
   inline Array<T> & getDataPointer(const ID & data_name,
                                    const ElementType & el_type,
                                    const GhostType & ghost_type,
                                    UInt nb_component, bool size_to_nb_element,
                                    bool resize_with_parent, const T & defaul_);
 
   /// Facets mesh accessor
   inline const Mesh & getMeshFacets() const;
   inline Mesh & getMeshFacets();
 
   /// Parent mesh accessor
   inline const Mesh & getMeshParent() const;
 
   inline bool isMeshFacets() const { return this->is_mesh_facets; }
 
 #ifndef SWIG
   /// return the dumper from a group and and a dumper name
   DumperIOHelper & getGroupDumper(const std::string & dumper_name,
                                   const std::string & group_name);
 #endif
   /* ------------------------------------------------------------------------ */
   /* Wrappers on ElementClass functions                                       */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the number of nodes per element for a given element type
   static inline UInt getNbNodesPerElement(const ElementType & type);
 
   /// get the number of nodes per element for a given element type considered as
   /// a first order element
   static inline ElementType getP1ElementType(const ElementType & type);
 
   /// get the kind of the element type
   static inline ElementKind getKind(const ElementType & type);
 
   /// get spatial dimension of a type of element
   static inline UInt getSpatialDimension(const ElementType & type);
 
   /// get number of facets of a given element type
   static inline UInt getNbFacetsPerElement(const ElementType & type);
 
   /// get number of facets of a given element type
   static inline UInt getNbFacetsPerElement(const ElementType & type, UInt t);
 
 #ifndef SWIG
   /// get local connectivity of a facet for a given facet type
   static inline auto getFacetLocalConnectivity(const ElementType & type,
                                                UInt t = 0);
 
   /// get connectivity of facets for a given element
   inline auto getFacetConnectivity(const Element & element, UInt t = 0) const;
 
 #endif
 
   /// get the number of type of the surface element associated to a given
   /// element type
   static inline UInt getNbFacetTypes(const ElementType & type, UInt t = 0);
 
 #ifndef SWIG
 
   /// get the type of the surface element associated to a given element
   static inline constexpr auto getFacetType(const ElementType & type,
                                             UInt t = 0);
 
   /// get all the type of the surface element associated to a given element
   static inline constexpr auto getAllFacetTypes(const ElementType & type);
 
 #endif
 
   /// get the number of nodes in the given element list
   static inline UInt getNbNodesPerElementList(const Array<Element> & elements);
 
   /* ------------------------------------------------------------------------ */
   /* Element type Iterator                                                    */
   /* ------------------------------------------------------------------------ */
   using type_iterator = ElementTypeMapArray<UInt, ElementType>::type_iterator;
   using ElementTypesIteratorHelper =
       ElementTypeMapArray<UInt, ElementType>::ElementTypesIteratorHelper;
 
   template <typename... pack>
   ElementTypesIteratorHelper elementTypes(pack &&... _pack) const;
 
   inline type_iterator firstType(UInt dim = _all_dimensions,
                                  GhostType ghost_type = _not_ghost,
                                  ElementKind kind = _ek_regular) const {
     return connectivities.firstType(dim, ghost_type, kind);
   }
 
   inline type_iterator lastType(UInt dim = _all_dimensions,
                                 GhostType ghost_type = _not_ghost,
                                 ElementKind kind = _ek_regular) const {
     return connectivities.lastType(dim, ghost_type, kind);
   }
 
   AKANTU_GET_MACRO(ElementSynchronizer, *element_synchronizer,
                    const ElementSynchronizer &);
   AKANTU_GET_MACRO_NOT_CONST(ElementSynchronizer, *element_synchronizer,
                              ElementSynchronizer &);
   AKANTU_GET_MACRO(NodeSynchronizer, *node_synchronizer,
                    const NodeSynchronizer &);
   AKANTU_GET_MACRO_NOT_CONST(NodeSynchronizer, *node_synchronizer,
                              NodeSynchronizer &);
   AKANTU_GET_MACRO(PeriodicNodeSynchronizer, *periodic_node_synchronizer,
                    const PeriodicNodeSynchronizer &);
   AKANTU_GET_MACRO_NOT_CONST(PeriodicNodeSynchronizer, *periodic_node_synchronizer,
                              PeriodicNodeSynchronizer &);
 
 // AKANTU_GET_MACRO_NOT_CONST(Communicator, *communicator, StaticCommunicator
 // &);
 #ifndef SWIG
   AKANTU_GET_MACRO(Communicator, *communicator, const auto &);
   AKANTU_GET_MACRO_NOT_CONST(Communicator, *communicator, auto &);
   AKANTU_GET_MACRO(PeriodicMasterSlaves, periodic_master_slave, const auto &);
 #endif
 
   /* ------------------------------------------------------------------------ */
   /* Private methods for friends                                              */
   /* ------------------------------------------------------------------------ */
 private:
   friend class MeshAccessor;
   friend class MeshUtils;
 
   AKANTU_GET_MACRO(NodesPointer, *nodes, Array<Real> &);
 
   /// get a pointer to the nodes_global_ids Array<UInt> and create it if
   /// necessary
   inline Array<UInt> & getNodesGlobalIdsPointer();
 
   /// get a pointer to the nodes_type Array<Int> and create it if necessary
   inline Array<NodeFlag> & getNodesFlagsPointer();
 
   /// get a pointer to the connectivity Array for the given type and create it
   /// if necessary
   inline Array<UInt> &
   getConnectivityPointer(const ElementType & type,
                          const GhostType & ghost_type = _not_ghost);
 
   /// get the ghost element counter
   inline Array<UInt> &
   getGhostsCounters(const ElementType & type,
                     const GhostType & ghost_type = _ghost) {
     AKANTU_DEBUG_ASSERT(ghost_type != _not_ghost,
                         "No ghost counter for _not_ghost elements");
     return ghosts_counters(type, ghost_type);
   }
 
   /// get a pointer to the element_to_subelement Array for the given type and
   /// create it if necessary
   inline Array<std::vector<Element>> &
   getElementToSubelementPointer(const ElementType & type,
                                 const GhostType & ghost_type = _not_ghost);
 
   /// get a pointer to the subelement_to_element Array for the given type and
   /// create it if necessary
   inline Array<Element> &
   getSubelementToElementPointer(const ElementType & type,
                                 const GhostType & ghost_type = _not_ghost);
 
   AKANTU_GET_MACRO_NOT_CONST(MeshData, mesh_data, MeshData &);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// array of the nodes coordinates
   std::shared_ptr<Array<Real>> nodes;
 
   /// global node ids
   std::shared_ptr<Array<UInt>> nodes_global_ids;
 
   /// node flags (shared/periodic/...)
   std::shared_ptr<Array<NodeFlag>> nodes_flags;
 
   /// processor handling the node when not local or master
   std::unordered_map<UInt, Int> nodes_prank;
 
   /// global number of nodes;
   UInt nb_global_nodes{0};
 
   /// all class of elements present in this mesh (for heterogenous meshes)
   ElementTypeMapArray<UInt> connectivities;
 
   /// count the references on ghost elements
   ElementTypeMapArray<UInt> ghosts_counters;
 
   /// map to normals for all class of elements present in this mesh
   ElementTypeMapArray<Real> normals;
 
   /// the spatial dimension of this mesh
   UInt spatial_dimension{0};
 
   /// size covered by the mesh on each direction
   Vector<Real> size;
   /// global bounding box
   BBox bbox;
 
   /// local bounding box
   BBox bbox_local;
 
   /// Extra data loaded from the mesh file
   MeshData mesh_data;
 
   /// facets' mesh
   std::unique_ptr<Mesh> mesh_facets;
 
   /// parent mesh (this is set for mesh_facets meshes)
   const Mesh * mesh_parent{nullptr};
 
   /// defines if current mesh is mesh_facets or not
   bool is_mesh_facets{false};
 
   /// defines if the mesh is centralized or distributed
   bool is_distributed{false};
 
   /// defines if the mesh is periodic
   bool is_periodic{false};
 
   /// Communicator on which mesh is distributed
   Communicator * communicator;
 
   /// Element synchronizer
   std::unique_ptr<ElementSynchronizer> element_synchronizer;
 
   /// Node synchronizer
   std::unique_ptr<NodeSynchronizer> node_synchronizer;
 
   /// Node synchronizer for periodic nodes
   std::unique_ptr<PeriodicNodeSynchronizer> periodic_node_synchronizer;
 
   using NodesToElements = std::vector<std::unique_ptr<std::set<Element>>>;
 
   /// class to update global data using external knowledge
   std::unique_ptr<MeshGlobalDataUpdater> global_data_updater;
 
   /// This info is stored to simplify the dynamic changes
   NodesToElements nodes_to_elements;
 
   /// periodicity local info
   std::unordered_map<UInt, UInt> periodic_slave_master;
   std::unordered_multimap<UInt, UInt> periodic_master_slave;
 };
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream, const Mesh & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 /* Inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 #include "element_type_map_tmpl.hh"
 #include "mesh_inline_impl.cc"
 
 #endif /* __AKANTU_MESH_HH__ */
diff --git a/src/mesh/mesh_inline_impl.cc b/src/mesh/mesh_inline_impl.cc
index 323867b17..94ebb8808 100644
--- a/src/mesh/mesh_inline_impl.cc
+++ b/src/mesh/mesh_inline_impl.cc
@@ -1,746 +1,785 @@
 /**
  * @file   mesh_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Thu Jul 15 2010
  * @date last modification: Mon Dec 18 2017
  *
  * @brief  Implementation of the inline functions of the mesh class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_iterators.hh"
 #include "element_class.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MESH_INLINE_IMPL_CC__
 #define __AKANTU_MESH_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 inline ElementKind Element::kind() const { return Mesh::getKind(type); }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 template <typename... pack>
 Mesh::ElementTypesIteratorHelper Mesh::elementTypes(pack &&... _pack) const {
   return connectivities.elementTypes(_pack...);
 }
 
 /* -------------------------------------------------------------------------- */
 inline RemovedNodesEvent::RemovedNodesEvent(const Mesh & mesh)
     : new_numbering(mesh.getNbNodes(), 1, "new_numbering") {}
 
 /* -------------------------------------------------------------------------- */
 inline RemovedElementsEvent::RemovedElementsEvent(const Mesh & mesh,
                                                   const ID & new_numbering_id)
     : new_numbering(new_numbering_id, mesh.getID(), mesh.getMemoryID()) {}
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void Mesh::sendEvent<NewElementsEvent>(NewElementsEvent & event) {
   this->nodes_to_elements.resize(nodes->size());
   for (const auto & elem : event.getList()) {
     const Array<UInt> & conn = connectivities(elem.type, elem.ghost_type);
 
     UInt nb_nodes_per_elem = this->getNbNodesPerElement(elem.type);
 
     for (UInt n = 0; n < nb_nodes_per_elem; ++n) {
       UInt node = conn(elem.element, n);
       if (not nodes_to_elements[node])
         nodes_to_elements[node] = std::make_unique<std::set<Element>>();
       nodes_to_elements[node]->insert(elem);
     }
   }
 
   EventHandlerManager<MeshEventHandler>::sendEvent(event);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> inline void Mesh::sendEvent<NewNodesEvent>(NewNodesEvent & event) {
   this->computeBoundingBox();
   this->nodes_flags->resize(this->nodes->size(), NodeFlag::_normal);
   EventHandlerManager<MeshEventHandler>::sendEvent(event);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 Mesh::sendEvent<RemovedElementsEvent>(RemovedElementsEvent & event) {
   this->connectivities.onElementsRemoved(event.getNewNumbering());
   this->fillNodesToElements();
   this->computeBoundingBox();
 
   EventHandlerManager<MeshEventHandler>::sendEvent(event);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void Mesh::sendEvent<RemovedNodesEvent>(RemovedNodesEvent & event) {
   const auto & new_numbering = event.getNewNumbering();
   this->removeNodesFromArray(*nodes, new_numbering);
   if (nodes_global_ids and not is_mesh_facets)
     this->removeNodesFromArray(*nodes_global_ids, new_numbering);
   if (not is_mesh_facets)
     this->removeNodesFromArray(*nodes_flags, new_numbering);
 
   if (not nodes_to_elements.empty()) {
     std::vector<std::unique_ptr<std::set<Element>>> tmp(
         nodes_to_elements.size());
     auto it = nodes_to_elements.begin();
 
     UInt new_nb_nodes = 0;
     for (auto new_i : new_numbering) {
       if (new_i != UInt(-1)) {
         tmp[new_i] = std::move(*it);
         ++new_nb_nodes;
       }
       ++it;
     }
 
     tmp.resize(new_nb_nodes);
     std::move(tmp.begin(), tmp.end(), nodes_to_elements.begin());
   }
 
   computeBoundingBox();
 
   EventHandlerManager<MeshEventHandler>::sendEvent(event);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Mesh::removeNodesFromArray(Array<T> & vect,
                                        const Array<UInt> & new_numbering) {
   Array<T> tmp(vect.size(), vect.getNbComponent());
   UInt nb_component = vect.getNbComponent();
   UInt new_nb_nodes = 0;
   for (UInt i = 0; i < new_numbering.size(); ++i) {
     UInt new_i = new_numbering(i);
     if (new_i != UInt(-1)) {
       T * to_copy = vect.storage() + i * nb_component;
       std::uninitialized_copy(to_copy, to_copy + nb_component,
                               tmp.storage() + new_i * nb_component);
       ++new_nb_nodes;
     }
   }
 
   tmp.resize(new_nb_nodes);
   vect.copy(tmp);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<UInt> & Mesh::getNodesGlobalIdsPointer() {
   AKANTU_DEBUG_IN();
   if (not nodes_global_ids) {
     nodes_global_ids = std::make_shared<Array<UInt>>(
         nodes->size(), 1, getID() + ":nodes_global_ids");
 
     for (auto && global_ids : enumerate(*nodes_global_ids)) {
       std::get<1>(global_ids) = std::get<0>(global_ids);
     }
   }
 
   AKANTU_DEBUG_OUT();
   return *nodes_global_ids;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<UInt> &
 Mesh::getConnectivityPointer(const ElementType & type,
                              const GhostType & ghost_type) {
   if (connectivities.exists(type, ghost_type))
     return connectivities(type, ghost_type);
 
   if (ghost_type != _not_ghost) {
     ghosts_counters.alloc(0, 1, type, ghost_type, 1);
   }
 
   AKANTU_DEBUG_INFO("The connectivity vector for the type " << type
                                                             << " created");
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   return connectivities.alloc(0, nb_nodes_per_element, type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<std::vector<Element>> &
 Mesh::getElementToSubelementPointer(const ElementType & type,
                                     const GhostType & ghost_type) {
   return getDataPointer<std::vector<Element>>("element_to_subelement", type,
                                               ghost_type, 1, true);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<Element> &
 Mesh::getSubelementToElementPointer(const ElementType & type,
                                     const GhostType & ghost_type) {
   auto & array = getDataPointer<Element>(
       "subelement_to_element", type, ghost_type, getNbFacetsPerElement(type),
       true, is_mesh_facets, ElementNull);
   return array;
 }
 
 /* -------------------------------------------------------------------------- */
 inline const auto & Mesh::getElementToSubelement() const {
   return getData<std::vector<Element>>("element_to_subelement");
 }
 
 /* -------------------------------------------------------------------------- */
 inline const auto &
 Mesh::getElementToSubelement(const ElementType & type,
                              const GhostType & ghost_type) const {
   return getData<std::vector<Element>>("element_to_subelement", type,
                                        ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto & Mesh::getElementToSubelement(const ElementType & type,
                                            const GhostType & ghost_type) {
   return getData<std::vector<Element>>("element_to_subelement", type,
                                        ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline const auto &
 Mesh::getElementToSubelement(const Element & element) const {
   return getData<std::vector<Element>>("element_to_subelement")(element);
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto & Mesh::getElementToSubelement(const Element & element) {
   return getData<std::vector<Element>>("element_to_subelement")(element);
 }
 
 /* -------------------------------------------------------------------------- */
 inline const auto & Mesh::getSubelementToElement() const {
   return getData<Element>("subelement_to_element");
 }
 
 /* -------------------------------------------------------------------------- */
 inline const auto &
 Mesh::getSubelementToElement(const ElementType & type,
                              const GhostType & ghost_type) const {
   return getData<Element>("subelement_to_element", type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto & Mesh::getSubelementToElement(const ElementType & type,
                                            const GhostType & ghost_type) {
   return getData<Element>("subelement_to_element", type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline VectorProxy<Element>
 Mesh::getSubelementToElement(const Element & element) const {
   const auto & sub_to_element =
       this->getSubelementToElement(element.type, element.ghost_type);
   auto it = sub_to_element.begin(sub_to_element.getNbComponent());
   return it[element.element];
 }
 
 /* -------------------------------------------------------------------------- */
 inline VectorProxy<Element>
 Mesh::getSubelementToElement(const Element & element) {
   auto & sub_to_element =
       this->getSubelementToElement(element.type, element.ghost_type);
   auto it = sub_to_element.begin(sub_to_element.getNbComponent());
   return it[element.element];
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline Array<T> &
 Mesh::getDataPointer(const ID & data_name, const ElementType & el_type,
                      const GhostType & ghost_type, UInt nb_component,
                      bool size_to_nb_element, bool resize_with_parent) {
   Array<T> & tmp = mesh_data.getElementalDataArrayAlloc<T>(
       data_name, el_type, ghost_type, nb_component);
 
   if (size_to_nb_element) {
     if (resize_with_parent)
       tmp.resize(mesh_parent->getNbElement(el_type, ghost_type));
     else
       tmp.resize(this->getNbElement(el_type, ghost_type));
   } else {
     tmp.resize(0);
   }
 
   return tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline Array<T> &
 Mesh::getDataPointer(const ID & data_name, const ElementType & el_type,
                      const GhostType & ghost_type, UInt nb_component,
                      bool size_to_nb_element, bool resize_with_parent,
                      const T & defaul_) {
   Array<T> & tmp = mesh_data.getElementalDataArrayAlloc<T>(
       data_name, el_type, ghost_type, nb_component);
 
   if (size_to_nb_element) {
     if (resize_with_parent)
       tmp.resize(mesh_parent->getNbElement(el_type, ghost_type), defaul_);
     else
       tmp.resize(this->getNbElement(el_type, ghost_type), defaul_);
   } else {
     tmp.resize(0);
   }
 
   return tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline bool Mesh::hasData(const ID & data_name, const ElementType & el_type,
                           const GhostType & ghost_type) const {
   return mesh_data.hasDataArray<T>(data_name, el_type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline const Array<T> & Mesh::getData(const ID & data_name,
                                       const ElementType & el_type,
                                       const GhostType & ghost_type) const {
   return mesh_data.getElementalDataArray<T>(data_name, el_type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline Array<T> & Mesh::getData(const ID & data_name,
                                 const ElementType & el_type,
                                 const GhostType & ghost_type) {
   return mesh_data.getElementalDataArray<T>(data_name, el_type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::hasData(const ID & data_name) const {
   return mesh_data.hasData(data_name);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline const ElementTypeMapArray<T> &
 Mesh::getData(const ID & data_name) const {
   return mesh_data.getElementalData<T>(data_name);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline ElementTypeMapArray<T> & Mesh::getData(const ID & data_name) {
   return mesh_data.getElementalData<T>(data_name);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline ElementTypeMapArray<T> & Mesh::registerData(const ID & data_name) {
   this->mesh_data.registerElementalData<T>(data_name);
   return this->getData<T>(data_name);
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbElement(const ElementType & type,
                                const GhostType & ghost_type) const {
   try {
 
     const Array<UInt> & conn = connectivities(type, ghost_type);
     return conn.size();
   } catch (...) {
     return 0;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbElement(const UInt spatial_dimension,
                                const GhostType & ghost_type,
                                const ElementKind & kind) const {
   AKANTU_DEBUG_ASSERT(spatial_dimension <= 3 || spatial_dimension == UInt(-1),
                       "spatial_dimension is " << spatial_dimension
                                               << " and is greater than 3 !");
   UInt nb_element = 0;
 
   for (auto type : elementTypes(spatial_dimension, ghost_type, kind))
     nb_element += getNbElement(type, ghost_type);
 
   return nb_element;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Mesh::getBarycenter(const Element & element,
                                 Vector<Real> & barycenter) const {
   Vector<UInt> conn = getConnectivity(element);
   Matrix<Real> local_coord(spatial_dimension, conn.size());
   auto node_begin = make_view(*nodes, spatial_dimension).begin();
 
   for (auto && node : enumerate(conn)) {
     local_coord(std::get<0>(node)) =
         Vector<Real>(node_begin[std::get<1>(node)]);
   }
 
   Math::barycenter(local_coord.storage(), conn.size(), spatial_dimension,
                    barycenter.storage());
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbNodesPerElement(const ElementType & type) {
   UInt nb_nodes_per_element = 0;
 #define GET_NB_NODES_PER_ELEMENT(type)                                         \
   nb_nodes_per_element = ElementClass<type>::getNbNodesPerElement()
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_NB_NODES_PER_ELEMENT);
 #undef GET_NB_NODES_PER_ELEMENT
   return nb_nodes_per_element;
 }
 
 /* -------------------------------------------------------------------------- */
 inline ElementType Mesh::getP1ElementType(const ElementType & type) {
   ElementType p1_type = _not_defined;
 #define GET_P1_TYPE(type) p1_type = ElementClass<type>::getP1ElementType()
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_P1_TYPE);
 #undef GET_P1_TYPE
   return p1_type;
 }
 
 /* -------------------------------------------------------------------------- */
 inline ElementKind Mesh::getKind(const ElementType & type) {
   ElementKind kind = _ek_not_defined;
 #define GET_KIND(type) kind = ElementClass<type>::getKind()
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_KIND);
 #undef GET_KIND
   return kind;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getSpatialDimension(const ElementType & type) {
   UInt spatial_dimension = 0;
 #define GET_SPATIAL_DIMENSION(type)                                            \
   spatial_dimension = ElementClass<type>::getSpatialDimension()
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_SPATIAL_DIMENSION);
 #undef GET_SPATIAL_DIMENSION
 
   return spatial_dimension;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbFacetTypes(const ElementType & type,
                                   __attribute__((unused)) UInt t) {
   UInt nb = 0;
 #define GET_NB_FACET_TYPE(type) nb = ElementClass<type>::getNbFacetTypes()
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_NB_FACET_TYPE);
 #undef GET_NB_FACET_TYPE
   return nb;
 }
 
 /* -------------------------------------------------------------------------- */
 inline constexpr auto Mesh::getFacetType(const ElementType & type, UInt t) {
 #define GET_FACET_TYPE(type) return ElementClass<type>::getFacetType(t);
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH_NO_DEFAULT(GET_FACET_TYPE);
 
 #undef GET_FACET_TYPE
 
   return _not_defined;
 }
 
 /* -------------------------------------------------------------------------- */
 inline constexpr auto Mesh::getAllFacetTypes(const ElementType & type) {
 #define GET_FACET_TYPE(type) return ElementClass<type>::getFacetTypes();
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH_NO_DEFAULT(GET_FACET_TYPE);
 #undef GET_FACET_TYPE
 
   return ElementClass<_not_defined>::getFacetTypes();
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbFacetsPerElement(const ElementType & type) {
   AKANTU_DEBUG_IN();
 
   UInt n_facet = 0;
 #define GET_NB_FACET(type) n_facet = ElementClass<type>::getNbFacetsPerElement()
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_NB_FACET);
 #undef GET_NB_FACET
 
   AKANTU_DEBUG_OUT();
   return n_facet;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbFacetsPerElement(const ElementType & type, UInt t) {
   AKANTU_DEBUG_IN();
 
   UInt n_facet = 0;
 #define GET_NB_FACET(type)                                                     \
   n_facet = ElementClass<type>::getNbFacetsPerElement(t)
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_NB_FACET);
 #undef GET_NB_FACET
 
   AKANTU_DEBUG_OUT();
   return n_facet;
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::getFacetLocalConnectivity(const ElementType & type, UInt t) {
   AKANTU_DEBUG_IN();
 
 #define GET_FACET_CON(type)                                                    \
   AKANTU_DEBUG_OUT();                                                          \
   return ElementClass<type>::getFacetLocalConnectivityPerElement(t)
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_FACET_CON);
 #undef GET_FACET_CON
 
   AKANTU_DEBUG_OUT();
   return ElementClass<_not_defined>::getFacetLocalConnectivityPerElement(0);
   // This avoid a compilation warning but will certainly
   // also cause a segfault if reached
 }
 
 /* -------------------------------------------------------------------------- */
 inline auto Mesh::getFacetConnectivity(const Element & element, UInt t) const {
   AKANTU_DEBUG_IN();
 
   Matrix<const UInt> local_facets(getFacetLocalConnectivity(element.type, t));
   Matrix<UInt> facets(local_facets.rows(), local_facets.cols());
 
   const Array<UInt> & conn = connectivities(element.type, element.ghost_type);
 
   for (UInt f = 0; f < facets.rows(); ++f) {
     for (UInt n = 0; n < facets.cols(); ++n) {
       facets(f, n) = conn(element.element, local_facets(f, n));
     }
   }
 
   AKANTU_DEBUG_OUT();
   return facets;
 }
 
 /* -------------------------------------------------------------------------- */
 inline VectorProxy<UInt> Mesh::getConnectivity(const Element & element) const {
   const auto & conn = connectivities(element.type, element.ghost_type);
   auto it = conn.begin(conn.getNbComponent());
   return it[element.element];
 }
 
 /* -------------------------------------------------------------------------- */
 inline VectorProxy<UInt> Mesh::getConnectivity(const Element & element) {
   auto & conn = connectivities(element.type, element.ghost_type);
   auto it = conn.begin(conn.getNbComponent());
   return it[element.element];
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Mesh::extractNodalValuesFromElement(
     const Array<T> & nodal_values, T * local_coord, UInt * connectivity,
     UInt n_nodes, UInt nb_degree_of_freedom) const {
   for (UInt n = 0; n < n_nodes; ++n) {
     memcpy(local_coord + n * nb_degree_of_freedom,
            nodal_values.storage() + connectivity[n] * nb_degree_of_freedom,
            nb_degree_of_freedom * sizeof(T));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Mesh::addConnectivityType(const ElementType & type,
                                       const GhostType & ghost_type) {
   getConnectivityPointer(type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isPureGhostNode(UInt n) const {
   return ((*nodes_flags)(n)&NodeFlag::_shared_mask) == NodeFlag::_pure_ghost;
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isLocalOrMasterNode(UInt n) const {
   return ((*nodes_flags)(n)&NodeFlag::_local_master_mask) == NodeFlag::_normal;
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isLocalNode(UInt n) const {
   return ((*nodes_flags)(n)&NodeFlag::_shared_mask) == NodeFlag::_normal;
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isMasterNode(UInt n) const {
   return ((*nodes_flags)(n)&NodeFlag::_shared_mask) == NodeFlag::_master;
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isSlaveNode(UInt n) const {
   return ((*nodes_flags)(n)&NodeFlag::_shared_mask) == NodeFlag::_slave;
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isPeriodicSlave(UInt n) const {
   return ((*nodes_flags)(n)&NodeFlag::_periodic_mask) ==
          NodeFlag::_periodic_slave;
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isPeriodicMaster(UInt n) const {
   return ((*nodes_flags)(n)&NodeFlag::_periodic_mask) ==
          NodeFlag::_periodic_master;
 }
 
 /* -------------------------------------------------------------------------- */
 inline NodeFlag Mesh::getNodeFlag(UInt local_id) const {
   return (*nodes_flags)(local_id);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Int Mesh::getNodePrank(UInt local_id) const {
   auto it = nodes_prank.find(local_id);
   return it == nodes_prank.end() ? -1 : it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNodeGlobalId(UInt local_id) const {
   return nodes_global_ids ? (*nodes_global_ids)(local_id) : local_id;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNodeLocalId(UInt global_id) const {
   AKANTU_DEBUG_ASSERT(nodes_global_ids != nullptr,
                       "The global ids are note set.");
   return nodes_global_ids->find(global_id);
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbGlobalNodes() const {
   return nodes_global_ids ? nb_global_nodes : nodes->size();
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbNodesPerElementList(const Array<Element> & elements) {
   UInt nb_nodes_per_element = 0;
   UInt nb_nodes = 0;
   ElementType current_element_type = _not_defined;
 
   for (const auto & el : elements) {
     if (el.type != current_element_type) {
       current_element_type = el.type;
       nb_nodes_per_element = Mesh::getNbNodesPerElement(current_element_type);
     }
 
     nb_nodes += nb_nodes_per_element;
   }
 
   return nb_nodes;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Mesh & Mesh::getMeshFacets() {
   if (!this->mesh_facets)
     AKANTU_SILENT_EXCEPTION(
         "No facet mesh is defined yet! check the buildFacets functions");
 
   return *this->mesh_facets;
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Mesh & Mesh::getMeshFacets() const {
   if (!this->mesh_facets)
     AKANTU_SILENT_EXCEPTION(
         "No facet mesh is defined yet! check the buildFacets functions");
 
   return *this->mesh_facets;
 }
 /* -------------------------------------------------------------------------- */
 inline const Mesh & Mesh::getMeshParent() const {
   if (!this->mesh_parent)
     AKANTU_SILENT_EXCEPTION(
         "No parent mesh is defined! This is only valid in a mesh_facets");
 
   return *this->mesh_parent;
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::addPeriodicSlave(UInt slave, UInt master) {
   if (master == slave)
     return;
 
   // if pair already registered
   auto master_slaves = periodic_master_slave.equal_range(master);
   auto slave_it =
       std::find_if(master_slaves.first, master_slaves.second,
                    [&](auto & pair) { return pair.second == slave; });
   if (slave_it == master_slaves.second) {
     // no duplicates
     periodic_master_slave.insert(std::make_pair(master, slave));
     AKANTU_DEBUG_INFO("adding periodic slave, slave gid:"
                       << getNodeGlobalId(slave) << " [lid: " << slave << "]"
                       << ", master gid:" << getNodeGlobalId(master)
                       << " [lid: " << master << "]");
     std::cout << "adding periodic slave, slave gid:" << getNodeGlobalId(slave)
               << " [lid: " << slave << "]"
               << ", master gid:" << getNodeGlobalId(master)
               << " [lid: " << master << "]" << std::endl;
   }
 
   periodic_slave_master[slave] = master;
 
   auto set_flag = [&](auto node, auto flag) {
     (*nodes_flags)[node] &= ~NodeFlag::_periodic_mask; // clean periodic flags
     (*nodes_flags)[node] |= flag;
   };
 
   set_flag(slave, NodeFlag::_periodic_slave);
   set_flag(master, NodeFlag::_periodic_master);
 }
 
 /* -------------------------------------------------------------------------- */
 UInt Mesh::getPeriodicMaster(UInt slave) const {
   return periodic_slave_master.at(slave);
 }
 
+/* -------------------------------------------------------------------------- */
+class Mesh::PeriodicSlaves {
+  using internal_iterator = std::unordered_multimap<UInt, UInt>::const_iterator;
+  std::pair<internal_iterator, internal_iterator> pair;
+
+public:
+  PeriodicSlaves(const Mesh & mesh, UInt master)
+      : pair(mesh.getPeriodicMasterSlaves().equal_range(master)) {}
+
+  PeriodicSlaves(const PeriodicSlaves & other) = default;
+  PeriodicSlaves(PeriodicSlaves && other) = default;
+  PeriodicSlaves & operator=(const PeriodicSlaves & other) = default;
+
+  class const_iterator {
+    internal_iterator it;
+
+  public:
+    const_iterator(internal_iterator it) : it(std::move(it)) {}
+
+    const_iterator operator++() {
+      ++it;
+      return *this;
+    }
+    bool
+    operator!=(const const_iterator & other) {
+      return other.it != it;
+    }
+    auto operator*() { return it->second; }
+  };
+
+  auto begin() { return const_iterator(pair.first); }
+  auto end() { return const_iterator(pair.second); }
+};
+
+/* -------------------------------------------------------------------------- */
+inline decltype(auto) Mesh::getPeriodicSlaves(UInt master) const {
+  return PeriodicSlaves(*this, master);
+}
+
 /* -------------------------------------------------------------------------- */
 inline Vector<UInt>
 Mesh::getConnectivityWithPeriodicity(const Element & element) const {
   Vector<UInt> conn = getConnectivity(element);
   if (not isPeriodic()) {
     return conn;
   }
 
   for (auto && node : conn) {
     if (isPeriodicSlave(node)) {
       node = getPeriodicMaster(node);
     }
   }
 
   return conn;
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_MESH_INLINE_IMPL_CC__ */
diff --git a/src/mesh/mesh_periodic.cc b/src/mesh/mesh_periodic.cc
index 1c75c371e..83cd5789f 100644
--- a/src/mesh/mesh_periodic.cc
+++ b/src/mesh/mesh_periodic.cc
@@ -1,435 +1,460 @@
 /**
  * @file   mesh_pbc.cc
  *
  * @author Nicolas Richart
  *
  * @date creation  Sat Feb 10 2018
  *
  * @brief Implementation of the perdiodicity capabilities in the mesh
  *
  * @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 "communication_tag.hh"
 #include "communicator.hh"
 #include "element_group.hh"
 #include "mesh.hh"
 #include "periodic_node_synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 void Mesh::makePeriodic(const SpatialDirection & direction) {
   Array<UInt> list_1;
   Array<UInt> list_2;
   Real tolerance = 1e-10;
 
   auto lower_bound = this->getLowerBounds();
   auto upper_bound = this->getUpperBounds();
   auto length = upper_bound(direction) - lower_bound(direction);
 
   const auto & positions = *nodes;
 
   for (auto && data : enumerate(make_view(positions, spatial_dimension))) {
     UInt node = std::get<0>(data);
     const auto & pos = std::get<1>(data);
 
     if (std::abs((pos(direction) - lower_bound(direction)) / length) <
         tolerance) {
       list_1.push_back(node);
     }
 
     if (std::abs((pos(direction) - upper_bound(direction)) / length) <
         tolerance) {
       list_2.push_back(node);
     }
   }
 
   this->makePeriodic(direction, list_1, list_2);
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::makePeriodic(const SpatialDirection & direction, const ID & list_1,
                         const ID & list_2) {
   const auto & list_nodes_1 =
       mesh.getElementGroup(list_1).getNodeGroup().getNodes();
   const auto & list_nodes_2 =
       mesh.getElementGroup(list_2).getNodeGroup().getNodes();
 
   this->makePeriodic(direction, list_nodes_1, list_nodes_2);
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
 namespace {
   struct NodeInfo {
     NodeInfo() {}
     NodeInfo(UInt spatial_dimension) : position(spatial_dimension) {}
     NodeInfo(UInt node, const Vector<Real> & position,
              const SpatialDirection & direction)
         : node(node), position(position) {
       this->direction_position = position(direction);
       this->position(direction) = 0.;
     }
 
     NodeInfo(const NodeInfo & other)
         : node(other.node), position(other.position),
           direction_position(other.direction_position) {}
 
     UInt node{0};
     Vector<Real> position;
     Real direction_position{0.};
   };
 }
 
 /* -------------------------------------------------------------------------- */
 // left is for lower values on direction and right for highest values
 void Mesh::makePeriodic(const SpatialDirection & direction,
                         const Array<UInt> & list_left,
                         const Array<UInt> & list_right) {
   Real tolerance = 1e-10;
 
   const auto & positions = *nodes;
   auto lower_bound = this->getLowerBounds();
   auto upper_bound = this->getUpperBounds();
   auto length = upper_bound(direction) - lower_bound(direction);
 
   lower_bound(direction) = 0;
   upper_bound(direction) = 0;
 
   auto prank = communicator->whoAmI();
 
   std::vector<NodeInfo> nodes_left(list_left.size());
   std::vector<NodeInfo> nodes_right(list_right.size());
 
   BBox bbox(spatial_dimension);
   auto to_position = [&](UInt node) {
     Vector<Real> pos(spatial_dimension);
     for (UInt s : arange(spatial_dimension)) {
       pos(s) = positions(node, s);
     }
     auto && info = NodeInfo(node, pos, direction);
     bbox += info.position;
     return info;
   };
 
   std::transform(list_left.begin(), list_left.end(), nodes_left.begin(),
                  to_position);
   BBox bbox_left = bbox;
 
   bbox.reset();
   std::transform(list_right.begin(), list_right.end(), nodes_right.begin(),
                  to_position);
   BBox bbox_right = bbox;
 
   std::vector<UInt> new_nodes;
   if (is_distributed) {
     NewNodesEvent event;
 
     /* ---------------------------------------------------------------------- */
+    // function to send nodes in bboxes intersections
     auto extract_and_send_nodes = [&](const auto & bbox, const auto & node_list,
-                                      auto & send_buffers, auto proc,
-                                      auto cnt) {
-      send_buffers.emplace_back();
-      auto & buffer = send_buffers.back();
+                                      auto & buffer, auto proc, auto cnt) {
 
+      // std::cout << "Sending to " << proc << std::endl;
       for (auto & info : node_list) {
         if (bbox.contains(info.position) and isLocalOrMasterNode(info.node)) {
           Vector<Real> pos = info.position;
           pos(direction) = info.direction_position;
 
-          buffer << getNodeGlobalId(info.node);
+          NodeFlag flag = (*nodes_flags)(info.node) & NodeFlag::_periodic_mask;
+          buffer << UInt(getNodeGlobalId(info.node));
           buffer << pos;
-          buffer << ((*nodes_flags)(info.node) & NodeFlag::_periodic_mask);
+          buffer << flag;
+
+          // std::cout << " - node " << getNodeGlobalId(info.node);
 
           // if is slave sends master info
-          if (isPeriodicSlave(info.node)) {
-            buffer << getNodeGlobalId(periodic_slave_master[info.node]);
+          if (flag == NodeFlag::_periodic_slave) {
+            UInt master = getNodeGlobalId(periodic_slave_master[info.node]);
+            // std::cout << " slave of " << master << std::endl;
+            buffer << master;
           }
 
           // if is master sends list of slaves
-          if (isPeriodicMaster(info.node)) {
+          if (flag == NodeFlag::_periodic_master) {
             UInt nb_slaves = periodic_master_slave.count(info.node);
             buffer << nb_slaves;
 
+            // std::cout << " master of " << nb_slaves << " nodes : [";
             auto slaves = periodic_master_slave.equal_range(info.node);
             for (auto it = slaves.first; it != slaves.second; ++it) {
               UInt gslave = getNodeGlobalId(it->second);
+              // std::cout << (it == slaves.first ? "" : ", ") << gslave;
               buffer << gslave;
             }
+            // std::cout << "]";
           }
+          // std::cout << std::endl;
         }
       }
 
-      auto tag = Tag::genTag(prank, cnt, Tag::_PERIODIC_NODES);
+      auto tag = Tag::genTag(prank, 10 * direction + cnt, Tag::_PERIODIC_NODES);
+      std::cout << "SBuffer size " << buffer.size() << " " << tag << std::endl;
       return communicator->asyncSend(buffer, proc, tag);
     };
 
     /* ---------------------------------------------------------------------- */
-    auto recv_and_extract_nodes = [&](auto & bbox, auto & node_list,
-                                      const auto proc, auto cnt) {
-      if (not bbox)
-        return;
-
+    // function to receive nodes in bboxes intersections
+    auto recv_and_extract_nodes = [&](auto & node_list, const auto proc,
+                                      auto cnt) {
       DynamicCommunicationBuffer buffer;
-      auto tag = Tag::genTag(proc, cnt, Tag::_PERIODIC_NODES);
+      auto tag = Tag::genTag(proc, 10 * direction + cnt, Tag::_PERIODIC_NODES);
       communicator->receive(buffer, proc, tag);
+      std::cout << "RBuffer size " << buffer.size() << " " << tag << std::endl;
+      // std::cout << "Receiving from " << proc << std::endl;
 
       while (not buffer.empty()) {
         Vector<Real> pos(spatial_dimension);
         UInt global_node;
         NodeFlag flag;
         buffer >> global_node;
         buffer >> pos;
         buffer >> flag;
 
+        // std::cout << " - node " << global_node;
         auto local_node = getNodeLocalId(global_node);
 
         // get the master info of is slave
-        if ((flag & NodeFlag::_periodic_mask) == NodeFlag::_periodic_slave) {
+        if (flag == NodeFlag::_periodic_slave) {
           UInt master_node;
           buffer >> master_node;
-          auto local_master_node = getNodeLocalId(master_node);
-          AKANTU_DEBUG_ASSERT(local_master_node != UInt(-1),
-                              "Should I know the master node " << master_node);
+          // std::cout << " slave of " << master_node << std::endl;
+          // auto local_master_node = getNodeLocalId(master_node);
+          // AKANTU_DEBUG_ASSERT(local_master_node != UInt(-1),
+          //"Should I know the master node " << master_node);
         }
 
         // get the list of slaves if is master
         if ((flag & NodeFlag::_periodic_mask) == NodeFlag::_periodic_master) {
           UInt nb_slaves;
           buffer >> nb_slaves;
+          // std::cout << " master of " << nb_slaves << " nodes : [";
           for (auto ns[[gnu::unused]] : arange(nb_slaves)) {
             UInt gslave_node;
             buffer >> gslave_node;
-            auto lslave_node = getNodeLocalId(gslave_node);
-            AKANTU_DEBUG_ASSERT(lslave_node != UInt(-1),
-                                "Should I know the slave node " << gslave_node);
+            // std::cout << (ns == 0 ? "" : ", ") << gslave_node;
+            // auto lslave_node = getNodeLocalId(gslave_node);
+            // AKANTU_DEBUG_ASSERT(lslave_node != UInt(-1),
+            //                    "Should I know the slave node " <<
+            //                    gslave_node);
           }
+          // std::cout << "]";
         }
-
+        // std::cout << std::endl;
         if (local_node != UInt(-1))
           continue;
 
         local_node = nodes->size();
 
         NodeInfo info(local_node, pos, direction);
-
         nodes->push_back(pos);
         nodes_global_ids->push_back(global_node);
         nodes_flags->push_back(flag | NodeFlag::_pure_ghost);
         new_nodes.push_back(info.node);
         node_list.push_back(info);
 
         nodes_prank[info.node] = proc;
         event.getList().push_back(local_node);
       }
     };
 
     /* ---------------------------------------------------------------------- */
     auto && intersections_with_right =
         bbox_left.intersection(bbox_right, *communicator);
     auto && intersections_with_left =
         bbox_right.intersection(bbox_left, *communicator);
 
     auto prank = communicator->whoAmI();
     auto nb_proc = communicator->getNbProc();
 
-    using buffers_t = std::vector<DynamicCommunicationBuffer>;
     std::vector<CommunicationRequest> send_requests;
-    buffers_t send_buffers;
-
-    for (auto && data : zip(arange(nb_proc), intersections_with_left,
-                            intersections_with_right)) {
-      auto proc = std::get<0>(data);
-      if (proc == prank)
-        continue;
+    std::vector<DynamicCommunicationBuffer> send_buffers;
+
+    // sending nodes in the common zones
+    auto send_intersections = [&](auto & intersections, auto send_count) {
+      for (auto && data : intersections) {
+        auto proc = std::get<0>(data);
+
+        // Send nodes from local right side if intersects with remote left side
+        const auto & intersection_with_proc = std::get<1>(data);
+        if (intersection_with_proc) {
+          send_requests.push_back(
+              extract_and_send_nodes(intersection_with_proc, nodes_right,
+                                     send_buffers, proc, send_count));
+        }
 
-      // Send nodes from local right side if intersects with remote left side
-      const auto & intersection_with_p_left = std::get<1>(data);
-      if (intersection_with_p_left) {
-        send_requests.push_back(extract_and_send_nodes(
-            intersection_with_p_left, nodes_right, send_buffers, proc, 0));
+        send_count += 2;
       }
+    };
 
-      // Send nodes from local left side if intersects with remote right side
-      const auto & intersection_with_p_right = std::get<2>(data);
-      if (intersection_with_p_right) {
-        send_requests.push_back(extract_and_send_nodes(
-            intersection_with_p_right, nodes_left, send_buffers, proc, 1));
-      }
-    }
+    send_intersections(intersections_with_left, 0);
+    send_intersections(intersections_with_left, 1);
 
+    // XXXXXXXXX
+
+    // receiving the nodes from the common zones
+    int recv_count = 0;
     for (auto && data : zip(arange(nb_proc), intersections_with_left,
                             intersections_with_right)) {
       auto proc = std::get<0>(data);
       if (proc == prank)
         continue;
 
+      // Receive remote right nodes to merge with local right nodes
+      const auto & intersection_with_p_right = std::get<2>(data);
+      if (intersection_with_p_right) {
+        recv_and_extract_nodes(nodes_right, proc, recv_count);
+      }
       // Receive remote left nodes to merge with local left nodes
-      const auto & intersections_with_left = std::get<1>(data);
-      recv_and_extract_nodes(intersections_with_left, nodes_left, proc, 1);
+      const auto & intersection_with_p_left = std::get<1>(data);
+      if (intersection_with_p_left) {
+        recv_and_extract_nodes(nodes_left, proc, recv_count + 1);
+      }
 
-      // Receive remote right nodes to merge with local right nodes
-      const auto & intersections_with_right = std::get<2>(data);
-      recv_and_extract_nodes(intersections_with_right, nodes_right, proc, 0);
+      recv_count += 2;
     }
 
     communicator->waitAll(send_requests);
     communicator->freeCommunicationRequest(send_requests);
 
     this->sendEvent(event);
   } // end distributed work
 
   auto to_sort = [&](auto && info1, auto && info2) -> bool {
     return info1.position < info2.position;
   };
 
   // sort nodes based on their distance to lower corner
   std::sort(nodes_left.begin(), nodes_left.end(), to_sort);
   std::sort(nodes_right.begin(), nodes_right.end(), to_sort);
 
+  // function to change the master of nodes
   auto updating_master = [&](auto & old_master, auto & new_master) {
     if (old_master == new_master)
       return;
 
     auto slaves = periodic_master_slave.equal_range(old_master);
-    AKANTU_DEBUG_ASSERT(slaves.first != periodic_master_slave.end(),
-                        "Cannot update master " << old_master
-                                                << ", its not a master node!");
+    AKANTU_DEBUG_ASSERT(
+        isPeriodicMaster(
+            old_master), // slaves.first != periodic_master_slave.end(),
+        "Cannot update master " << old_master << ", its not a master node!");
     decltype(periodic_master_slave) tmp_master_slave;
     for (auto it = slaves.first; it != slaves.second; ++it) {
       auto slave = it->second;
       tmp_master_slave.insert(std::make_pair(new_master, slave));
       periodic_slave_master[slave] = new_master;
     }
 
     periodic_master_slave.erase(old_master);
     (*nodes_flags)[old_master] &= ~NodeFlag::_periodic_master;
     addPeriodicSlave(old_master, new_master);
 
     for (auto && data : tmp_master_slave) {
       addPeriodicSlave(data.second, data.first);
     }
   };
 
+  // handling 2 nodes that are periodic
   auto match_found = [&](auto & info1, auto & info2) {
     const auto & node1 = info1.node;
     const auto & node2 = info2.node;
 
     auto master = node1;
     bool node1_side_master = false;
     if (isPeriodicMaster(node1)) {
       node1_side_master = true;
     } else if (isPeriodicSlave(node1)) {
       node1_side_master = true;
       master = periodic_slave_master[node1];
     }
 
     auto node2_master = node2;
     if (isPeriodicSlave(node2)) {
       node2_master = periodic_slave_master[node2];
     }
 
     if (node1_side_master) {
       if (isPeriodicSlave(node2)) {
         updating_master(node2_master, master);
         return;
       }
 
       if (isPeriodicMaster(node2)) {
         updating_master(node2, master);
         return;
       }
 
       addPeriodicSlave(node2, master);
     } else {
       if (isPeriodicSlave(node2)) {
         addPeriodicSlave(node1, node2_master);
         return;
       }
 
       if (isPeriodicMaster(node2)) {
         addPeriodicSlave(node1, node2);
         return;
       }
 
       addPeriodicSlave(node2, node1);
     }
   };
 
+  // matching the nodes from 2 lists
   auto match_pairs = [&](auto & nodes_1, auto & nodes_2) {
     auto it = nodes_2.begin();
 
     // for every nodes in 1st list
     for (auto && info1 : nodes_1) {
       auto & pos1 = info1.position;
       auto it_cur = it;
 
       // try to find a match in 2nd list
       for (; it_cur != nodes_2.end(); ++it_cur) {
         auto & info2 = *it_cur;
         auto & pos2 = info2.position;
 
         auto dist = pos1.distance(pos2) / length;
         if (dist < tolerance) {
           // handles the found matches
           match_found(info1, info2);
           it = it_cur;
           break;
         }
       }
     }
   };
 
   match_pairs(nodes_left, nodes_right);
   // match_pairs(nodes_right, nodes_left);
 
   this->updatePeriodicSynchronizer();
 
   this->is_periodic = true;
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::wipePeriodicInfo() {
   this->is_periodic = false;
 
   this->periodic_slave_master.clear();
   this->periodic_master_slave.clear();
 
   for (auto && flags : *nodes_flags) {
     flags &= ~NodeFlag::_periodic_mask;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::updatePeriodicSynchronizer() {
   if (not this->periodic_node_synchronizer) {
     this->periodic_node_synchronizer =
         std::make_unique<PeriodicNodeSynchronizer>(
             *this, this->getID() + ":periodic_synchronizer",
             this->getMemoryID(), false);
   }
 
   this->periodic_node_synchronizer->update();
 }
 
 } // akantu
diff --git a/src/model/dof_manager.cc b/src/model/dof_manager.cc
index 7c43b65af..c034fb43f 100644
--- a/src/model/dof_manager.cc
+++ b/src/model/dof_manager.cc
@@ -1,605 +1,617 @@
 /**
  * @file   dof_manager.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Aug 18 2015
  * @date last modification: Wed Feb 21 2018
  *
  * @brief  Implementation of the common parts of the DOFManagers
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dof_manager.hh"
 #include "communicator.hh"
 #include "element_group.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 #include "node_group.hh"
 #include "non_linear_solver.hh"
 #include "sparse_matrix.hh"
 #include "time_step_solver.hh"
 /* -------------------------------------------------------------------------- */
 #include <memory>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFManager(const ID & id, const MemoryID & memory_id)
     : Memory(id, memory_id),
       communicator(Communicator::getStaticCommunicator()) {}
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFManager(Mesh & mesh, const ID & id, const MemoryID & memory_id)
     : Memory(id, memory_id), mesh(&mesh), local_system_size(0),
       pure_local_system_size(0), system_size(0),
       communicator(mesh.getCommunicator()) {
   this->mesh->registerEventHandler(*this, _ehp_dof_manager);
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManager::~DOFManager() = default;
 
 /* -------------------------------------------------------------------------- */
 // void DOFManager::getEquationsNumbers(const ID &, Array<UInt> &) {
 //   AKANTU_TO_IMPLEMENT();
 // }
 
 /* -------------------------------------------------------------------------- */
 std::vector<ID> DOFManager::getDOFIDs() const {
   std::vector<ID> keys;
   for (const auto & dof_data : this->dofs)
     keys.push_back(dof_data.first);
 
   return keys;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::assembleElementalArrayLocalArray(
     const Array<Real> & elementary_vect, Array<Real> & array_assembeled,
     const ElementType & type, const GhostType & ghost_type, Real scale_factor,
     const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   UInt nb_element;
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_degree_of_freedom =
       elementary_vect.getNbComponent() / nb_nodes_per_element;
 
   UInt * filter_it = nullptr;
   if (filter_elements != empty_filter) {
     nb_element = filter_elements.size();
     filter_it = filter_elements.storage();
   } else {
     nb_element = this->mesh->getNbElement(type, ghost_type);
   }
 
   AKANTU_DEBUG_ASSERT(elementary_vect.size() == nb_element,
                       "The vector elementary_vect("
                           << elementary_vect.getID()
                           << ") has not the good size.");
 
   const Array<UInt> & connectivity =
       this->mesh->getConnectivity(type, ghost_type);
 
   Array<Real>::const_matrix_iterator elem_it =
       elementary_vect.begin(nb_degree_of_freedom, nb_nodes_per_element);
 
   for (UInt el = 0; el < nb_element; ++el, ++elem_it) {
     UInt element = el;
     if (filter_it != nullptr) {
       // conn_it = conn_begin + *filter_it;
       element = *filter_it;
     }
 
     // const Vector<UInt> & conn = *conn_it;
     const Matrix<Real> & elemental_val = *elem_it;
     for (UInt n = 0; n < nb_nodes_per_element; ++n) {
       UInt offset_node = connectivity(element, n) * nb_degree_of_freedom;
       Vector<Real> assemble(array_assembeled.storage() + offset_node,
                             nb_degree_of_freedom);
       Vector<Real> elem_val = elemental_val(n);
       assemble.aXplusY(elem_val, scale_factor);
     }
 
     if (filter_it != nullptr)
       ++filter_it;
     //    else
     //      ++conn_it;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::assembleElementalArrayToResidual(
     const ID & dof_id, const Array<Real> & elementary_vect,
     const ElementType & type, const GhostType & ghost_type, Real scale_factor,
     const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_degree_of_freedom =
       elementary_vect.getNbComponent() / nb_nodes_per_element;
   Array<Real> array_localy_assembeled(this->mesh->getNbNodes(),
                                       nb_degree_of_freedom);
 
   array_localy_assembeled.clear();
 
   this->assembleElementalArrayLocalArray(
       elementary_vect, array_localy_assembeled, type, ghost_type, scale_factor,
       filter_elements);
 
   this->assembleToResidual(dof_id, array_localy_assembeled, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::assembleElementalArrayToLumpedMatrix(
     const ID & dof_id, const Array<Real> & elementary_vect,
     const ID & lumped_mtx, const ElementType & type,
     const GhostType & ghost_type, Real scale_factor,
     const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_degree_of_freedom =
       elementary_vect.getNbComponent() / nb_nodes_per_element;
   Array<Real> array_localy_assembeled(this->mesh->getNbNodes(),
                                       nb_degree_of_freedom);
 
   array_localy_assembeled.clear();
 
   this->assembleElementalArrayLocalArray(
       elementary_vect, array_localy_assembeled, type, ghost_type, scale_factor,
       filter_elements);
 
   this->assembleToLumpedMatrix(dof_id, array_localy_assembeled, lumped_mtx, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::assembleMatMulDOFsToResidual(const ID & A_id,
                                               Real scale_factor) {
   for (auto & pair : this->dofs) {
     const auto & dof_id = pair.first;
     auto & dof_data = *pair.second;
 
     this->assembleMatMulVectToResidual(dof_id, A_id, *dof_data.dof,
                                        scale_factor);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFData::DOFData(const ID & dof_id)
     : support_type(_dst_generic), group_support("__mesh__"), dof(nullptr),
       blocked_dofs(nullptr), increment(nullptr), previous(nullptr),
       solution(0, 1, dof_id + ":solution"),
       local_equation_number(0, 1, dof_id + ":local_equation_number") {}
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFData::~DOFData() = default;
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFData & DOFManager::getNewDOFData(const ID & dof_id) {
   auto it = this->dofs.find(dof_id);
   if (it != this->dofs.end()) {
     AKANTU_EXCEPTION("This dof array has already been registered");
   }
 
   std::unique_ptr<DOFData> dofs_storage = std::make_unique<DOFData>(dof_id);
   this->dofs[dof_id] = std::move(dofs_storage);
   return *dofs_storage;
 }
 
+/* -------------------------------------------------------------------------- */
+template <typename Func>
+auto DOFManager::countDOFsForNodes(const DOFData & dof_data, UInt nb_nodes,
+                                   Func && getNode) {
+  auto nb_local_dofs = nb_nodes;
+  decltype(nb_local_dofs) nb_pure_local = 0;
+  for (auto n : arange(nb_nodes)) {
+    UInt node = getNode(n);
+
+    // http://www.open-std.org/jtc1/sc22/open/n2356/conv.html
+    nb_pure_local += this->mesh->isLocalOrMasterNode(node);
+    nb_local_dofs -= this->mesh->isPeriodicSlave(node);
+  }
+
+  const auto & dofs_array = *dof_data.dof;
+  nb_pure_local *= dofs_array.getNbComponent();
+  nb_local_dofs *= dofs_array.getNbComponent();
+  return std::make_pair(nb_local_dofs, nb_pure_local);
+}
+
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFsInternal(const ID & dof_id,
                                       Array<Real> & dofs_array) {
   DOFData & dofs_storage = this->getDOFData(dof_id);
   dofs_storage.dof = &dofs_array;
 
   UInt nb_local_dofs = 0;
   UInt nb_pure_local = 0;
 
   const DOFSupportType & support_type = dofs_storage.support_type;
 
   switch (support_type) {
   case _dst_nodal: {
-    UInt nb_nodes = 0;
     const ID & group = dofs_storage.group_support;
 
-    NodeGroup * node_group = nullptr;
+    std::function<UInt(UInt)> getNode;
     if (group == "__mesh__") {
-      nb_nodes = this->mesh->getNbNodes();
+      AKANTU_DEBUG_ASSERT(
+          dofs_array.size() == this->mesh->getNbNodes(),
+          "The array of dof is too shot to be associated to nodes.");
+
+      std::tie(nb_local_dofs, nb_pure_local) = countDOFsForNodes(
+          dofs_storage, this->mesh->getNbNodes(), [](auto && n) { return n; });
     } else {
-      node_group = &this->mesh->getElementGroup(group).getNodeGroup();
-      nb_nodes = node_group->size();
-    }
+      const auto & node_group =
+          this->mesh->getElementGroup(group).getNodeGroup().getNodes();
 
-    nb_local_dofs = nb_nodes;
-    AKANTU_DEBUG_ASSERT(
-        dofs_array.size() == nb_local_dofs,
+      AKANTU_DEBUG_ASSERT(
+          dofs_array.size() == node_group.size(),
         "The array of dof is too shot to be associated to nodes.");
 
-    for (UInt n = 0; n < nb_nodes; ++n) {
-      UInt node = n;
-      if (node_group)
-        node = node_group->getNodes()(n);
-
-      nb_pure_local += this->mesh->isLocalOrMasterNode(node) ? 1 : 0;
-      nb_local_dofs -= this->mesh->isPeriodicSlave(node) ? 1 : 0;
+      std::tie(nb_local_dofs, nb_pure_local) =
+          countDOFsForNodes(dofs_storage, node_group.size(),
+                            [&node_group](auto && n) { return node_group(n); });
     }
 
-    nb_pure_local *= dofs_array.getNbComponent();
-    nb_local_dofs *= dofs_array.getNbComponent();
+
+
     break;
   }
   case _dst_generic: {
     nb_local_dofs = nb_pure_local =
         dofs_array.size() * dofs_array.getNbComponent();
     break;
   }
   default: { AKANTU_EXCEPTION("This type of dofs is not handled yet."); }
   }
 
   this->pure_local_system_size += nb_pure_local;
   this->local_system_size += nb_local_dofs;
 
   communicator.allReduce(nb_pure_local, SynchronizerOperation::_sum);
 
   this->system_size += nb_pure_local;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFs(const ID & dof_id, Array<Real> & dofs_array,
                               const DOFSupportType & support_type) {
   DOFData & dofs_storage = this->getNewDOFData(dof_id);
   dofs_storage.support_type = support_type;
 
   this->registerDOFsInternal(dof_id, dofs_array);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFs(const ID & dof_id, Array<Real> & dofs_array,
                               const ID & support_group) {
   DOFData & dofs_storage = this->getNewDOFData(dof_id);
   dofs_storage.support_type = _dst_nodal;
   dofs_storage.group_support = support_group;
 
   this->registerDOFsInternal(dof_id, dofs_array);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFsPrevious(const ID & dof_id, Array<Real> & array) {
   DOFData & dof = this->getDOFData(dof_id);
 
   if (dof.previous != nullptr) {
     AKANTU_EXCEPTION("The previous dofs array for "
                      << dof_id << " has already been registered");
   }
 
   dof.previous = &array;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFsIncrement(const ID & dof_id, Array<Real> & array) {
   DOFData & dof = this->getDOFData(dof_id);
 
   if (dof.increment != nullptr) {
     AKANTU_EXCEPTION("The dofs increment array for "
                      << dof_id << " has already been registered");
   }
 
   dof.increment = &array;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFsDerivative(const ID & dof_id, UInt order,
                                         Array<Real> & dofs_derivative) {
   DOFData & dof = this->getDOFData(dof_id);
   std::vector<Array<Real> *> & derivatives = dof.dof_derivatives;
 
   if (derivatives.size() < order) {
     derivatives.resize(order, nullptr);
   } else {
     if (derivatives[order - 1] != nullptr) {
       AKANTU_EXCEPTION("The dof derivatives of order "
                        << order << " already been registered for this dof ("
                        << dof_id << ")");
     }
   }
 
   derivatives[order - 1] = &dofs_derivative;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerBlockedDOFs(const ID & dof_id,
                                      Array<bool> & blocked_dofs) {
   DOFData & dof = this->getDOFData(dof_id);
 
   if (dof.blocked_dofs != nullptr) {
     AKANTU_EXCEPTION("The blocked dofs array for "
                      << dof_id << " has already been registered");
   }
 
   dof.blocked_dofs = &blocked_dofs;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::splitSolutionPerDOFs() {
   auto it = this->dofs.begin();
   auto end = this->dofs.end();
 
   for (; it != end; ++it) {
     DOFData & dof_data = *it->second;
     dof_data.solution.resize(dof_data.dof->size() *
                              dof_data.dof->getNbComponent());
     this->getSolutionPerDOFs(it->first, dof_data.solution);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix &
 DOFManager::registerSparseMatrix(const ID & matrix_id,
                                  std::unique_ptr<SparseMatrix> & matrix) {
   SparseMatricesMap::const_iterator it = this->matrices.find(matrix_id);
   if (it != this->matrices.end()) {
     AKANTU_EXCEPTION("The matrix " << matrix_id << " already exists in "
                                    << this->id);
   }
 
   SparseMatrix & ret = *matrix;
   this->matrices[matrix_id] = std::move(matrix);
   return ret;
 }
 
 /* -------------------------------------------------------------------------- */
 /// Get an instance of a new SparseMatrix
 Array<Real> & DOFManager::getNewLumpedMatrix(const ID & id) {
   ID matrix_id = this->id + ":lumped_mtx:" + id;
   LumpedMatricesMap::const_iterator it = this->lumped_matrices.find(matrix_id);
   if (it != this->lumped_matrices.end()) {
     AKANTU_EXCEPTION("The lumped matrix " << matrix_id << " already exists in "
                                           << this->id);
   }
 
   auto mtx =
       std::make_unique<Array<Real>>(this->local_system_size, 1, matrix_id);
   this->lumped_matrices[matrix_id] = std::move(mtx);
   return *this->lumped_matrices[matrix_id];
 }
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolver & DOFManager::registerNonLinearSolver(
     const ID & non_linear_solver_id,
     std::unique_ptr<NonLinearSolver> & non_linear_solver) {
   NonLinearSolversMap::const_iterator it =
       this->non_linear_solvers.find(non_linear_solver_id);
   if (it != this->non_linear_solvers.end()) {
     AKANTU_EXCEPTION("The non linear solver " << non_linear_solver_id
                                               << " already exists in "
                                               << this->id);
   }
 
   NonLinearSolver & ret = *non_linear_solver;
   this->non_linear_solvers[non_linear_solver_id] = std::move(non_linear_solver);
 
   return ret;
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolver & DOFManager::registerTimeStepSolver(
     const ID & time_step_solver_id,
     std::unique_ptr<TimeStepSolver> & time_step_solver) {
   TimeStepSolversMap::const_iterator it =
       this->time_step_solvers.find(time_step_solver_id);
   if (it != this->time_step_solvers.end()) {
     AKANTU_EXCEPTION("The non linear solver " << time_step_solver_id
                                               << " already exists in "
                                               << this->id);
   }
 
   TimeStepSolver & ret = *time_step_solver;
   this->time_step_solvers[time_step_solver_id] = std::move(time_step_solver);
   return ret;
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix & DOFManager::getMatrix(const ID & id) {
   ID matrix_id = this->id + ":mtx:" + id;
   SparseMatricesMap::const_iterator it = this->matrices.find(matrix_id);
   if (it == this->matrices.end()) {
     AKANTU_SILENT_EXCEPTION("The matrix " << matrix_id << " does not exists in "
                                           << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFManager::hasMatrix(const ID & id) const {
   ID mtx_id = this->id + ":mtx:" + id;
   auto it = this->matrices.find(mtx_id);
   return it != this->matrices.end();
 }
 
 /* -------------------------------------------------------------------------- */
 Array<Real> & DOFManager::getLumpedMatrix(const ID & id) {
   ID matrix_id = this->id + ":lumped_mtx:" + id;
   LumpedMatricesMap::const_iterator it = this->lumped_matrices.find(matrix_id);
   if (it == this->lumped_matrices.end()) {
     AKANTU_SILENT_EXCEPTION("The lumped matrix "
                             << matrix_id << " does not exists in " << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 const Array<Real> & DOFManager::getLumpedMatrix(const ID & id) const {
   ID matrix_id = this->id + ":lumped_mtx:" + id;
   auto it = this->lumped_matrices.find(matrix_id);
   if (it == this->lumped_matrices.end()) {
     AKANTU_SILENT_EXCEPTION("The lumped matrix "
                             << matrix_id << " does not exists in " << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFManager::hasLumpedMatrix(const ID & id) const {
   ID mtx_id = this->id + ":lumped_mtx:" + id;
   auto it = this->lumped_matrices.find(mtx_id);
   return it != this->lumped_matrices.end();
 }
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolver & DOFManager::getNonLinearSolver(const ID & id) {
   ID non_linear_solver_id = this->id + ":nls:" + id;
   NonLinearSolversMap::const_iterator it =
       this->non_linear_solvers.find(non_linear_solver_id);
   if (it == this->non_linear_solvers.end()) {
     AKANTU_EXCEPTION("The non linear solver " << non_linear_solver_id
                                               << " does not exists in "
                                               << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFManager::hasNonLinearSolver(const ID & id) const {
   ID solver_id = this->id + ":nls:" + id;
   auto it = this->non_linear_solvers.find(solver_id);
   return it != this->non_linear_solvers.end();
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolver & DOFManager::getTimeStepSolver(const ID & id) {
   ID time_step_solver_id = this->id + ":tss:" + id;
   TimeStepSolversMap::const_iterator it =
       this->time_step_solvers.find(time_step_solver_id);
   if (it == this->time_step_solvers.end()) {
     AKANTU_EXCEPTION("The non linear solver " << time_step_solver_id
                                               << " does not exists in "
                                               << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFManager::hasTimeStepSolver(const ID & solver_id) const {
   ID time_step_solver_id = this->id + ":tss:" + solver_id;
   auto it = this->time_step_solvers.find(time_step_solver_id);
   return it != this->time_step_solvers.end();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::savePreviousDOFs(const ID & dofs_id) {
   this->getPreviousDOFs(dofs_id).copy(this->getDOFs(dofs_id));
 }
 
 /* -------------------------------------------------------------------------- */
 /* Mesh Events                                                                */
 /* -------------------------------------------------------------------------- */
 std::pair<UInt, UInt>
 DOFManager::updateNodalDOFs(const ID & dof_id, const Array<UInt> & nodes_list) {
   auto & dof_data = this->getDOFData(dof_id);
-  UInt nb_new_local_dofs = 0;
-  UInt nb_new_pure_local = 0;
-
-  nb_new_local_dofs = nodes_list.size();
-  for (const auto & node : nodes_list) {
-    nb_new_pure_local += this->mesh->isLocalOrMasterNode(node) ? 1 : 0;
-  }
+  UInt nb_new_local_dofs, nb_new_pure_local;
 
-  const auto & dof_array = *dof_data.dof;
-  nb_new_pure_local *= dof_array.getNbComponent();
-  nb_new_local_dofs *= dof_array.getNbComponent();
+  std::tie(nb_new_local_dofs, nb_new_pure_local) =
+      countDOFsForNodes(dof_data, nodes_list.size(),
+                        [&nodes_list](auto && n) { return nodes_list(n); });
 
   this->pure_local_system_size += nb_new_pure_local;
   this->local_system_size += nb_new_local_dofs;
 
   UInt nb_new_global = nb_new_pure_local;
   communicator.allReduce(nb_new_global, SynchronizerOperation::_sum);
 
   this->system_size += nb_new_global;
 
   dof_data.solution.resize(dof_data.solution.size() + nb_new_local_dofs);
 
   return std::make_pair(nb_new_local_dofs, nb_new_pure_local);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::onNodesAdded(const Array<UInt> & nodes_list,
                               const NewNodesEvent &) {
   for (auto & pair : this->dofs) {
     const auto & dof_id = pair.first;
     auto & dof_data = this->getDOFData(dof_id);
     if (dof_data.support_type != _dst_nodal)
       continue;
 
     const auto & group = dof_data.group_support;
 
     if (group == "__mesh__") {
       this->updateNodalDOFs(dof_id, nodes_list);
     } else {
       const auto & node_group =
           this->mesh->getElementGroup(group).getNodeGroup();
       Array<UInt> new_nodes_list;
       for (const auto & node : nodes_list) {
         if (node_group.find(node) != UInt(-1))
           new_nodes_list.push_back(node);
       }
 
       this->updateNodalDOFs(dof_id, new_nodes_list);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::onNodesRemoved(const Array<UInt> &, const Array<UInt> &,
                                 const RemovedNodesEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::onElementsAdded(const Array<Element> &,
                                  const NewElementsEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::onElementsRemoved(const Array<Element> &,
                                    const ElementTypeMapArray<UInt> &,
                                    const RemovedElementsEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::onElementsChanged(const Array<Element> &,
                                    const Array<Element> &,
                                    const ElementTypeMapArray<UInt> &,
                                    const ChangedElementsEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/model/dof_manager.hh b/src/model/dof_manager.hh
index fdba64f14..3ff30b99b 100644
--- a/src/model/dof_manager.hh
+++ b/src/model/dof_manager.hh
@@ -1,479 +1,485 @@
 /**
  * @file   dof_manager.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Aug 18 2015
  * @date last modification: Wed Feb 21 2018
  *
  * @brief  Class handling the different types of dofs
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_factory.hh"
 #include "aka_memory.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 #include <map>
 #include <set>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_DOF_MANAGER_HH__
 #define __AKANTU_DOF_MANAGER_HH__
 
 namespace akantu {
 class TermsToAssemble;
 class NonLinearSolver;
 class TimeStepSolver;
 class SparseMatrix;
 } // namespace akantu
 
 namespace akantu {
 
 class DOFManager : protected Memory, protected MeshEventHandler {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
+protected:
+  struct DOFData;
+
 public:
   DOFManager(const ID & id = "dof_manager", const MemoryID & memory_id = 0);
   DOFManager(Mesh & mesh, const ID & id = "dof_manager",
              const MemoryID & memory_id = 0);
   ~DOFManager() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 private:
   /// common function to help registering dofs
   void registerDOFsInternal(const ID & dof_id, Array<Real> & dofs_array);
 
 public:
   /// register an array of degree of freedom
   virtual void registerDOFs(const ID & dof_id, Array<Real> & dofs_array,
                             const DOFSupportType & support_type);
 
   /// the dof as an implied type of _dst_nodal and is defined only on a subset
   /// of nodes
   virtual void registerDOFs(const ID & dof_id, Array<Real> & dofs_array,
                             const ID & group_support);
 
   /// register an array of previous values of the degree of freedom
   virtual void registerDOFsPrevious(const ID & dof_id,
                                     Array<Real> & dofs_array);
 
   /// register an array of increment of degree of freedom
   virtual void registerDOFsIncrement(const ID & dof_id,
                                      Array<Real> & dofs_array);
 
   /// register an array of derivatives for a particular dof array
   virtual void registerDOFsDerivative(const ID & dof_id, UInt order,
                                       Array<Real> & dofs_derivative);
 
   /// register array representing the blocked degree of freedoms
   virtual void registerBlockedDOFs(const ID & dof_id,
                                    Array<bool> & blocked_dofs);
 
   /// Assemble an array to the global residual array
   virtual void assembleToResidual(const ID & dof_id,
                                   Array<Real> & array_to_assemble,
                                   Real scale_factor = 1.) = 0;
 
   /// Assemble an array to the global lumped matrix array
   virtual void assembleToLumpedMatrix(const ID & dof_id,
                                       Array<Real> & array_to_assemble,
                                       const ID & lumped_mtx,
                                       Real scale_factor = 1.) = 0;
 
   /**
    * Assemble elementary values to a local array of the size nb_nodes *
    * nb_dof_per_node. The dof number is implicitly considered as
    * conn(el, n) * nb_nodes_per_element + d.
    * With 0 < n < nb_nodes_per_element and 0 < d < nb_dof_per_node
    **/
   virtual void assembleElementalArrayLocalArray(
       const Array<Real> & elementary_vect, Array<Real> & array_assembeled,
       const ElementType & type, const GhostType & ghost_type,
       Real scale_factor = 1.,
       const Array<UInt> & filter_elements = empty_filter);
 
   /**
    * Assemble elementary values to the global residual array. The dof number is
    * implicitly considered as conn(el, n) * nb_nodes_per_element + d.
    * With 0 < n < nb_nodes_per_element and 0 < d < nb_dof_per_node
    **/
   virtual void assembleElementalArrayToResidual(
       const ID & dof_id, const Array<Real> & elementary_vect,
       const ElementType & type, const GhostType & ghost_type,
       Real scale_factor = 1.,
       const Array<UInt> & filter_elements = empty_filter);
 
   /**
    * Assemble elementary values to a global array corresponding to a lumped
    * matrix
    */
   virtual void assembleElementalArrayToLumpedMatrix(
       const ID & dof_id, const Array<Real> & elementary_vect,
       const ID & lumped_mtx, const ElementType & type,
       const GhostType & ghost_type, Real scale_factor = 1.,
       const Array<UInt> & filter_elements = empty_filter);
 
   /**
    * Assemble elementary values to the global residual array. The dof number is
    * implicitly considered as conn(el, n) * nb_nodes_per_element + d.  With 0 <
    * n < nb_nodes_per_element and 0 < d < nb_dof_per_node
    **/
   virtual void assembleElementalMatricesToMatrix(
       const ID & matrix_id, const ID & dof_id,
       const Array<Real> & elementary_mat, const ElementType & type,
       const GhostType & ghost_type = _not_ghost,
       const MatrixType & elemental_matrix_type = _symmetric,
       const Array<UInt> & filter_elements = empty_filter) = 0;
 
   /// multiply a vector by a matrix and assemble the result to the residual
   virtual void assembleMatMulVectToResidual(const ID & dof_id, const ID & A_id,
                                             const Array<Real> & x,
                                             Real scale_factor = 1) = 0;
 
   /// multiply the dofs by a matrix and assemble the result to the residual
   virtual void assembleMatMulDOFsToResidual(const ID & A_id,
                                             Real scale_factor = 1);
 
   /// multiply a vector by a lumped matrix and assemble the result to the
   /// residual
   virtual void assembleLumpedMatMulVectToResidual(const ID & dof_id,
                                                   const ID & A_id,
                                                   const Array<Real> & x,
                                                   Real scale_factor = 1) = 0;
 
   /// assemble coupling terms between to dofs
   virtual void assemblePreassembledMatrix(const ID & dof_id_m,
                                           const ID & dof_id_n,
                                           const ID & matrix_id,
                                           const TermsToAssemble & terms) = 0;
 
   /// sets the residual to 0
   virtual void clearResidual() = 0;
   /// sets the matrix to 0
   virtual void clearMatrix(const ID & mtx) = 0;
   /// sets the lumped matrix to 0
   virtual void clearLumpedMatrix(const ID & mtx) = 0;
 
   /// splits the solution storage from a global view to the per dof storages
   void splitSolutionPerDOFs();
 
   /// extract a lumped matrix part corresponding to a given dof
   virtual void getLumpedMatrixPerDOFs(const ID & dof_id, const ID & lumped_mtx,
                                       Array<Real> & lumped) = 0;
 
 protected:
   /// minimum functionality to implement per derived version of the DOFManager
   /// to allow the splitSolutionPerDOFs function to work
   virtual void getSolutionPerDOFs(const ID & dof_id,
                                   Array<Real> & solution_array) = 0;
 
 protected:
   /* ------------------------------------------------------------------------ */
   /// register a matrix
   SparseMatrix & registerSparseMatrix(const ID & matrix_id,
                                       std::unique_ptr<SparseMatrix> & matrix);
 
   /// register a non linear solver instantiated by a derived class
   NonLinearSolver &
   registerNonLinearSolver(const ID & non_linear_solver_id,
                           std::unique_ptr<NonLinearSolver> & non_linear_solver);
 
   /// register a time step solver instantiated by a derived class
   TimeStepSolver &
   registerTimeStepSolver(const ID & time_step_solver_id,
                          std::unique_ptr<TimeStepSolver> & time_step_solver);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// Get the equation numbers corresponding to a dof_id. This might be used to
   /// access the matrix.
   inline const Array<UInt> & getEquationsNumbers(const ID & dof_id) const;
 
   /// Global number of dofs
   AKANTU_GET_MACRO(SystemSize, this->system_size, UInt);
 
   /// Local number of dofs
   AKANTU_GET_MACRO(LocalSystemSize, this->local_system_size, UInt);
 
   /// Retrieve all the registered DOFs
   std::vector<ID> getDOFIDs() const;
 
   /* ------------------------------------------------------------------------ */
   /* DOFs and derivatives accessors                                          */
   /* ------------------------------------------------------------------------ */
   /// Get a reference to the registered dof array for a given id
   inline Array<Real> & getDOFs(const ID & dofs_id);
 
   /// Get the support type of a given dof
   inline DOFSupportType getSupportType(const ID & dofs_id) const;
 
   /// are the dofs registered
   inline bool hasDOFs(const ID & dofs_id) const;
 
   /// Get a reference to the registered dof derivatives array for a given id
   inline Array<Real> & getDOFsDerivatives(const ID & dofs_id, UInt order);
 
   /// Does the dof has derivatives
   inline bool hasDOFsDerivatives(const ID & dofs_id, UInt order) const;
 
   /// Get a reference to the blocked dofs array registered for the given id
   inline const Array<bool> & getBlockedDOFs(const ID & dofs_id) const;
 
   /// Does the dof has a blocked array
   inline bool hasBlockedDOFs(const ID & dofs_id) const;
 
   /// Get a reference to the registered dof increment array for a given id
   inline Array<Real> & getDOFsIncrement(const ID & dofs_id);
 
   /// Does the dof has a increment array
   inline bool hasDOFsIncrement(const ID & dofs_id) const;
 
   /// Does the dof has a previous array
   inline Array<Real> & getPreviousDOFs(const ID & dofs_id);
 
   /// Get a reference to the registered dof array for previous step values a
   /// given id
   inline bool hasPreviousDOFs(const ID & dofs_id) const;
 
   /// saves the values from dofs to previous dofs
   virtual void savePreviousDOFs(const ID & dofs_id);
 
   /// Get a reference to the solution array registered for the given id
   inline const Array<Real> & getSolution(const ID & dofs_id) const;
 
   /// Get a reference to the solution array registered for the given id
   inline Array<Real> & getSolution(const ID & dofs_id);
 
   /* ------------------------------------------------------------------------ */
   /* Matrices accessors                                                       */
   /* ------------------------------------------------------------------------ */
   /// Get an instance of a new SparseMatrix
   virtual SparseMatrix & getNewMatrix(const ID & matrix_id,
                                       const MatrixType & matrix_type) = 0;
 
   /// Get an instance of a new SparseMatrix as a copy of the SparseMatrix
   /// matrix_to_copy_id
   virtual SparseMatrix & getNewMatrix(const ID & matrix_id,
                                       const ID & matrix_to_copy_id) = 0;
 
   /// Get the reference of an existing matrix
   SparseMatrix & getMatrix(const ID & matrix_id);
 
   /// check if the given matrix exists
   bool hasMatrix(const ID & matrix_id) const;
 
   /// Get an instance of a new lumped matrix
   virtual Array<Real> & getNewLumpedMatrix(const ID & matrix_id);
   /// Get the lumped version of a given matrix
   const Array<Real> & getLumpedMatrix(const ID & matrix_id) const;
   /// Get the lumped version of a given matrix
   Array<Real> & getLumpedMatrix(const ID & matrix_id);
 
   /// check if the given matrix exists
   bool hasLumpedMatrix(const ID & matrix_id) const;
 
   /* ------------------------------------------------------------------------ */
   /* Non linear system solver                                                 */
   /* ------------------------------------------------------------------------ */
   /// Get instance of a non linear solver
   virtual NonLinearSolver & getNewNonLinearSolver(
       const ID & nls_solver_id,
       const NonLinearSolverType & _non_linear_solver_type) = 0;
 
   /// get instance of a non linear solver
   virtual NonLinearSolver & getNonLinearSolver(const ID & nls_solver_id);
 
   /// check if the given solver exists
   bool hasNonLinearSolver(const ID & solver_id) const;
 
   /* ------------------------------------------------------------------------ */
   /* Time-Step Solver                                                         */
   /* ------------------------------------------------------------------------ */
   /// Get instance of a time step solver
   virtual TimeStepSolver &
   getNewTimeStepSolver(const ID & time_step_solver_id,
                        const TimeStepSolverType & type,
                        NonLinearSolver & non_linear_solver) = 0;
 
   /// get instance of a time step solver
   virtual TimeStepSolver & getTimeStepSolver(const ID & time_step_solver_id);
 
   /// check if the given solver exists
   bool hasTimeStepSolver(const ID & solver_id) const;
 
   /* ------------------------------------------------------------------------ */
   const Mesh & getMesh() {
     if (mesh) {
       return *mesh;
     } else {
       AKANTU_EXCEPTION("No mesh registered in this dof manager");
     }
   }
 
   /* ------------------------------------------------------------------------ */
   AKANTU_GET_MACRO(Communicator, communicator, const auto &);
   AKANTU_GET_MACRO_NOT_CONST(Communicator, communicator, auto &);
 
   /* ------------------------------------------------------------------------ */
   /* MeshEventHandler interface                                               */
   /* ------------------------------------------------------------------------ */
 protected:
   /// helper function for the DOFManager::onNodesAdded method
   virtual std::pair<UInt, UInt> updateNodalDOFs(const ID & dof_id,
                                                 const Array<UInt> & nodes_list);
 
+  template <typename Func>
+  auto countDOFsForNodes(const DOFData & dof_data, UInt nb_nodes,
+                        Func && getNode);
+
 public:
   /// function to implement to react on  akantu::NewNodesEvent
   void onNodesAdded(const Array<UInt> & nodes_list,
                     const NewNodesEvent & event) override;
   /// function to implement to react on  akantu::RemovedNodesEvent
   void onNodesRemoved(const Array<UInt> & nodes_list,
                       const Array<UInt> & new_numbering,
                       const RemovedNodesEvent & event) override;
   /// function to implement to react on  akantu::NewElementsEvent
   void onElementsAdded(const Array<Element> & elements_list,
                        const NewElementsEvent & event) override;
   /// function to implement to react on  akantu::RemovedElementsEvent
   void onElementsRemoved(const Array<Element> & elements_list,
                          const ElementTypeMapArray<UInt> & new_numbering,
                          const RemovedElementsEvent & event) override;
   /// function to implement to react on  akantu::ChangedElementsEvent
   void onElementsChanged(const Array<Element> & old_elements_list,
                          const Array<Element> & new_elements_list,
                          const ElementTypeMapArray<UInt> & new_numbering,
                          const ChangedElementsEvent & event) override;
 
 protected:
-  struct DOFData;
   inline DOFData & getDOFData(const ID & dof_id);
   inline const DOFData & getDOFData(const ID & dof_id) const;
   template <class _DOFData>
   inline _DOFData & getDOFDataTyped(const ID & dof_id);
   template <class _DOFData>
   inline const _DOFData & getDOFDataTyped(const ID & dof_id) const;
 
   virtual DOFData & getNewDOFData(const ID & dof_id);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// dof representations in the dof manager
   struct DOFData {
     DOFData() = delete;
     explicit DOFData(const ID & dof_id);
     virtual ~DOFData();
 
     /// DOF support type (nodal, general) this is needed to determine how the
     /// dof are shared among processors
     DOFSupportType support_type;
 
     ID group_support;
 
     /// Degree of freedom array
     Array<Real> * dof;
 
     /// Blocked degree of freedoms array
     Array<bool> * blocked_dofs;
 
     /// Degree of freedoms increment
     Array<Real> * increment;
 
     /// Degree of freedoms at previous step
     Array<Real> * previous;
 
     /// Solution associated to the dof
     Array<Real> solution;
 
     /// local numbering equation numbers
     Array<UInt> local_equation_number;
 
     /* ---------------------------------------------------------------------- */
     /* data for dynamic simulations                                           */
     /* ---------------------------------------------------------------------- */
     /// Degree of freedom derivatives arrays
     std::vector<Array<Real> *> dof_derivatives;
   };
 
   /// type to store dofs information
   using DOFStorage = std::map<ID, std::unique_ptr<DOFData>>;
 
   /// type to store all the matrices
   using SparseMatricesMap = std::map<ID, std::unique_ptr<SparseMatrix>>;
 
   /// type to store all the lumped matrices
   using LumpedMatricesMap = std::map<ID, std::unique_ptr<Array<Real>>>;
 
   /// type to store all the non linear solver
   using NonLinearSolversMap = std::map<ID, std::unique_ptr<NonLinearSolver>>;
 
   /// type to store all the time step solver
   using TimeStepSolversMap = std::map<ID, std::unique_ptr<TimeStepSolver>>;
 
   /// store a reference to the dof arrays
   DOFStorage dofs;
 
   /// list of sparse matrices that where created
   SparseMatricesMap matrices;
 
   /// list of lumped matrices
   LumpedMatricesMap lumped_matrices;
 
   /// non linear solvers storage
   NonLinearSolversMap non_linear_solvers;
 
   /// time step solvers storage
   TimeStepSolversMap time_step_solvers;
 
   /// reference to the underlying mesh
   Mesh * mesh{nullptr};
 
   /// Total number of degrees of freedom (size with the ghosts)
   UInt local_system_size{0};
 
   /// Number of purely local dofs (size without the ghosts)
   UInt pure_local_system_size{0};
 
   /// Total number of degrees of freedom
   UInt system_size{0};
 
   /// Communicator used for this manager, should be the same as in the mesh if a
   /// mesh is registered
   Communicator & communicator;
 };
 
 using DefaultDOFManagerFactory =
     Factory<DOFManager, ID, const ID &, const MemoryID &>;
 using DOFManagerFactory =
     Factory<DOFManager, ID, Mesh &, const ID &, const MemoryID &>;
 
 } // namespace akantu
 
 #include "dof_manager_inline_impl.cc"
 
 #endif /* __AKANTU_DOF_MANAGER_HH__ */
diff --git a/src/model/dof_manager_default.cc b/src/model/dof_manager_default.cc
index e1b7ad401..2ad4ab000 100644
--- a/src/model/dof_manager_default.cc
+++ b/src/model/dof_manager_default.cc
@@ -1,980 +1,995 @@
 /**
  * @file   dof_manager_default.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Aug 18 2015
  * @date last modification: Thu Feb 08 2018
  *
  * @brief  Implementation of the default DOFManager
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dof_manager_default.hh"
 #include "communicator.hh"
 #include "dof_synchronizer.hh"
 #include "element_group.hh"
 #include "node_synchronizer.hh"
 #include "non_linear_solver_default.hh"
 #include "periodic_node_synchronizer.hh"
 #include "sparse_matrix_aij.hh"
 #include "terms_to_assemble.hh"
 #include "time_step_solver_default.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <memory>
 #include <numeric>
 #include <unordered_map>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline void DOFManagerDefault::addSymmetricElementalMatrixToSymmetric(
     SparseMatrixAIJ & matrix, const Matrix<Real> & elementary_mat,
     const Vector<UInt> & equation_numbers, UInt max_size) {
   for (UInt i = 0; i < elementary_mat.rows(); ++i) {
     UInt c_irn = equation_numbers(i);
     if (c_irn < max_size) {
       for (UInt j = i; j < elementary_mat.cols(); ++j) {
         UInt c_jcn = equation_numbers(j);
         if (c_jcn < max_size) {
           matrix(c_irn, c_jcn) += elementary_mat(i, j);
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void DOFManagerDefault::addUnsymmetricElementalMatrixToSymmetric(
     SparseMatrixAIJ & matrix, const Matrix<Real> & elementary_mat,
     const Vector<UInt> & equation_numbers, UInt max_size) {
   for (UInt i = 0; i < elementary_mat.rows(); ++i) {
     UInt c_irn = equation_numbers(i);
     if (c_irn < max_size) {
       for (UInt j = 0; j < elementary_mat.cols(); ++j) {
         UInt c_jcn = equation_numbers(j);
         if (c_jcn < max_size) {
           if (c_jcn >= c_irn) {
             matrix(c_irn, c_jcn) += elementary_mat(i, j);
           }
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void DOFManagerDefault::addElementalMatrixToUnsymmetric(
     SparseMatrixAIJ & matrix, const Matrix<Real> & elementary_mat,
     const Vector<UInt> & equation_numbers, UInt max_size) {
   for (UInt i = 0; i < elementary_mat.rows(); ++i) {
     UInt c_irn = equation_numbers(i);
     if (c_irn < max_size) {
       for (UInt j = 0; j < elementary_mat.cols(); ++j) {
         UInt c_jcn = equation_numbers(j);
         if (c_jcn < max_size) {
           matrix(c_irn, c_jcn) += elementary_mat(i, j);
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManagerDefault::DOFManagerDefault(const ID & id, const MemoryID & memory_id)
     : DOFManager(id, memory_id), residual(0, 1, std::string(id + ":residual")),
       global_residual(nullptr),
       global_solution(0, 1, std::string(id + ":global_solution")),
       global_blocked_dofs(0, 1, std::string(id + ":global_blocked_dofs")),
       previous_global_blocked_dofs(
           0, 1, std::string(id + ":previous_global_blocked_dofs")),
       dofs_flag(0, 1, std::string(id + ":dofs_type")),
       data_cache(0, 1, std::string(id + ":data_cache_array")),
       global_equation_number(0, 1, "global_equation_number"),
       synchronizer(nullptr) {}
 
 /* -------------------------------------------------------------------------- */
 DOFManagerDefault::DOFManagerDefault(Mesh & mesh, const ID & id,
                                      const MemoryID & memory_id)
     : DOFManager(mesh, id, memory_id),
       residual(0, 1, std::string(id + ":residual")), global_residual(nullptr),
       global_solution(0, 1, std::string(id + ":global_solution")),
       global_blocked_dofs(0, 1, std::string(id + ":global_blocked_dofs")),
       previous_global_blocked_dofs(
           0, 1, std::string(id + ":previous_global_blocked_dofs")),
       dofs_flag(0, 1, std::string(id + ":dofs_type")),
       data_cache(0, 1, std::string(id + ":data_cache_array")),
       global_equation_number(0, 1, "global_equation_number"),
       first_global_dof_id(0), synchronizer(nullptr) {
   if (this->mesh->isDistributed())
     this->synchronizer = std::make_unique<DOFSynchronizer>(
         *this, this->id + ":dof_synchronizer", this->memory_id);
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManagerDefault::~DOFManagerDefault() = default;
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void DOFManagerDefault::makeConsistentForPeriodicity(const ID & dof_id,
                                                      Array<T> & array) {
   auto & dof_data = this->getDOFDataTyped<DOFDataDefault>(dof_id);
   if (dof_data.support_type != _dst_nodal)
     return;
 
   if (not mesh->isPeriodic())
     return;
 
   this->mesh->getPeriodicNodeSynchronizer()
       .reduceSynchronizeWithPBCSlaves<AddOperation>(array);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void DOFManagerDefault::assembleToGlobalArray(
     const ID & dof_id, const Array<T> & array_to_assemble,
     Array<T> & global_array, T scale_factor) {
   AKANTU_DEBUG_IN();
 
   auto & dof_data = this->getDOFDataTyped<DOFDataDefault>(dof_id);
   AKANTU_DEBUG_ASSERT(dof_data.local_equation_number.size() ==
                           array_to_assemble.size() *
                               array_to_assemble.getNbComponent(),
                       "The array to assemble does not have a correct size."
                           << " (" << array_to_assemble.getID() << ")");
 
   if (dof_data.support_type == _dst_nodal and mesh->isPeriodic()) {
     for (auto && data :
          zip(dof_data.local_equation_number, dof_data.associated_nodes,
              make_view(array_to_assemble))) {
       auto && equ_num = std::get<0>(data);
       auto && node = std::get<1>(data);
       auto && arr = std::get<2>(data);
-      if (not this->mesh->isPeriodicSlave(node)) {
-        global_array(equ_num) += scale_factor * (arr);
-      }
+      global_array(equ_num) +=
+          scale_factor * (arr) * (not this->mesh->isPeriodicSlave(node));
     }
   } else {
     for (auto && data :
          zip(dof_data.local_equation_number, make_view(array_to_assemble))) {
       auto && equ_num = std::get<0>(data);
       auto && arr = std::get<1>(data);
       global_array(equ_num) += scale_factor * (arr);
     }
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManagerDefault::DOFDataDefault::DOFDataDefault(const ID & dof_id)
     : DOFData(dof_id), associated_nodes(0, 1, dof_id + "associated_nodes") {}
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFData & DOFManagerDefault::getNewDOFData(const ID & dof_id) {
   this->dofs[dof_id] = std::make_unique<DOFDataDefault>(dof_id);
   return *this->dofs[dof_id];
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::registerDOFsInternal(const ID & dof_id, UInt nb_dofs,
                                              UInt nb_pure_local_dofs) {
   // auto prank = this->communicator.whoAmI();
   // auto psize = this->communicator.getNbProc();
 
   // access the relevant data to update
   auto & dof_data = this->getDOFDataTyped<DOFDataDefault>(dof_id);
   const auto & support_type = dof_data.support_type;
 
   const auto & group = dof_data.group_support;
 
-  switch(support_type) {
-  case  _dst_nodal:
+  switch (support_type) {
+  case _dst_nodal:
     if (group != "__mesh__") {
       auto & support_nodes =
           this->mesh->getElementGroup(group).getNodeGroup().getNodes();
       this->updateDOFsData(
           dof_data, nb_dofs, nb_pure_local_dofs, support_nodes.size(),
           [&support_nodes](UInt node) -> UInt { return support_nodes[node]; });
     } else {
-      this->updateDOFsData(dof_data, nb_dofs, nb_pure_local_dofs, mesh->getNbNodes(),
+      this->updateDOFsData(dof_data, nb_dofs, nb_pure_local_dofs,
+                           mesh->getNbNodes(),
                            [](UInt node) -> UInt { return node; });
     }
     break;
   case _dst_generic:
     this->updateDOFsData(dof_data, nb_dofs, nb_pure_local_dofs);
     break;
   }
 
   // update the synchronizer if needed
   if (this->synchronizer)
     this->synchronizer->registerDOFs(dof_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::registerDOFs(const ID & dof_id,
                                      Array<Real> & dofs_array,
                                      const DOFSupportType & support_type) {
   // stores the current numbers of dofs
   UInt nb_dofs_old = this->local_system_size;
   UInt nb_pure_local_dofs_old = this->pure_local_system_size;
 
   // update or create the dof_data
   DOFManager::registerDOFs(dof_id, dofs_array, support_type);
 
   UInt nb_dofs = this->local_system_size - nb_dofs_old;
   UInt nb_pure_local_dofs =
       this->pure_local_system_size - nb_pure_local_dofs_old;
 
   this->registerDOFsInternal(dof_id, nb_dofs, nb_pure_local_dofs);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::registerDOFs(const ID & dof_id,
                                      Array<Real> & dofs_array,
                                      const ID & group_support) {
   // stores the current numbers of dofs
   UInt nb_dofs_old = this->local_system_size;
   UInt nb_pure_local_dofs_old = this->pure_local_system_size;
 
   // update or create the dof_data
   DOFManager::registerDOFs(dof_id, dofs_array, group_support);
 
   UInt nb_dofs = this->local_system_size - nb_dofs_old;
   UInt nb_pure_local_dofs =
       this->pure_local_system_size - nb_pure_local_dofs_old;
 
   this->registerDOFsInternal(dof_id, nb_dofs, nb_pure_local_dofs);
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix & DOFManagerDefault::getNewMatrix(const ID & id,
                                                const MatrixType & matrix_type) {
   ID matrix_id = this->id + ":mtx:" + id;
   std::unique_ptr<SparseMatrix> sm =
       std::make_unique<SparseMatrixAIJ>(*this, matrix_type, matrix_id);
   return this->registerSparseMatrix(matrix_id, sm);
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix & DOFManagerDefault::getNewMatrix(const ID & id,
                                                const ID & matrix_to_copy_id) {
 
   ID matrix_id = this->id + ":mtx:" + id;
   SparseMatrixAIJ & sm_to_copy = this->getMatrix(matrix_to_copy_id);
   std::unique_ptr<SparseMatrix> sm =
       std::make_unique<SparseMatrixAIJ>(sm_to_copy, matrix_id);
   return this->registerSparseMatrix(matrix_id, sm);
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrixAIJ & DOFManagerDefault::getMatrix(const ID & id) {
   SparseMatrix & matrix = DOFManager::getMatrix(id);
 
   return dynamic_cast<SparseMatrixAIJ &>(matrix);
 }
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolver &
 DOFManagerDefault::getNewNonLinearSolver(const ID & id,
                                          const NonLinearSolverType & type) {
   ID non_linear_solver_id = this->id + ":nls:" + id;
   std::unique_ptr<NonLinearSolver> nls;
   switch (type) {
 #if defined(AKANTU_IMPLICIT)
   case _nls_newton_raphson:
   case _nls_newton_raphson_modified: {
     nls = std::make_unique<NonLinearSolverNewtonRaphson>(
         *this, type, non_linear_solver_id, this->memory_id);
     break;
   }
   case _nls_linear: {
     nls = std::make_unique<NonLinearSolverLinear>(
         *this, type, non_linear_solver_id, this->memory_id);
     break;
   }
 #endif
   case _nls_lumped: {
     nls = std::make_unique<NonLinearSolverLumped>(
         *this, type, non_linear_solver_id, this->memory_id);
     break;
   }
   default:
     AKANTU_EXCEPTION("The asked type of non linear solver is not supported by "
                      "this dof manager");
   }
 
   return this->registerNonLinearSolver(non_linear_solver_id, nls);
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolver &
 DOFManagerDefault::getNewTimeStepSolver(const ID & id,
                                         const TimeStepSolverType & type,
                                         NonLinearSolver & non_linear_solver) {
   ID time_step_solver_id = this->id + ":tss:" + id;
 
   std::unique_ptr<TimeStepSolver> tss = std::make_unique<TimeStepSolverDefault>(
       *this, type, non_linear_solver, time_step_solver_id, this->memory_id);
 
   return this->registerTimeStepSolver(time_step_solver_id, tss);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::clearResidual() {
   this->residual.resize(this->local_system_size);
   this->residual.clear();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::clearMatrix(const ID & mtx) {
   this->getMatrix(mtx).clear();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::clearLumpedMatrix(const ID & mtx) {
   this->getLumpedMatrix(mtx).clear();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::updateGlobalBlockedDofs() {
   auto it = this->dofs.begin();
   auto end = this->dofs.end();
 
   this->previous_global_blocked_dofs.copy(this->global_blocked_dofs);
   this->global_blocked_dofs.resize(this->local_system_size);
   this->global_blocked_dofs.clear();
 
   for (; it != end; ++it) {
     if (!this->hasBlockedDOFs(it->first))
       continue;
 
     DOFData & dof_data = *it->second;
     this->assembleToGlobalArray(it->first, *dof_data.blocked_dofs,
                                 this->global_blocked_dofs, true);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void DOFManagerDefault::getArrayPerDOFs(const ID & dof_id,
                                         const Array<T> & global_array,
                                         Array<T> & local_array) const {
   AKANTU_DEBUG_IN();
 
   const Array<UInt> & equation_number = this->getLocalEquationNumbers(dof_id);
 
   UInt nb_degree_of_freedoms = equation_number.size();
   local_array.resize(nb_degree_of_freedoms / local_array.getNbComponent());
 
   auto loc_it = local_array.begin_reinterpret(nb_degree_of_freedoms);
   auto equ_it = equation_number.begin();
 
   for (UInt d = 0; d < nb_degree_of_freedoms; ++d, ++loc_it, ++equ_it) {
     (*loc_it) = global_array(*equ_it);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::getSolutionPerDOFs(const ID & dof_id,
                                            Array<Real> & solution_array) {
   AKANTU_DEBUG_IN();
   this->getArrayPerDOFs(dof_id, this->global_solution, solution_array);
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::getLumpedMatrixPerDOFs(const ID & dof_id,
                                                const ID & lumped_mtx,
                                                Array<Real> & lumped) {
   AKANTU_DEBUG_IN();
   this->getArrayPerDOFs(dof_id, this->getLumpedMatrix(lumped_mtx), lumped);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleToResidual(const ID & dof_id,
                                            Array<Real> & array_to_assemble,
                                            Real scale_factor) {
   AKANTU_DEBUG_IN();
 
   this->makeConsistentForPeriodicity(dof_id, array_to_assemble);
 
   this->assembleToGlobalArray(dof_id, array_to_assemble, this->residual,
                               scale_factor);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleToLumpedMatrix(const ID & dof_id,
                                                Array<Real> & array_to_assemble,
                                                const ID & lumped_mtx,
                                                Real scale_factor) {
   AKANTU_DEBUG_IN();
 
   this->makeConsistentForPeriodicity(dof_id, array_to_assemble);
 
   Array<Real> & lumped = this->getLumpedMatrix(lumped_mtx);
   this->assembleToGlobalArray(dof_id, array_to_assemble, lumped, scale_factor);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleMatMulVectToResidual(const ID & dof_id,
                                                      const ID & A_id,
                                                      const Array<Real> & x,
                                                      Real scale_factor) {
   SparseMatrixAIJ & A = this->getMatrix(A_id);
 
   // Array<Real> data_cache(this->local_system_size, 1, 0.);
   this->data_cache.resize(this->local_system_size);
   this->data_cache.clear();
 
   this->assembleToGlobalArray(dof_id, x, data_cache, 1.);
 
   Array<Real> tmp_residual(this->residual.size(), 1, 0.);
 
   A.matVecMul(data_cache, tmp_residual, scale_factor, 1.);
   this->residual += tmp_residual;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleLumpedMatMulVectToResidual(
     const ID & dof_id, const ID & A_id, const Array<Real> & x,
     Real scale_factor) {
   const Array<Real> & A = this->getLumpedMatrix(A_id);
 
   //  Array<Real> data_cache(this->local_system_size, 1, 0.);
   this->data_cache.resize(this->local_system_size);
   this->data_cache.clear();
 
   this->assembleToGlobalArray(dof_id, x, data_cache, scale_factor);
 
   auto A_it = A.begin();
   auto A_end = A.end();
   auto x_it = data_cache.begin();
   auto r_it = this->residual.begin();
 
   for (; A_it != A_end; ++A_it, ++x_it, ++r_it) {
     *r_it += *A_it * *x_it;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleElementalMatricesToMatrix(
     const ID & matrix_id, const ID & dof_id, const Array<Real> & elementary_mat,
     const ElementType & type, const GhostType & ghost_type,
     const MatrixType & elemental_matrix_type,
     const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   auto & dof_data = this->getDOFData(dof_id);
 
   AKANTU_DEBUG_ASSERT(dof_data.support_type == _dst_nodal,
                       "This function applies only on Nodal dofs");
 
   this->addToProfile(matrix_id, dof_id, type, ghost_type);
 
   const auto & equation_number = this->getLocalEquationNumbers(dof_id);
   auto & A = this->getMatrix(matrix_id);
 
   UInt nb_element;
   UInt * filter_it = nullptr;
   if (filter_elements != empty_filter) {
     nb_element = filter_elements.size();
     filter_it = filter_elements.storage();
   } else {
     if (dof_data.group_support != "__mesh__") {
       const auto & group_elements =
           this->mesh->getElementGroup(dof_data.group_support)
               .getElements(type, ghost_type);
       nb_element = group_elements.size();
       filter_it = group_elements.storage();
     } else {
       nb_element = this->mesh->getNbElement(type, ghost_type);
     }
   }
 
   AKANTU_DEBUG_ASSERT(elementary_mat.size() == nb_element,
                       "The vector elementary_mat("
                           << elementary_mat.getID()
                           << ") has not the good size.");
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
   UInt nb_degree_of_freedom = dof_data.dof->getNbComponent();
 
   const Array<UInt> & connectivity =
       this->mesh->getConnectivity(type, ghost_type);
   auto conn_begin = connectivity.begin(nb_nodes_per_element);
   auto conn_it = conn_begin;
 
   UInt size_mat = nb_nodes_per_element * nb_degree_of_freedom;
 
   Vector<UInt> element_eq_nb(nb_degree_of_freedom * nb_nodes_per_element);
   Array<Real>::const_matrix_iterator el_mat_it =
       elementary_mat.begin(size_mat, size_mat);
 
   for (UInt e = 0; e < nb_element; ++e, ++el_mat_it) {
     if (filter_it)
       conn_it = conn_begin + *filter_it;
 
     this->extractElementEquationNumber(equation_number, *conn_it,
                                        nb_degree_of_freedom, element_eq_nb);
     std::transform(element_eq_nb.begin(), element_eq_nb.end(),
                    element_eq_nb.begin(), [&](UInt & local) -> UInt {
                      return this->localToGlobalEquationNumber(local);
                    });
 
     if (filter_it)
       ++filter_it;
     else
       ++conn_it;
 
     if (A.getMatrixType() == _symmetric)
       if (elemental_matrix_type == _symmetric)
         this->addSymmetricElementalMatrixToSymmetric(A, *el_mat_it,
                                                      element_eq_nb, A.size());
       else
         this->addUnsymmetricElementalMatrixToSymmetric(A, *el_mat_it,
                                                        element_eq_nb, A.size());
     else
       this->addElementalMatrixToUnsymmetric(A, *el_mat_it, element_eq_nb,
                                             A.size());
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assemblePreassembledMatrix(
     const ID & dof_id_m, const ID & dof_id_n, const ID & matrix_id,
     const TermsToAssemble & terms) {
   const Array<UInt> & equation_number_m =
       this->getLocalEquationNumbers(dof_id_m);
   const Array<UInt> & equation_number_n =
       this->getLocalEquationNumbers(dof_id_n);
   SparseMatrixAIJ & A = this->getMatrix(matrix_id);
 
   for (const auto & term : terms) {
     UInt gi = this->localToGlobalEquationNumber(equation_number_m(term.i()));
     UInt gj = this->localToGlobalEquationNumber(equation_number_n(term.j()));
     A.add(gi, gj, term);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::addToProfile(const ID & matrix_id, const ID & dof_id,
                                      const ElementType & type,
                                      const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   const DOFData & dof_data = this->getDOFData(dof_id);
 
   if (dof_data.support_type != _dst_nodal)
     return;
 
   auto mat_dof = std::make_pair(matrix_id, dof_id);
   auto type_pair = std::make_pair(type, ghost_type);
 
   auto prof_it = this->matrix_profiled_dofs.find(mat_dof);
   if (prof_it != this->matrix_profiled_dofs.end() &&
       std::find(prof_it->second.begin(), prof_it->second.end(), type_pair) !=
           prof_it->second.end())
     return;
 
   UInt nb_degree_of_freedom_per_node = dof_data.dof->getNbComponent();
 
   const auto & equation_number = this->getLocalEquationNumbers(dof_id);
 
   auto & A = this->getMatrix(matrix_id);
 
   auto size = A.size();
 
   auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
   const auto & connectivity = this->mesh->getConnectivity(type, ghost_type);
   auto cbegin = connectivity.begin(nb_nodes_per_element);
   auto cit = cbegin;
 
   UInt nb_elements = connectivity.size();
   UInt * ge_it = nullptr;
   if (dof_data.group_support != "__mesh__") {
     const auto & group_elements =
         this->mesh->getElementGroup(dof_data.group_support)
             .getElements(type, ghost_type);
     ge_it = group_elements.storage();
     nb_elements = group_elements.size();
   }
 
   UInt size_mat = nb_nodes_per_element * nb_degree_of_freedom_per_node;
   Vector<UInt> element_eq_nb(size_mat);
 
   for (UInt e = 0; e < nb_elements; ++e) {
     if (ge_it)
       cit = cbegin + *ge_it;
 
     this->extractElementEquationNumber(
         equation_number, *cit, nb_degree_of_freedom_per_node, element_eq_nb);
     std::transform(element_eq_nb.storage(),
                    element_eq_nb.storage() + element_eq_nb.size(),
                    element_eq_nb.storage(), [&](UInt & local) -> UInt {
                      return this->localToGlobalEquationNumber(local);
                    });
 
     if (ge_it)
       ++ge_it;
     else
       ++cit;
 
     for (UInt i = 0; i < size_mat; ++i) {
       UInt c_irn = element_eq_nb(i);
       if (c_irn < size) {
         for (UInt j = 0; j < size_mat; ++j) {
           UInt c_jcn = element_eq_nb(j);
           if (c_jcn < size) {
             A.add(c_irn, c_jcn);
           }
         }
       }
     }
   }
 
   this->matrix_profiled_dofs[mat_dof].push_back(type_pair);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::applyBoundary(const ID & matrix_id) {
   SparseMatrixAIJ & J = this->getMatrix(matrix_id);
 
   if (this->jacobian_release == J.getValueRelease()) {
     auto are_equal =
         std::equal(global_blocked_dofs.begin(), global_blocked_dofs.end(),
                    previous_global_blocked_dofs.begin());
 
     if (not are_equal)
       J.applyBoundary();
 
     previous_global_blocked_dofs.copy(global_blocked_dofs);
   } else {
     J.applyBoundary();
   }
 
   this->jacobian_release = J.getValueRelease();
 }
 
 /* -------------------------------------------------------------------------- */
 const Array<Real> & DOFManagerDefault::getGlobalResidual() {
   if (this->synchronizer) {
     if (not this->global_residual) {
       this->global_residual =
           std::make_unique<Array<Real>>(0, 1, "global_residual");
     }
 
     if (this->synchronizer->getCommunicator().whoAmI() == 0) {
       this->global_residual->resize(this->system_size);
       this->synchronizer->gather(this->residual, *this->global_residual);
     } else {
       this->synchronizer->gather(this->residual);
     }
 
     return *this->global_residual;
   } else {
     return this->residual;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 const Array<Real> & DOFManagerDefault::getResidual() const {
   return this->residual;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::setGlobalSolution(const Array<Real> & solution) {
   if (this->synchronizer) {
     if (this->synchronizer->getCommunicator().whoAmI() == 0) {
       this->synchronizer->scatter(this->global_solution, solution);
     } else {
       this->synchronizer->scatter(this->global_solution);
     }
   } else {
     AKANTU_DEBUG_ASSERT(solution.size() == this->global_solution.size(),
                         "Sequential call to this function needs the solution "
                         "to be the same size as the global_solution");
     this->global_solution.copy(solution);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::onNodesAdded(const Array<UInt> & nodes_list,
                                      const NewNodesEvent & event) {
   DOFManager::onNodesAdded(nodes_list, event);
 
   if (this->synchronizer)
     this->synchronizer->onNodesAdded(nodes_list);
 }
 
 /* -------------------------------------------------------------------------- */
 std::pair<UInt, UInt>
 DOFManagerDefault::updateNodalDOFs(const ID & dof_id,
                                    const Array<UInt> & nodes_list) {
   UInt nb_new_local_dofs, nb_new_pure_local;
   std::tie(nb_new_local_dofs, nb_new_pure_local) =
       DOFManager::updateNodalDOFs(dof_id, nodes_list);
 
   auto & dof_data = this->getDOFDataTyped<DOFDataDefault>(dof_id);
-  updateDOFsData(dof_data, nb_new_local_dofs, nb_new_pure_local, nodes_list.size(),
+  updateDOFsData(dof_data, nb_new_local_dofs, nb_new_pure_local,
+                 nodes_list.size(),
                  [&nodes_list](UInt pos) -> UInt { return nodes_list[pos]; });
 
   return std::make_pair(nb_new_local_dofs, nb_new_pure_local);
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 class GlobalDOFInfoDataAccessor : public DataAccessor<UInt> {
 public:
   using size_type =
       typename std::unordered_map<UInt, std::vector<UInt>>::size_type;
 
   GlobalDOFInfoDataAccessor(DOFManagerDefault::DOFDataDefault & dof_data,
                             DOFManagerDefault & dof_manager)
       : dof_data(dof_data), dof_manager(dof_manager) {
     for (auto && pair :
          zip(dof_data.local_equation_number, dof_data.associated_nodes)) {
       UInt node, dof;
       std::tie(dof, node) = pair;
+
       dofs_per_node[node].push_back(dof);
     }
   }
 
   UInt getNbData(const Array<UInt> & nodes,
                  const SynchronizationTag & tag) const override {
-    if (tag == _gst_ask_nodes) {
+    if (tag == _gst_ask_nodes or tag == _gst_giu_global_conn) {
       return nodes.size() * dof_data.dof->getNbComponent() * sizeof(UInt);
     }
 
     return 0;
   }
 
   void packData(CommunicationBuffer & buffer, const Array<UInt> & nodes,
                 const SynchronizationTag & tag) const override {
-    if (tag == _gst_ask_nodes) {
+    if (tag == _gst_ask_nodes or tag == _gst_giu_global_conn) {
       for (auto & node : nodes) {
         auto & dofs = dofs_per_node.at(node);
         for (auto & dof : dofs) {
           buffer << dof_manager.global_equation_number(dof);
         }
       }
     }
   }
 
   void unpackData(CommunicationBuffer & buffer, const Array<UInt> & nodes,
                   const SynchronizationTag & tag) override {
-    if (tag == _gst_ask_nodes) {
+    if (tag == _gst_ask_nodes or tag == _gst_giu_global_conn) {
       for (auto & node : nodes) {
         auto & dofs = dofs_per_node[node];
         for (auto dof : dofs) {
           UInt global_dof;
           buffer >> global_dof;
+          AKANTU_DEBUG_ASSERT(
+              (dof_manager.global_equation_number(dof) == UInt(-1) or
+              dof_manager.global_equation_number(dof) == global_dof),
+              "This dof already had a global_dof_id which is different from "
+              "the received one. "
+                  << dof_manager.global_equation_number(dof)
+                  << " != " << global_dof);
           dof_manager.global_equation_number(dof) = global_dof;
           dof_manager.global_to_local_mapping[global_dof] = dof;
         }
       }
     }
   }
 
 protected:
   std::unordered_map<UInt, std::vector<UInt>> dofs_per_node;
   DOFManagerDefault::DOFDataDefault & dof_data;
   DOFManagerDefault & dof_manager;
 };
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::resizeGlobalArrays() {
   // resize all relevant arrays
   this->residual.resize(this->local_system_size, 0.);
   this->dofs_flag.resize(this->local_system_size, NodeFlag::_normal);
   this->global_solution.resize(this->local_system_size, 0.);
   this->global_blocked_dofs.resize(this->local_system_size, true);
   this->previous_global_blocked_dofs.resize(this->local_system_size, true);
   this->global_equation_number.resize(this->local_system_size, -1);
 
   for (auto & lumped_matrix : lumped_matrices)
     lumped_matrix.second->resize(this->local_system_size);
 
   matrix_profiled_dofs.clear();
   for (auto & matrix : matrices) {
     matrix.second->clearProfile();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 auto DOFManagerDefault::computeFirstDOFIDs(UInt nb_new_local_dofs,
                                            UInt nb_new_pure_local) {
   auto prank = this->communicator.whoAmI();
   auto psize = this->communicator.getNbProc();
 
   // determine the first local/global dof id to use
   Array<UInt> nb_dofs_per_proc(psize);
   nb_dofs_per_proc(prank) = nb_new_pure_local;
   this->communicator.allGather(nb_dofs_per_proc);
 
   this->first_global_dof_id += std::accumulate(
       nb_dofs_per_proc.begin(), nb_dofs_per_proc.begin() + prank, 0);
 
   auto first_global_dof_id = this->first_global_dof_id;
   auto first_local_dof_id = this->local_system_size - nb_new_local_dofs;
 
-  this->first_global_dof_id += std::accumulate(
-      nb_dofs_per_proc.begin() + prank, nb_dofs_per_proc.end(), 0);
+  this->first_global_dof_id += std::accumulate(nb_dofs_per_proc.begin() + prank,
+                                               nb_dofs_per_proc.end(), 0);
 
   return std::make_pair(first_local_dof_id, first_global_dof_id);
 }
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::updateDOFsData(
     DOFDataDefault & dof_data, UInt nb_new_local_dofs, UInt nb_new_pure_local,
     UInt nb_node, const std::function<UInt(UInt)> & getNode) {
   auto nb_local_dofs_added = nb_node * dof_data.dof->getNbComponent();
 
   resizeGlobalArrays();
 
   auto first_dof_pos = dof_data.local_equation_number.size();
   dof_data.local_equation_number.reserve(dof_data.local_equation_number.size() +
                                          nb_local_dofs_added);
   dof_data.associated_nodes.reserve(dof_data.associated_nodes.size() +
                                     nb_local_dofs_added);
 
   std::unordered_map<std::pair<UInt, UInt>, UInt> masters_dofs;
 
   // update per dof info
   UInt local_eq_num, first_global_dof_id;
   std::tie(local_eq_num, first_global_dof_id) =
       computeFirstDOFIDs(nb_new_local_dofs, nb_new_pure_local);
   for (auto d : arange(nb_local_dofs_added)) {
     auto node = getNode(d / dof_data.dof->getNbComponent());
     auto dof_flag = this->mesh->getNodeFlag(node);
 
     dof_data.associated_nodes.push_back(node);
     auto is_local_dof = this->mesh->isLocalOrMasterNode(node);
     auto is_periodic_slave = this->mesh->isPeriodicSlave(node);
     auto is_periodic_master = this->mesh->isPeriodicMaster(node);
 
     if (is_periodic_slave) {
       dof_data.local_equation_number.push_back(UInt(-1));
       continue;
     }
 
     // update equation numbers
     this->dofs_flag(local_eq_num) = dof_flag;
     dof_data.local_equation_number.push_back(local_eq_num);
 
     if (is_local_dof) {
       this->global_equation_number(local_eq_num) = first_global_dof_id;
       this->global_to_local_mapping[first_global_dof_id] = local_eq_num;
       ++first_global_dof_id;
     } else {
       this->global_equation_number(local_eq_num) = UInt(-1);
     }
 
     if (is_periodic_master) {
       auto node = getNode(d / dof_data.dof->getNbComponent());
       auto dof = d % dof_data.dof->getNbComponent();
       masters_dofs.insert(
           std::make_pair(std::make_pair(node, dof), local_eq_num));
     }
 
     ++local_eq_num;
   }
 
   // correct periodic slave equation numbers
   if (this->mesh->isPeriodic()) {
     auto assoc_begin = dof_data.associated_nodes.begin();
     for (auto d : arange(nb_local_dofs_added)) {
       auto node = dof_data.associated_nodes(first_dof_pos + d);
       if (not this->mesh->isPeriodicSlave(node))
         continue;
 
       auto master_node = this->mesh->getPeriodicMaster(node);
       auto dof = d % dof_data.dof->getNbComponent();
       dof_data.local_equation_number(first_dof_pos + d) =
           masters_dofs[std::make_pair(master_node, dof)];
     }
   }
 
   // synchronize the global numbering for slaves
   if (this->synchronizer) {
     GlobalDOFInfoDataAccessor data_accessor(dof_data, *this);
+
+    if (this->mesh->isPeriodic()) {
+      mesh->getPeriodicNodeSynchronizer().synchronizeOnce(data_accessor,
+                                                          _gst_giu_global_conn);
+    }
+
     auto & node_synchronizer = this->mesh->getNodeSynchronizer();
     node_synchronizer.synchronizeOnce(data_accessor, _gst_ask_nodes);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::updateDOFsData(DOFDataDefault & dof_data,
                                        UInt nb_new_local_dofs,
                                        UInt nb_new_pure_local) {
   resizeGlobalArrays();
 
   dof_data.local_equation_number.reserve(dof_data.local_equation_number.size() +
                                          nb_new_local_dofs);
 
   UInt first_local_dof_id, first_global_dof_id;
   std::tie(first_local_dof_id, first_global_dof_id) =
       computeFirstDOFIDs(nb_new_local_dofs, nb_new_pure_local);
 
   // update per dof info
-  for (auto _ [[gnu::unused]] : arange(nb_new_local_dofs)) {
+  for (auto _[[gnu::unused]] : arange(nb_new_local_dofs)) {
     // update equation numbers
     this->dofs_flag(first_local_dof_id) = NodeFlag::_normal;
     ;
     dof_data.local_equation_number.push_back(first_local_dof_id);
 
     this->global_equation_number(first_local_dof_id) = first_global_dof_id;
     this->global_to_local_mapping[first_global_dof_id] = first_local_dof_id;
 
     ++first_global_dof_id;
     ++first_local_dof_id;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 // register in factory
 static bool default_dof_manager_is_registered[[gnu::unused]] =
     DefaultDOFManagerFactory::getInstance().registerAllocator(
         "default", [](const ID & id,
                       const MemoryID & mem_id) -> std::unique_ptr<DOFManager> {
           return std::make_unique<DOFManagerDefault>(id, mem_id);
         });
 
 static bool dof_manager_is_registered[[gnu::unused]] =
     DOFManagerFactory::getInstance().registerAllocator(
         "default", [](Mesh & mesh, const ID & id,
                       const MemoryID & mem_id) -> std::unique_ptr<DOFManager> {
           return std::make_unique<DOFManagerDefault>(mesh, id, mem_id);
         });
 } // namespace akantu
diff --git a/src/solver/sparse_matrix_aij.cc b/src/solver/sparse_matrix_aij.cc
index cb10f23ae..bb16d2b33 100644
--- a/src/solver/sparse_matrix_aij.cc
+++ b/src/solver/sparse_matrix_aij.cc
@@ -1,216 +1,216 @@
 /**
  * @file   sparse_matrix_aij.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Aug 21 2015
  * @date last modification: Mon Dec 04 2017
  *
  * @brief  Implementation of the AIJ sparse matrix
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "sparse_matrix_aij.hh"
 #include "aka_iterators.hh"
 #include "dof_manager_default.hh"
 #include "dof_synchronizer.hh"
 #include "terms_to_assemble.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 SparseMatrixAIJ::SparseMatrixAIJ(DOFManagerDefault & dof_manager,
                                  const MatrixType & matrix_type, const ID & id)
     : SparseMatrix(dof_manager, matrix_type, id), dof_manager(dof_manager),
       irn(0, 1, id + ":irn"), jcn(0, 1, id + ":jcn"), a(0, 1, id + ":a") {}
 
 /* -------------------------------------------------------------------------- */
 SparseMatrixAIJ::SparseMatrixAIJ(const SparseMatrixAIJ & matrix, const ID & id)
     : SparseMatrix(matrix, id), dof_manager(matrix.dof_manager),
-      irn(matrix.irn, true, id + ":irn"), jcn(matrix.jcn, true, id + ":jcn"),
-      a(matrix.a, true, id + ":a") {}
+      irn(matrix.irn, id + ":irn"), jcn(matrix.jcn, id + ":jcn"),
+      a(matrix.a, id + ":a") {}
 
 /* -------------------------------------------------------------------------- */
 SparseMatrixAIJ::~SparseMatrixAIJ() = default;
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::applyBoundary(Real block_val) {
   AKANTU_DEBUG_IN();
 
   // clang-format off
   const auto & blocked_dofs = this->dof_manager.getGlobalBlockedDOFs();
 
   for (auto && ij_a : zip(irn, jcn, a)) {
     UInt ni = this->dof_manager.globalToLocalEquationNumber(std::get<0>(ij_a) - 1);
     UInt nj = this->dof_manager.globalToLocalEquationNumber(std::get<1>(ij_a) - 1);
     if (blocked_dofs(ni) || blocked_dofs(nj)) {
       std::get<2>(ij_a) =
           std::get<0>(ij_a) != std::get<1>(ij_a)   ? 0.
         : this->dof_manager.isLocalOrMasterDOF(ni) ? block_val
         :                                            0.;
     }
   }
 
   this->value_release++;
   // clang-format on
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::saveProfile(const std::string & filename) const {
   AKANTU_DEBUG_IN();
 
   std::ofstream outfile;
   outfile.open(filename.c_str());
 
   UInt m = this->size_;
   outfile << "%%MatrixMarket matrix coordinate pattern";
   if (this->matrix_type == _symmetric)
     outfile << " symmetric";
   else
     outfile << " general";
   outfile << std::endl;
   outfile << m << " " << m << " " << this->nb_non_zero << std::endl;
 
   for (UInt i = 0; i < this->nb_non_zero; ++i) {
     outfile << this->irn.storage()[i] << " " << this->jcn.storage()[i] << " 1"
             << std::endl;
   }
 
   outfile.close();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::saveMatrix(const std::string & filename) const {
   AKANTU_DEBUG_IN();
 
   // open and set the properties of the stream
   std::ofstream outfile;
   outfile.open(filename.c_str());
   outfile.precision(std::numeric_limits<Real>::digits10);
 
   // write header
   outfile << "%%MatrixMarket matrix coordinate real";
   if (this->matrix_type == _symmetric)
     outfile << " symmetric";
   else
     outfile << " general";
   outfile << std::endl;
   outfile << this->size_ << " " << this->size_ << " " << this->nb_non_zero
           << std::endl;
 
   // write content
   for (UInt i = 0; i < this->nb_non_zero; ++i) {
     outfile << this->irn(i) << " " << this->jcn(i) << " " << this->a(i)
             << std::endl;
   }
 
   // time to end
   outfile.close();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::matVecMul(const Array<Real> & x, Array<Real> & y,
                                 Real alpha, Real beta) const {
   AKANTU_DEBUG_IN();
 
   y *= beta;
 
   auto i_it = this->irn.begin();
   auto j_it = this->jcn.begin();
   auto a_it = this->a.begin();
   auto a_end = this->a.end();
   auto x_it = x.begin_reinterpret(x.size() * x.getNbComponent());
   auto y_it = y.begin_reinterpret(x.size() * x.getNbComponent());
 
   for (; a_it != a_end; ++i_it, ++j_it, ++a_it) {
     Int i = this->dof_manager.globalToLocalEquationNumber(*i_it - 1);
     Int j = this->dof_manager.globalToLocalEquationNumber(*j_it - 1);
     const Real & A = *a_it;
 
     y_it[i] += alpha * A * x_it[j];
 
     if ((this->matrix_type == _symmetric) && (i != j))
       y_it[j] += alpha * A * x_it[i];
   }
 
   if (this->dof_manager.hasSynchronizer())
     this->dof_manager.getSynchronizer().reduceSynchronize<AddOperation>(y);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::copyContent(const SparseMatrix & matrix) {
   AKANTU_DEBUG_IN();
   const auto & mat = dynamic_cast<const SparseMatrixAIJ &>(matrix);
   AKANTU_DEBUG_ASSERT(nb_non_zero == mat.getNbNonZero(),
                       "The to matrix don't have the same profiles");
   memcpy(a.storage(), mat.getA().storage(), nb_non_zero * sizeof(Real));
 
   this->value_release++;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class MatrixType>
 void SparseMatrixAIJ::addMeToTemplated(MatrixType & B, Real alpha) const {
   UInt i, j;
   Real A_ij;
   for (auto && tuple : zip(irn, jcn, a)) {
     std::tie(i, j, A_ij) = tuple;
     B.add(i - 1, j - 1, alpha * A_ij);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::addMeTo(SparseMatrix & B, Real alpha) const {
   if (auto * B_aij = dynamic_cast<SparseMatrixAIJ *>(&B)) {
     this->addMeToTemplated<SparseMatrixAIJ>(*B_aij, alpha);
   } else {
     //    this->addMeToTemplated<SparseMatrix>(*this, alpha);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::mul(Real alpha) {
   this->a *= alpha;
   this->value_release++;
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::clear() {
   a.set(0.);
 
   this->value_release++;
 }
 
 } // namespace akantu
diff --git a/src/synchronizer/communication_buffer.hh b/src/synchronizer/communication_buffer.hh
index 54586466c..03822eae9 100644
--- a/src/synchronizer/communication_buffer.hh
+++ b/src/synchronizer/communication_buffer.hh
@@ -1,190 +1,182 @@
 /**
  * @file   communication_buffer.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Wed Nov 08 2017
  *
  * @brief  Buffer for packing and unpacking data
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "aka_common.hh"
 #include "element.hh"
 
 #ifndef __AKANTU_COMMUNICATION_BUFFER_HH__
 #define __AKANTU_COMMUNICATION_BUFFER_HH__
 
 namespace akantu {
 
 template <bool is_static = true> class CommunicationBufferTemplated {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
-  explicit CommunicationBufferTemplated(UInt size) : buffer(size, 1) {
+  explicit CommunicationBufferTemplated(UInt size)
+      : buffer(size, 1, char()) {
     ptr_pack = buffer.storage();
     ptr_unpack = buffer.storage();
   };
 
   CommunicationBufferTemplated() : CommunicationBufferTemplated(0) {}
 
-  CommunicationBufferTemplated(const CommunicationBufferTemplated & other) {
-    buffer = other.buffer;
-    ptr_pack = buffer.storage();
-    ptr_unpack = buffer.storage();
-  }
-
+  CommunicationBufferTemplated(const CommunicationBufferTemplated & other) = delete;
   CommunicationBufferTemplated &
-  operator=(const CommunicationBufferTemplated & other) {
-    if (this != &other) {
-      buffer = other.buffer;
-      ptr_pack = buffer.storage();
-      ptr_unpack = buffer.storage();
-    }
-    return *this;
-  }
+  operator=(const CommunicationBufferTemplated & other) = delete;
+
+
+  CommunicationBufferTemplated(CommunicationBufferTemplated && other) = default;
 
   virtual ~CommunicationBufferTemplated() = default;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// reset to "empty"
   inline void reset();
 
   /// resize the internal buffer do not allocate on dynamic buffers
   inline void resize(UInt size);
 
   /// resize the internal buffer allocate always
   inline void reserve(UInt size);
 
   /// clear buffer context
   inline void clear();
 
 private:
   inline void packResize(UInt size);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   inline char * storage() { return buffer.storage(); };
   inline const char * storage() const { return buffer.storage(); };
   /* ------------------------------------------------------------------------ */
   /* Operators                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// printing tool
   template <typename T> inline std::string extractStream(UInt packet_size);
 
   /// packing data
   template <typename T>
   inline CommunicationBufferTemplated & operator<<(const T & to_pack);
 
   template <typename T>
   inline CommunicationBufferTemplated & operator<<(const Vector<T> & to_pack);
 
   template <typename T>
   inline CommunicationBufferTemplated & operator<<(const Matrix<T> & to_pack);
 
   template <typename T>
   inline CommunicationBufferTemplated &
   operator<<(const std::vector<T> & to_pack);
 
   /// unpacking data
   template <typename T>
   inline CommunicationBufferTemplated & operator>>(T & to_unpack);
 
   template <typename T>
   inline CommunicationBufferTemplated & operator>>(Vector<T> & to_unpack);
 
   template <typename T>
   inline CommunicationBufferTemplated & operator>>(Matrix<T> & to_unpack);
 
   template <typename T>
   inline CommunicationBufferTemplated & operator>>(std::vector<T> & to_unpack);
 
   inline CommunicationBufferTemplated & operator<<(const std::string & to_pack);
   inline CommunicationBufferTemplated & operator>>(std::string & to_unpack);
 
 private:
   template <typename T> inline void packIterable(T & to_pack);
   template <typename T> inline void unpackIterable(T & to_pack);
 
   /* ------------------------------------------------------------------------ */
   /* Accessor                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   template <typename T> static inline UInt sizeInBuffer(const T & data);
   template <typename T> static inline UInt sizeInBuffer(const Vector<T> & data);
   template <typename T> static inline UInt sizeInBuffer(const Matrix<T> & data);
   template <typename T>
   static inline UInt sizeInBuffer(const std::vector<T> & data);
   static inline UInt sizeInBuffer(const std::string & data);
 
   /// return the size in bytes of the stored values
   inline UInt getPackedSize() const { return ptr_pack - buffer.storage(); };
   /// return the size in bytes of data left to be unpacked
   inline UInt getLeftToUnpack() const {
     return buffer.size() - (ptr_unpack - buffer.storage());
   };
   /// return the global size allocated
   inline UInt size() const { return buffer.size(); };
 
   /// is the buffer empty
   inline bool empty() const {
     return (getPackedSize() == 0) and (getLeftToUnpack() == 0);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// current position for packing
   char * ptr_pack;
 
   /// current position for unpacking
   char * ptr_unpack;
 
   /// storing buffer
   Array<char> buffer;
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 #if defined(AKANTU_INCLUDE_INLINE_IMPL)
 #include "communication_buffer_inline_impl.cc"
 #endif
 
 using CommunicationBuffer = CommunicationBufferTemplated<true>;
 using DynamicCommunicationBuffer = CommunicationBufferTemplated<false>;
 
 } // namespace akantu
 
 #endif /* __AKANTU_COMMUNICATION_BUFFER_HH__ */
diff --git a/src/synchronizer/communication_buffer_inline_impl.cc b/src/synchronizer/communication_buffer_inline_impl.cc
index 96b3fe147..3b3b8ef2e 100644
--- a/src/synchronizer/communication_buffer_inline_impl.cc
+++ b/src/synchronizer/communication_buffer_inline_impl.cc
@@ -1,333 +1,333 @@
 /**
  * @file   communication_buffer_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Apr 14 2011
  * @date last modification: Wed Nov 08 2017
  *
  * @brief  CommunicationBuffer inline implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline UInt CommunicationBufferTemplated<is_static>::sizeInBuffer(const T &) {
   return sizeof(T);
 }
 
 template <bool is_static>
 template <typename T>
 inline UInt
 CommunicationBufferTemplated<is_static>::sizeInBuffer(const Vector<T> & data) {
   UInt size = data.size() * sizeof(T);
   return size;
 }
 
 template <bool is_static>
 template <typename T>
 inline UInt
 CommunicationBufferTemplated<is_static>::sizeInBuffer(const Matrix<T> & data) {
   UInt size = data.size() * sizeof(T);
   return size;
 }
 
 template <bool is_static>
 template <typename T>
 inline UInt CommunicationBufferTemplated<is_static>::sizeInBuffer(
     const std::vector<T> & data) {
   UInt size = data.size() * sizeof(T) + sizeof(size_t);
   return size;
 }
 
 template <bool is_static>
 inline UInt CommunicationBufferTemplated<is_static>::sizeInBuffer(
     const std::string & data) {
   UInt size = data.size() * sizeof(std::string::value_type) + sizeof(size_t);
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 inline void CommunicationBufferTemplated<is_static>::packResize(UInt size) {
   if (not is_static) {
     char * values = buffer.storage();
     auto nb_packed = ptr_pack - values;
 
     if(buffer.size() > nb_packed + size) return;
 
     buffer.resize(nb_packed + size);
     ptr_pack = buffer.storage() + nb_packed;
     ptr_unpack = buffer.storage() + (ptr_unpack - values);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator<<(const T & to_pack) {
   UInt size = sizeInBuffer(to_pack);
   packResize(size);
   AKANTU_DEBUG_ASSERT(
       (buffer.storage() + buffer.size()) >= (ptr_pack + size),
       "Packing too much data in the CommunicationBufferTemplated");
   memcpy(ptr_pack, reinterpret_cast<const char *>(&to_pack), size);
   ptr_pack += size;
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator>>(T & to_unpack) {
   UInt size = sizeInBuffer(to_unpack);
 
   alignas(alignof(T)) std::array<char, sizeof(T)> aligned_ptr;
   memcpy(aligned_ptr.data(), ptr_unpack, size);
 
   auto * tmp = reinterpret_cast<T *>(aligned_ptr.data());
   AKANTU_DEBUG_ASSERT(
       (buffer.storage() + buffer.size()) >= (ptr_unpack + size),
       "Unpacking too much data in the CommunicationBufferTemplated");
   to_unpack = *tmp;
   // memcpy(reinterpret_cast<char *>(&to_unpack), ptr_unpack, size);
   ptr_unpack += size;
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 /* Specialization                                                             */
 /* -------------------------------------------------------------------------- */
 
 /**
  * Vector
  */
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator<<(const Vector<T> & to_pack) {
   UInt size = sizeInBuffer(to_pack);
   packResize(size);
   AKANTU_DEBUG_ASSERT(
       (buffer.storage() + buffer.size()) >= (ptr_pack + size),
       "Packing too much data in the CommunicationBufferTemplated");
   memcpy(ptr_pack, to_pack.storage(), size);
   ptr_pack += size;
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator>>(Vector<T> & to_unpack) {
   UInt size = sizeInBuffer(to_unpack);
   AKANTU_DEBUG_ASSERT(
       (buffer.storage() + buffer.size()) >= (ptr_unpack + size),
       "Unpacking too much data in the CommunicationBufferTemplated");
   memcpy(to_unpack.storage(), ptr_unpack, size);
   ptr_unpack += size;
   return *this;
 }
 
 /**
  * Matrix
  */
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator<<(const Matrix<T> & to_pack) {
   UInt size = sizeInBuffer(to_pack);
   packResize(size);
   AKANTU_DEBUG_ASSERT(
       (buffer.storage() + buffer.size()) >= (ptr_pack + size),
       "Packing too much data in the CommunicationBufferTemplated");
   memcpy(ptr_pack, to_pack.storage(), size);
   ptr_pack += size;
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator>>(Matrix<T> & to_unpack) {
   UInt size = sizeInBuffer(to_unpack);
   AKANTU_DEBUG_ASSERT(
       (buffer.storage() + buffer.size()) >= (ptr_unpack + size),
       "Unpacking too much data in the CommunicationBufferTemplated");
   memcpy(to_unpack.storage(), ptr_unpack, size);
   ptr_unpack += size;
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline void CommunicationBufferTemplated<is_static>::packIterable(T & to_pack) {
   operator<<(size_t(to_pack.size()));
   auto it = to_pack.begin();
   auto end = to_pack.end();
   for (; it != end; ++it)
     operator<<(*it);
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline void
 CommunicationBufferTemplated<is_static>::unpackIterable(T & to_unpack) {
   size_t size;
   operator>>(size);
   to_unpack.resize(size);
   auto it = to_unpack.begin();
   auto end = to_unpack.end();
   for (; it != end; ++it)
     operator>>(*it);
 }
 
 /**
  * std::vector<T>
  */
 /* -------------------------------------------------------------------------- */
 
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::
 operator<<(const std::vector<T> & to_pack) {
   packIterable(to_pack);
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::
 operator>>(std::vector<T> & to_unpack) {
   unpackIterable(to_unpack);
   return *this;
 }
 
 /**
  * std::string
  */
 /* -------------------------------------------------------------------------- */
 
 template <bool is_static>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::
 operator<<(const std::string & to_pack) {
   packIterable(to_pack);
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator>>(std::string & to_unpack) {
   unpackIterable(to_unpack);
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline std::string
 CommunicationBufferTemplated<is_static>::extractStream(UInt block_size) {
   std::stringstream str;
   auto * ptr = reinterpret_cast<T *>(buffer.storage());
   UInt sz = buffer.size() / sizeof(T);
   UInt sz_block = block_size / sizeof(T);
 
   UInt n_block = 0;
   for (UInt i = 0; i < sz; ++i) {
     if (i % sz_block == 0) {
       str << std::endl << n_block << " ";
       ++n_block;
     }
     str << *ptr << " ";
     ++ptr;
   }
   return str.str();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 inline void CommunicationBufferTemplated<is_static>::resize(UInt size) {
   if (!is_static) {
-    buffer.resize(0);
+    buffer.resize(0, 0);
   } else {
-    buffer.resize(size);
+    buffer.resize(size, 0);
   }
   reset();
 #ifndef AKANTU_NDEBUG
   clear();
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 inline void CommunicationBufferTemplated<is_static>::reserve(UInt size) {
   char * values = buffer.storage();
   auto nb_packed = ptr_pack - values;
 
   buffer.resize(size);
   ptr_pack = buffer.storage() + nb_packed;
   ptr_unpack = buffer.storage() + (ptr_unpack - values);
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 inline void CommunicationBufferTemplated<is_static>::clear() {
   buffer.clear();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 inline void CommunicationBufferTemplated<is_static>::reset() {
   ptr_pack = buffer.storage();
   ptr_unpack = buffer.storage();
 }
 
 /* -------------------------------------------------------------------------- */
 // template<bool is_static>
 // inline CommunicationBufferTemplated<is_static> &
 // CommunicationBufferTemplated<is_static>::packMeshData (const MeshData &
 // to_pack, const ElementType & type) {
 
 // UInt size = to_pack.size();
 // operator<<(size);
 // typename std::vector<T>::iterator it  = to_pack.begin();
 // typename std::vector<T>::iterator end = to_pack.end();
 // for(;it != end; ++it) operator<<(*it);
 // return *this;
 
 //}
diff --git a/src/synchronizer/communication_tag.hh b/src/synchronizer/communication_tag.hh
index 753dbbc55..ff5eb6568 100644
--- a/src/synchronizer/communication_tag.hh
+++ b/src/synchronizer/communication_tag.hh
@@ -1,124 +1,124 @@
 /**
  * @file   communication_tag.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Sep 07 2016
  * @date last modification: Wed Nov 08 2017
  *
  * @brief  Description of the communication tags
  *
  * @section LICENSE
  *
  * Copyright (©) 2016-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_COMMUNICATION_TAG_HH__
 #define __AKANTU_COMMUNICATION_TAG_HH__
 
 namespace akantu {
 /**
  * tag = |__________20_________|___8____|_4_|
  *       |          proc       | num mes| ct|
  */
 class Tag {
 public:
   Tag() = default;
   Tag(int val) : tag(val) {}
   Tag(int val, int hash) : tag(val), hash(hash) {}
 
   operator int() const {
     return int(max_tag == 0 ? tag : (uint32_t(tag) % max_tag));
   }
 
   /// generates a tag
   template <typename CommTag>
   static inline Tag genTag(int proc, UInt msg_count, CommTag tag) {
     int _tag = ((((proc & 0xFFFFF) << 12) + ((msg_count & 0xFF) << 4) +
                  ((int)tag & 0xF)));
     Tag t(_tag);
     return t;
   }
 
   /// generates a tag and hashes it
   template <typename CommTag>
   static inline Tag genTag(int proc, UInt msg_count, CommTag tag, int hash) {
     Tag t = genTag(proc, msg_count, tag);
     t.tag = t.tag ^ hash;
     t.hash = hash;
     return t;
   }
 
   virtual void printself(std::ostream & stream, int) const {
     int t = tag;
     stream << "TAG(";
     if (hash != 0)
       t = t ^ hash;
     stream << (t >> 12) << ":" << (t >> 4 & 0xFF) << ":" << (t & 0xF) << " -> "
            << std::hex << "0x" << int(*this);
     if (hash != 0)
       stream << " {hash: 0x" << hash << "}";
     stream << " [0x" << this->max_tag << "]";
-    stream << ")";
+    stream << ")" << std::dec;
   }
 
   enum CommTags : int {
     _SIZES = 1,
     _CONNECTIVITY = 2,
     _DATA = 3,
     _PARTITIONS = 4,
     _NB_NODES = 5,
     _NODES = 6,
     _COORDINATES = 7,
     _NODES_TYPE = 8,
     _MESH_DATA = 9,
     _ELEMENT_GROUP = 10,
     _NODE_GROUP = 11,
     _MODIFY_SCHEME = 12,
     _GATHER_INITIALIZATION = 1,
     _GATHER = 2,
     _SCATTER = 3,
     _SYNCHRONIZE = 15,
     _REDUCE,
     _PERIODIC_SLAVES,
     _PERIODIC_NODES,
   };
 
 private:
   static void setMaxTag(int _max_tag) { max_tag = _max_tag; }
   friend void initialize(const std::string &, int &, char **&);
 
 private:
   int tag{0};
   int hash{0};
   static int max_tag;
 };
 
 /* -------------------------------------------------------------------------- */
 inline std::ostream & operator<<(std::ostream & stream, const Tag & _this) {
   _this.printself(stream, 0);
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 }
 
 #endif /* __AKANTU_COMMUNICATION_TAG_HH__ */
diff --git a/src/synchronizer/node_info_per_processor.cc b/src/synchronizer/node_info_per_processor.cc
index 627c617cd..499966c82 100644
--- a/src/synchronizer/node_info_per_processor.cc
+++ b/src/synchronizer/node_info_per_processor.cc
@@ -1,713 +1,734 @@
 /**
  * @file   node_info_per_processor.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Mar 16 2016
  * @date last modification: Wed Nov 08 2017
  *
  * @brief  Please type the brief for file: Helper classes to create the
  * distributed synchronizer and distribute a mesh
  *
  * @section LICENSE
  *
  * Copyright (©) 2016-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "node_info_per_processor.hh"
 #include "communicator.hh"
 #include "node_group.hh"
 #include "node_synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NodeInfoPerProc::NodeInfoPerProc(NodeSynchronizer & synchronizer,
                                  UInt message_cnt, UInt root)
     : MeshAccessor(synchronizer.getMesh()), synchronizer(synchronizer),
       comm(synchronizer.getCommunicator()), rank(comm.whoAmI()),
       nb_proc(comm.getNbProc()), root(root), mesh(synchronizer.getMesh()),
       spatial_dimension(synchronizer.getMesh().getSpatialDimension()),
       message_count(message_cnt) {}
 
 /* -------------------------------------------------------------------------- */
 void NodeInfoPerProc::synchronize() {
   synchronizeNodes();
   synchronizeTypes();
   synchronizeGroups();
   synchronizePeriodicity();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class CommunicationBuffer>
 void NodeInfoPerProc::fillNodeGroupsFromBuffer(CommunicationBuffer & buffer) {
   AKANTU_DEBUG_IN();
 
   std::vector<std::vector<std::string>> node_to_group;
 
   buffer >> node_to_group;
 
   AKANTU_DEBUG_ASSERT(node_to_group.size() == mesh.getNbGlobalNodes(),
                       "Not the good amount of nodes where transmitted");
 
   const auto & global_nodes = mesh.getGlobalNodesIds();
 
   auto nbegin = global_nodes.begin();
   auto nit = global_nodes.begin();
   auto nend = global_nodes.end();
   for (; nit != nend; ++nit) {
     auto it = node_to_group[*nit].begin();
     auto end = node_to_group[*nit].end();
 
     for (; it != end; ++it) {
       mesh.getNodeGroup(*it).add(nit - nbegin, false);
     }
   }
 
   GroupManager::const_node_group_iterator ngi = mesh.node_group_begin();
   GroupManager::const_node_group_iterator nge = mesh.node_group_end();
   for (; ngi != nge; ++ngi) {
     NodeGroup & ng = *(ngi->second);
     ng.optimize();
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeInfoPerProc::fillNodesType() {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes = mesh.getNbNodes();
   auto & nodes_flags = this->getNodesFlags();
 
   Array<UInt> nodes_set(nb_nodes);
   nodes_set.set(0);
 
   enum NodeSet {
     NORMAL_SET = 1,
     GHOST_SET = 2,
   };
 
   Array<bool> already_seen(nb_nodes, 1, false);
 
   for (auto gt : ghost_types) {
     UInt set = NORMAL_SET;
     if (gt == _ghost)
       set = GHOST_SET;
 
     already_seen.set(false);
     for (auto && type :
          mesh.elementTypes(_all_dimensions, gt, _ek_not_defined)) {
       const auto & connectivity = mesh.getConnectivity(type, gt);
 
       for (auto & conn :
            make_view(connectivity, connectivity.getNbComponent())) {
         for (UInt n = 0; n < conn.size(); ++n) {
           AKANTU_DEBUG_ASSERT(conn(n) < nb_nodes,
                               "Node " << conn(n)
                                       << " bigger than number of nodes "
                                       << nb_nodes);
           if (!already_seen(conn(n))) {
             nodes_set(conn(n)) += set;
             already_seen(conn(n)) = true;
           }
         }
       }
     }
   }
 
   nodes_flags.resize(nb_nodes);
   for (UInt i = 0; i < nb_nodes; ++i) {
     if (nodes_set(i) == NORMAL_SET)
       nodes_flags(i) = NodeFlag::_normal;
     else if (nodes_set(i) == GHOST_SET)
       nodes_flags(i) = NodeFlag::_pure_ghost;
     else if (nodes_set(i) == (GHOST_SET + NORMAL_SET))
       nodes_flags(i) = NodeFlag::_master;
     else {
       AKANTU_EXCEPTION("Gni ?");
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeInfoPerProc::fillCommunicationScheme(const Array<UInt> & master_info) {
   AKANTU_DEBUG_IN();
 
   Communications<UInt> & communications =
       this->synchronizer.getCommunications();
 
   { // send schemes
     auto it = master_info.begin_reinterpret(2, master_info.size() / 2);
     auto end = master_info.end_reinterpret(2, master_info.size() / 2);
 
     std::map<UInt, Array<UInt>> send_array_per_proc;
 
     for (; it != end; ++it) {
       const Vector<UInt> & send_info = *it;
 
       send_array_per_proc[send_info(0)].push_back(send_info(1));
     }
 
     for (auto & send_schemes : send_array_per_proc) {
       auto & scheme = communications.createSendScheme(send_schemes.first);
 
       auto & sends = send_schemes.second;
       std::sort(sends.begin(), sends.end());
       std::transform(sends.begin(), sends.end(), sends.begin(),
                      [this](UInt g) -> UInt { return mesh.getNodeLocalId(g); });
       scheme.copy(sends);
     }
   }
 
   { // receive schemes
     std::map<UInt, Array<UInt>> recv_array_per_proc;
 
     for (auto node : arange(mesh.getNbNodes())) {
       if (mesh.isSlaveNode(node)) {
         recv_array_per_proc[mesh.getNodePrank(node)].push_back(
             mesh.getNodeGlobalId(node));
       }
     }
 
     for (auto & recv_schemes : recv_array_per_proc) {
       auto & scheme = communications.createRecvScheme(recv_schemes.first);
 
       auto & recvs = recv_schemes.second;
       std::sort(recvs.begin(), recvs.end());
       std::transform(recvs.begin(), recvs.end(), recvs.begin(),
                      [this](UInt g) -> UInt { return mesh.getNodeLocalId(g); });
 
       scheme.copy(recvs);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeInfoPerProc::fillPeriodicPairs(const Array<UInt> & global_pairs,
                                         std::vector<UInt> & missing_nodes) {
   this->wipePeriodicInfo();
   auto & nodes_flags = this->getNodesFlags();
 
   auto checkIsLocal = [&](auto && global_node) {
     auto && node = mesh.getNodeLocalId(global_node);
     if (node == UInt(-1)) {
       auto & global_nodes = this->getNodesGlobalIds();
       node = global_nodes.size();
 
       global_nodes.push_back(global_node);
       nodes_flags.push_back(NodeFlag::_pure_ghost);
       missing_nodes.push_back(global_node);
       std::cout << "Missing node " << node << std::endl;
     }
     return node;
   };
 
   for (auto && pairs : make_view(global_pairs, 2)) {
     UInt slave = checkIsLocal(pairs(0));
     UInt master = checkIsLocal(pairs(1));
 
     this->addPeriodicSlave(slave, master);
   }
 
   this->markMeshPeriodic();
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeInfoPerProc::receiveMissingPeriodic(
     DynamicCommunicationBuffer & buffer) {
   auto & nodes = this->getNodes();
   Communications<UInt> & communications =
       this->synchronizer.getCommunications();
 
   std::size_t nb_nodes;
   buffer >> nb_nodes;
 
-  for (auto _ [[gnu::unused]] : arange(nb_nodes)) {
+  for (auto _[[gnu::unused]] : arange(nb_nodes)) {
     Vector<Real> pos(spatial_dimension);
     Int prank;
     buffer >> pos;
     buffer >> prank;
 
     UInt node = nodes.size();
 
     this->setNodePrank(node, prank);
     nodes.push_back(pos);
 
     auto & scheme = communications.createRecvScheme(prank);
     scheme.push_back(node);
   }
 
   while (buffer.getLeftToUnpack() != 0) {
     Int prank;
     UInt gnode;
 
     buffer >> gnode;
     buffer >> prank;
     auto node = mesh.getNodeLocalId(gnode);
 
     AKANTU_DEBUG_ASSERT(node != UInt(-1),
                         "I cannot send the node "
                             << gnode << " to proc " << prank
                             << " because it is note a local node");
 
     auto & scheme = communications.createSendScheme(prank);
     scheme.push_back(node);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 MasterNodeInfoPerProc::MasterNodeInfoPerProc(NodeSynchronizer & synchronizer,
                                              UInt message_cnt, UInt root)
     : NodeInfoPerProc(synchronizer, message_cnt, root),
       all_nodes(0, synchronizer.getMesh().getSpatialDimension()) {
   UInt nb_global_nodes = this->mesh.getNbGlobalNodes();
   this->comm.broadcast(nb_global_nodes, this->root);
 }
 
 /* -------------------------------------------------------------------------- */
 void MasterNodeInfoPerProc::synchronizeNodes() {
   this->nodes_per_proc.resize(nb_proc);
   this->nb_nodes_per_proc.resize(nb_proc);
 
   Array<Real> local_nodes(0, spatial_dimension);
   Array<Real> & nodes = this->getNodes();
 
   all_nodes.copy(nodes);
-  nodes_pranks.resize(nodes.size(), root);
+  nodes_pranks.resize(nodes.size(), UInt(-1));
 
   for (UInt p = 0; p < nb_proc; ++p) {
     UInt nb_nodes = 0;
     //      UInt * buffer;
     Array<Real> * nodes_to_send;
 
     Array<UInt> & nodespp = nodes_per_proc[p];
     if (p != root) {
       nodes_to_send = new Array<Real>(0, spatial_dimension);
       AKANTU_DEBUG_INFO("Receiving number of nodes from proc "
                         << p << " " << Tag::genTag(p, 0, Tag::_NB_NODES));
       comm.receive(nb_nodes, p, Tag::genTag(p, 0, Tag::_NB_NODES));
       nodespp.resize(nb_nodes);
       this->nb_nodes_per_proc(p) = nb_nodes;
 
       AKANTU_DEBUG_INFO("Receiving list of nodes from proc "
                         << p << " " << Tag::genTag(p, 0, Tag::_NODES));
       comm.receive(nodespp, p, Tag::genTag(p, 0, Tag::_NODES));
     } else {
       Array<UInt> & local_ids = this->getNodesGlobalIds();
       this->nb_nodes_per_proc(p) = local_ids.size();
       nodespp.copy(local_ids);
       nodes_to_send = &local_nodes;
     }
 
     Array<UInt>::const_scalar_iterator it = nodespp.begin();
     Array<UInt>::const_scalar_iterator end = nodespp.end();
     /// get the coordinates for the selected nodes
     for (; it != end; ++it) {
       Vector<Real> coord(nodes.storage() + spatial_dimension * *it,
                          spatial_dimension);
       nodes_to_send->push_back(coord);
     }
 
     if (p != root) { /// send them for distant processors
       AKANTU_DEBUG_INFO("Sending coordinates to proc "
                         << p << " "
                         << Tag::genTag(this->rank, 0, Tag::_COORDINATES));
       comm.send(*nodes_to_send, p,
                 Tag::genTag(this->rank, 0, Tag::_COORDINATES));
       delete nodes_to_send;
     }
   }
 
   /// construct the local nodes coordinates
   nodes.copy(local_nodes);
 }
 
 /* -------------------------------------------------------------------------- */
 void MasterNodeInfoPerProc::synchronizeTypes() {
   //           <global_id,     <proc, local_id> >
   std::multimap<UInt, std::pair<UInt, UInt>> nodes_to_proc;
   std::vector<Array<NodeFlag>> nodes_flags_per_proc(nb_proc);
   std::vector<Array<Int>> nodes_prank_per_proc(nb_proc);
 
   if (mesh.isPeriodic())
     all_periodic_flags.copy(this->getNodesFlags());
 
   // arrays containing pairs of (proc, node)
   std::vector<Array<UInt>> nodes_to_send_per_proc(nb_proc);
   for (UInt p = 0; p < nb_proc; ++p) {
     nodes_flags_per_proc[p].resize(nb_nodes_per_proc(p), NodeFlag(0xFF));
     nodes_prank_per_proc[p].resize(nb_nodes_per_proc(p), -1);
   }
 
   this->fillNodesType();
 
-  for (UInt p = 0; p < nb_proc; ++p) {
+  auto is_master = [](auto && flag) {
+    return (flag & NodeFlag::_shared_mask) == NodeFlag::_master;
+  };
+
+  auto is_local = [](auto && flag) {
+    return (flag & NodeFlag::_shared_mask) == NodeFlag::_normal;
+  };
+
+  for (auto p : arange(nb_proc)) {
     auto & nodes_flags = nodes_flags_per_proc[p];
+
     if (p != root) {
       AKANTU_DEBUG_INFO(
           "Receiving first nodes types from proc "
           << p << " "
           << Tag::genTag(this->rank, this->message_count, Tag::_NODES_TYPE));
       comm.receive(nodes_flags, p, Tag::genTag(p, 0, Tag::_NODES_TYPE));
     } else {
       nodes_flags.copy(this->getNodesFlags());
     }
 
     // stack all processors claiming to be master for a node
-    for (UInt local_node = 0; local_node < nb_nodes_per_proc(p); ++local_node) {
-      if ((nodes_flags(local_node) & NodeFlag::_shared_mask) ==
-          NodeFlag::_master) {
-        UInt global_node = nodes_per_proc[p](local_node);
+    for (auto local_node : arange(nb_nodes_per_proc(p))) {
+      auto global_node = nodes_per_proc[p](local_node);
+
+      if (is_master(nodes_flags(local_node))) {
         nodes_to_proc.insert(
             std::make_pair(global_node, std::make_pair(p, local_node)));
-      } else if ((nodes_flags(local_node) & NodeFlag::_shared_mask) ==
-                 NodeFlag::_normal) {
-        nodes_prank_per_proc[p](local_node) = p;
-        nodes_pranks[mesh.getNodeGlobalId(local_node)] = p;
+
+      } else if (is_local(nodes_flags(local_node))) {
+        nodes_pranks[global_node] = p;
       }
     }
   }
 
-  for (UInt i = 0; i < mesh.getNbGlobalNodes(); ++i) {
+  for (auto i : arange(mesh.getNbGlobalNodes())) {
     auto it_range = nodes_to_proc.equal_range(i);
     if (it_range.first == nodes_to_proc.end() || it_range.first->first != i)
       continue;
 
     // pick the first processor out of the multi-map as the actual master
     UInt master_proc = (it_range.first)->second.first;
     nodes_pranks[i] = master_proc;
 
-    for (auto it_node = it_range.first; it_node != it_range.second; ++it_node) {
-      UInt proc = it_node->second.first;
-      UInt node = it_node->second.second;
-      nodes_prank_per_proc[proc](node) = master_proc;
+    for (auto && data : range(it_range.first, it_range.second)) {
+      auto proc = data.second.first;
+      auto node = data.second.second;
+
       if (proc != master_proc) {
         // store the info on all the slaves for a given master
         nodes_flags_per_proc[proc](node) = NodeFlag::_slave;
         nodes_to_send_per_proc[master_proc].push_back(proc);
         nodes_to_send_per_proc[master_proc].push_back(i);
       }
     }
   }
 
+  /// Fills the nodes prank per proc
+  for (auto && data : zip(arange(nb_proc), nodes_per_proc, nodes_prank_per_proc,
+                          nodes_flags_per_proc)) {
+    for (auto && node_data :
+         zip(std::get<1>(data), std::get<2>(data), std::get<3>(data))) {
+      if (std::get<2>(node_data) == NodeFlag::_normal) {
+        std::get<1>(node_data) = std::get<0>(data);
+      } else {
+        std::get<1>(node_data) = nodes_pranks(std::get<0>(node_data));
+      }
+    }
+  }
+
   std::vector<CommunicationRequest> requests_send_type;
   std::vector<CommunicationRequest> requests_send_master_info;
   for (UInt p = 0; p < nb_proc; ++p) {
     if (p != root) {
       AKANTU_DEBUG_INFO("Sending nodes types to proc "
                         << p << " "
                         << Tag::genTag(this->rank, 0, Tag::_NODES_TYPE));
       requests_send_type.push_back(
           comm.asyncSend(nodes_flags_per_proc[p], p,
                          Tag::genTag(this->rank, 0, Tag::_NODES_TYPE)));
 
       requests_send_type.push_back(
           comm.asyncSend(nodes_prank_per_proc[p], p,
                          Tag::genTag(this->rank, 2, Tag::_NODES_TYPE)));
 
       auto & nodes_to_send = nodes_to_send_per_proc[p];
 
       AKANTU_DEBUG_INFO("Sending nodes master info to proc "
                         << p << " "
                         << Tag::genTag(this->rank, 1, Tag::_NODES_TYPE));
       requests_send_master_info.push_back(comm.asyncSend(
           nodes_to_send, p, Tag::genTag(this->rank, 1, Tag::_NODES_TYPE)));
     } else {
       this->getNodesFlags().copy(nodes_flags_per_proc[p]);
       for (auto && data : enumerate(nodes_prank_per_proc[p])) {
         auto node = std::get<0>(data);
-        if (not (mesh.isMasterNode(node) or mesh.isLocalNode(node))) {
+        if (not(mesh.isMasterNode(node) or mesh.isLocalNode(node))) {
           this->setNodePrank(node, std::get<1>(data));
         }
       }
 
       this->fillCommunicationScheme(nodes_to_send_per_proc[root]);
     }
   }
 
   comm.waitAll(requests_send_type);
   comm.freeCommunicationRequest(requests_send_type);
   requests_send_type.clear();
 
   comm.waitAll(requests_send_master_info);
   comm.freeCommunicationRequest(requests_send_master_info);
 }
 
 /* -------------------------------------------------------------------------- */
 void MasterNodeInfoPerProc::synchronizeGroups() {
   AKANTU_DEBUG_IN();
 
   UInt nb_total_nodes = mesh.getNbGlobalNodes();
 
   DynamicCommunicationBuffer buffer;
 
   using NodeToGroup = std::vector<std::vector<std::string>>;
   NodeToGroup node_to_group;
   node_to_group.resize(nb_total_nodes);
 
   GroupManager::const_node_group_iterator ngi = mesh.node_group_begin();
   GroupManager::const_node_group_iterator nge = mesh.node_group_end();
   for (; ngi != nge; ++ngi) {
     NodeGroup & ng = *(ngi->second);
 
     std::string name = ngi->first;
 
     NodeGroup::const_node_iterator nit = ng.begin();
     NodeGroup::const_node_iterator nend = ng.end();
     for (; nit != nend; ++nit) {
       node_to_group[*nit].push_back(name);
     }
 
     nit = ng.begin();
     if (nit != nend)
       ng.empty();
   }
 
   buffer << node_to_group;
 
   std::vector<CommunicationRequest> requests;
   for (UInt p = 0; p < nb_proc; ++p) {
     if (p == this->rank)
       continue;
     AKANTU_DEBUG_INFO("Sending node groups to proc "
                       << p << " "
                       << Tag::genTag(this->rank, p, Tag::_NODE_GROUP));
     requests.push_back(comm.asyncSend(
         buffer, p, Tag::genTag(this->rank, p, Tag::_NODE_GROUP)));
   }
 
   this->fillNodeGroupsFromBuffer(buffer);
 
   comm.waitAll(requests);
   comm.freeCommunicationRequest(requests);
   requests.clear();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MasterNodeInfoPerProc::synchronizePeriodicity() {
   bool is_periodic = mesh.isPeriodic();
   comm.broadcast(is_periodic, root);
 
   if (not is_periodic)
     return;
 
   std::vector<CommunicationRequest> requests;
   std::vector<Array<UInt>> periodic_info_to_send_per_proc;
   for (auto p : arange(nb_proc)) {
     periodic_info_to_send_per_proc.emplace_back(0, 2);
     auto && periodic_info = periodic_info_to_send_per_proc.back();
 
     for (UInt proc_local_node : arange(nb_nodes_per_proc(p))) {
       UInt global_node = nodes_per_proc[p](proc_local_node);
       if ((all_periodic_flags[global_node] & NodeFlag::_periodic_mask) ==
           NodeFlag::_periodic_slave) {
         periodic_info.push_back(
             Vector<UInt>{global_node, mesh.getPeriodicMaster(global_node)});
       }
     }
 
     if (p == root)
       continue;
 
     auto && tag = Tag::genTag(this->rank, p, Tag::_PERIODIC_SLAVES);
     AKANTU_DEBUG_INFO("Sending periodic info to proc " << p << " " << tag);
     requests.push_back(comm.asyncSend(periodic_info, p, tag));
   }
 
   CommunicationStatus status;
   std::vector<DynamicCommunicationBuffer> buffers(nb_proc);
   std::vector<std::vector<UInt>> proc_missings(nb_proc);
   auto nodes_it = all_nodes.begin(spatial_dimension);
 
   for (UInt p = 0; p < nb_proc; ++p) {
     auto & proc_missing = proc_missings[p];
     if (p != root) {
       auto && tag = Tag::genTag(p, 0, Tag::_PERIODIC_NODES);
       comm.probe<UInt>(p, tag, status);
 
       proc_missing.resize(status.size());
       comm.receive(proc_missing, p, tag);
     } else {
       fillPeriodicPairs(periodic_info_to_send_per_proc[root], proc_missing);
     }
 
     auto & buffer = buffers[p];
     buffer.reserve((spatial_dimension * sizeof(Real) + sizeof(Int)) *
                    proc_missing.size());
     buffer << proc_missing.size();
     for (auto && node : proc_missing) {
       buffer << *(nodes_it + node);
       buffer << nodes_pranks(node);
     }
   }
 
   for (UInt p = 0; p < nb_proc; ++p) {
     for (auto && node : proc_missings[p]) {
       auto & buffer = buffers[nodes_pranks(node)];
       buffer << node;
       buffer << p;
     }
   }
 
   for (UInt p = 0; p < nb_proc; ++p) {
     if (p != root) {
       auto && tag_send = Tag::genTag(p, 1, Tag::_PERIODIC_NODES);
       requests.push_back(comm.asyncSend(buffers[p], p, tag_send));
     } else {
       receiveMissingPeriodic(buffers[p]);
     }
   }
 
   comm.waitAll(requests);
   comm.freeCommunicationRequest(requests);
   requests.clear();
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 SlaveNodeInfoPerProc::SlaveNodeInfoPerProc(NodeSynchronizer & synchronizer,
                                            UInt message_cnt, UInt root)
     : NodeInfoPerProc(synchronizer, message_cnt, root) {
   UInt nb_global_nodes = 0;
   comm.broadcast(nb_global_nodes, root);
   this->setNbGlobalNodes(nb_global_nodes);
 }
 
 /* -------------------------------------------------------------------------- */
 void SlaveNodeInfoPerProc::synchronizeNodes() {
   AKANTU_DEBUG_INFO("Sending list of nodes to proc "
                     << root << " " << Tag::genTag(this->rank, 0, Tag::_NB_NODES)
                     << " " << Tag::genTag(this->rank, 0, Tag::_NODES));
   Array<UInt> & local_ids = this->getNodesGlobalIds();
   Array<Real> & nodes = this->getNodes();
 
   UInt nb_nodes = local_ids.size();
   comm.send(nb_nodes, root, Tag::genTag(this->rank, 0, Tag::_NB_NODES));
   comm.send(local_ids, root, Tag::genTag(this->rank, 0, Tag::_NODES));
 
   /* --------<<<<-COORDINATES---------------------------------------------- */
   nodes.resize(nb_nodes);
   AKANTU_DEBUG_INFO("Receiving coordinates from proc "
                     << root << " " << Tag::genTag(root, 0, Tag::_COORDINATES));
   comm.receive(nodes, root, Tag::genTag(root, 0, Tag::_COORDINATES));
 }
 
 /* -------------------------------------------------------------------------- */
 void SlaveNodeInfoPerProc::synchronizeTypes() {
   this->fillNodesType();
 
   auto & nodes_types = this->getNodesFlags();
 
   AKANTU_DEBUG_INFO("Sending first nodes types to proc "
                     << root << ""
                     << Tag::genTag(this->rank, 0, Tag::_NODES_TYPE));
   comm.send(nodes_types, root, Tag::genTag(this->rank, 0, Tag::_NODES_TYPE));
 
   AKANTU_DEBUG_INFO("Receiving nodes types from proc "
                     << root << " " << Tag::genTag(root, 0, Tag::_NODES_TYPE));
   comm.receive(nodes_types, root, Tag::genTag(root, 0, Tag::_NODES_TYPE));
 
   Array<Int> nodes_prank(nodes_types.size());
   comm.receive(nodes_prank, root, Tag::genTag(root, 2, Tag::_NODES_TYPE));
   for (auto && data : enumerate(nodes_prank)) {
     auto node = std::get<0>(data);
-    if (not (mesh.isMasterNode(node) or mesh.isLocalNode(node))) {
+    if (not(mesh.isMasterNode(node) or mesh.isLocalNode(node))) {
       this->setNodePrank(node, std::get<1>(data));
     }
   }
 
   AKANTU_DEBUG_INFO("Receiving nodes master info from proc "
                     << root << " " << Tag::genTag(root, 1, Tag::_NODES_TYPE));
   CommunicationStatus status;
   comm.probe<UInt>(root, Tag::genTag(root, 1, Tag::_NODES_TYPE), status);
 
   Array<UInt> nodes_master_info(status.size());
   if (nodes_master_info.size() > 0)
     comm.receive(nodes_master_info, root,
                  Tag::genTag(root, 1, Tag::_NODES_TYPE));
 
   this->fillCommunicationScheme(nodes_master_info);
 }
 
 /* -------------------------------------------------------------------------- */
 void SlaveNodeInfoPerProc::synchronizeGroups() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Receiving node groups from proc "
                     << root << " "
                     << Tag::genTag(root, this->rank, Tag::_NODE_GROUP));
 
   CommunicationStatus status;
   comm.probe<char>(root, Tag::genTag(root, this->rank, Tag::_NODE_GROUP),
                    status);
 
   CommunicationBuffer buffer(status.size());
   comm.receive(buffer, root, Tag::genTag(root, this->rank, Tag::_NODE_GROUP));
 
   this->fillNodeGroupsFromBuffer(buffer);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SlaveNodeInfoPerProc::synchronizePeriodicity() {
   bool is_periodic;
   comm.broadcast(is_periodic, root);
 
   if (not is_periodic)
     return;
 
   CommunicationStatus status;
   auto && tag = Tag::genTag(root, this->rank, Tag::_PERIODIC_SLAVES);
   comm.probe<UInt>(root, tag, status);
 
   Array<UInt> periodic_info(status.size() / 2, 2);
   comm.receive(periodic_info, root, tag);
 
   std::vector<UInt> proc_missing;
   fillPeriodicPairs(periodic_info, proc_missing);
 
   auto && tag_missing_request =
       Tag::genTag(this->rank, 0, Tag::_PERIODIC_NODES);
   comm.send(proc_missing, root, tag_missing_request);
 
   DynamicCommunicationBuffer buffer;
   auto && tag_missing = Tag::genTag(this->rank, 1, Tag::_PERIODIC_NODES);
   comm.receive(buffer, root, tag_missing);
 
   receiveMissingPeriodic(buffer);
 }
 
 } // akantu
diff --git a/src/synchronizer/node_synchronizer.cc b/src/synchronizer/node_synchronizer.cc
index d9a5f5272..fcb7010ba 100644
--- a/src/synchronizer/node_synchronizer.cc
+++ b/src/synchronizer/node_synchronizer.cc
@@ -1,181 +1,221 @@
 /**
 * @file   node_synchronizer.cc
 *
 * @author Nicolas Richart <nicolas.richart@epfl.ch>
 *
 * @date creation: Fri Jun 18 2010
 * @date last modification: Wed Nov 15 2017
 *
 * @brief  Implementation of the node synchronizer
 *
 * @section LICENSE
 *
 * Copyright (©)  2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 *
 * Akantu is free  software: you can redistribute it and/or  modify it under the
 * terms  of the  GNU Lesser  General Public  License as published by  the Free
 * Software Foundation, either version 3 of the License, or (at your option) any
 * later version.
 *
 * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
 * details.
 *
 * You should  have received  a copy  of the GNU  Lesser General  Public License
 * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
 /* -------------------------------------------------------------------------- */
 #include "node_synchronizer.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NodeSynchronizer::NodeSynchronizer(Mesh & mesh, const ID & id,
                                    MemoryID memory_id,
                                    const bool register_to_event_manager,
                                    EventHandlerPriority event_priority)
     : SynchronizerImpl<UInt>(mesh.getCommunicator(), id, memory_id),
       mesh(mesh) {
   AKANTU_DEBUG_IN();
 
   if (register_to_event_manager) {
     this->mesh.registerEventHandler(*this, event_priority);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 NodeSynchronizer::~NodeSynchronizer() = default;
 
 /* -------------------------------------------------------------------------- */
 Int NodeSynchronizer::getRank(const UInt & node) const {
   return this->mesh.getNodePrank(node);
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeSynchronizer::onNodesAdded(const Array<UInt> & /*nodes_list*/,
                                     const NewNodesEvent &) {
   std::map<UInt, std::vector<UInt>> nodes_per_proc;
 
   // recreates fully the schemes due to changes of global ids
   // \TODO add an event to handle global id changes
   for (auto && data : communications.iterateSchemes(_recv)) {
     auto & scheme = data.second;
     scheme.resize(0);
   }
 
   for (auto && local_id : arange(mesh.getNbNodes())) {
     if (not mesh.isSlaveNode(local_id))
       continue; // local, master or pure ghost
 
     auto global_id = mesh.getNodeGlobalId(local_id);
     auto proc = mesh.getNodePrank(local_id);
     nodes_per_proc[proc].push_back(global_id);
 
     auto & scheme = communications.createScheme(proc, _recv);
     scheme.push_back(local_id);
   }
 
   std::vector<CommunicationRequest> send_requests;
   for (auto && pair : communications.iterateSchemes(_recv)) {
     auto proc = pair.first;
 
     // if proc not in nodes_per_proc this should insert an empty array to send
     send_requests.push_back(communicator.asyncSend(
         nodes_per_proc[proc], proc, Tag::genTag(rank, proc, 0xcafe)));
   }
 
   for (auto && data : communications.iterateSchemes(_send)) {
     auto proc = data.first;
     auto & scheme = data.second;
     CommunicationStatus status;
 
     auto tag = Tag::genTag(proc, rank, 0xcafe);
     communicator.probe<UInt>(proc, tag, status);
 
     scheme.resize(status.size());
     communicator.receive(scheme, proc, tag);
     std::transform(scheme.begin(), scheme.end(), scheme.begin(),
                    [&](auto & gnode) { return mesh.getNodeLocalId(gnode); });
   }
 
   // communicator.receiveAnyNumber<UInt>(
   //     send_requests,
   //     [&](auto && proc, auto && nodes) {
   //       auto & scheme = communications.createScheme(proc, _send);
   //       scheme.resize(nodes.size());
   //       for (auto && data : enumerate(nodes)) {
   //         auto global_id = std::get<1>(data);
   //         auto local_id = mesh.getNodeLocalId(global_id);
   //         AKANTU_DEBUG_ASSERT(local_id != UInt(-1),
   //                             "The global node " << global_id
   //                                                << "is not known on rank "
   //                                                << rank);
   //         scheme[std::get<0>(data)] = local_id;
   //       }
   //     },
   //     Tag::genTag(rank, count, 0xcafe));
   // ++count;
 
   communicator.waitAll(send_requests);
   communicator.freeCommunicationRequest(send_requests);
 }
 
 /* -------------------------------------------------------------------------- */
 UInt NodeSynchronizer::sanityCheckDataSize(const Array<UInt> & nodes,
                                            const SynchronizationTag & tag,
                                            bool from_comm_desc) const {
   UInt size =
       SynchronizerImpl<UInt>::sanityCheckDataSize(nodes, tag, from_comm_desc);
 
+  // global id
+  if (tag != _gst_giu_global_conn) {
+    size += sizeof(UInt) * nodes.size();
+  }
+
+  // flag
+  size += sizeof(NodeFlag) * nodes.size();
+
   // positions
   size += mesh.getSpatialDimension() * sizeof(Real) * nodes.size();
 
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeSynchronizer::packSanityCheckData(
     CommunicationBuffer & buffer, const Array<UInt> & nodes,
-    const SynchronizationTag & /*tag*/) const {
+    const SynchronizationTag & tag) const {
   auto dim = mesh.getSpatialDimension();
   for (auto && node : nodes) {
+    if (tag != _gst_giu_global_conn) {
+      buffer << mesh.getNodeGlobalId(node);
+    }
+    buffer << mesh.getNodeFlag(node);
     buffer << Vector<Real>(mesh.getNodes().begin(dim)[node]);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeSynchronizer::unpackSanityCheckData(CommunicationBuffer & buffer,
                                              const Array<UInt> & nodes,
                                              const SynchronizationTag & tag,
                                              UInt proc, UInt rank) const {
   auto dim = mesh.getSpatialDimension();
   // std::set<SynchronizationTag> skip_conn_tags{_gst_smmc_facets_conn,
   //                                             _gst_giu_global_conn};
 
   // bool is_skip_tag_conn = skip_conn_tags.find(tag) != skip_conn_tags.end();
 
+  auto periodic = [&](auto && flag) { return flag & NodeFlag::_periodic_mask; };
+  auto distrib = [&](auto && flag) { return flag & NodeFlag::_shared_mask; };
+
   for (auto && node : nodes) {
+    if (tag != _gst_giu_global_conn) {
+      UInt global_id;
+      buffer >> global_id;
+      AKANTU_DEBUG_ASSERT(global_id == mesh.getNodeGlobalId(node),
+                          "The nodes global ids do not match: "
+                              << global_id
+                              << " != " << mesh.getNodeGlobalId(node));
+    }
+
+    NodeFlag flag;
+    buffer >> flag;
+    AKANTU_DEBUG_ASSERT(
+        (periodic(flag) == periodic(mesh.getNodeFlag(node))) and
+            (((distrib(flag) == NodeFlag::_master) and
+              (distrib(mesh.getNodeFlag(node)) ==
+               NodeFlag::_slave)) or // master to slave
+             ((distrib(flag) == NodeFlag::_slave) and
+              (distrib(mesh.getNodeFlag(node)) ==
+               NodeFlag::_master)) or // reverse comm slave to master
+             (distrib(mesh.getNodeFlag(node)) ==
+                  NodeFlag::_pure_ghost or // pure ghost nodes
+              distrib(flag) == NodeFlag::_pure_ghost)),
+        "The node flags do not make sense: "
+            << std::hex << "0x" << flag << " and 0x" << mesh.getNodeFlag(node));
+
     Vector<Real> pos_remote(dim);
     buffer >> pos_remote;
     Vector<Real> pos(mesh.getNodes().begin(dim)[node]);
 
     auto dist = pos_remote.distance(pos);
     if (not Math::are_float_equal(dist, 0.)) {
       AKANTU_EXCEPTION("Unpacking an unknown value for the node "
                        << node << "(position " << pos << " != buffer "
                        << pos_remote << ") [" << dist << "] - tag: " << tag
                        << " comm from " << proc << " to " << rank);
     }
   }
 }
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/synchronizer/node_synchronizer.hh b/src/synchronizer/node_synchronizer.hh
index 54678417e..4d04b8970 100644
--- a/src/synchronizer/node_synchronizer.hh
+++ b/src/synchronizer/node_synchronizer.hh
@@ -1,127 +1,127 @@
 /**
  * @file   node_synchronizer.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Nov 08 2016
  * @date last modification: Tue Feb 20 2018
  *
  * @brief  Synchronizer for nodal information
  *
  * @section LICENSE
  *
  * Copyright (©) 2016-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "mesh_events.hh"
 #include "synchronizer_impl.hh"
 /* -------------------------------------------------------------------------- */
 #include <unordered_map>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_NODE_SYNCHRONIZER_HH__
 #define __AKANTU_NODE_SYNCHRONIZER_HH__
 
 namespace akantu {
 
 class NodeSynchronizer : public MeshEventHandler,
                          public SynchronizerImpl<UInt> {
 public:
   NodeSynchronizer(Mesh & mesh, const ID & id = "element_synchronizer",
                    MemoryID memory_id = 0,
                    const bool register_to_event_manager = true,
                    EventHandlerPriority event_priority = _ehp_synchronizer);
 
   ~NodeSynchronizer() override;
 
   /* ------------------------------------------------------------------------ */
   /// Uses the synchronizer to perform a reduction on the vector
   template <template <class> class Op, typename T>
   void reduceSynchronize(Array<T> & array) const;
 
   /* ------------------------------------------------------------------------ */
-  template <typename T>
-  void synchronize(Array<T> & array) const;
+  template <typename T> void synchronizeData(Array<T> & array) const;
 
   friend class NodeInfoPerProc;
 
   UInt sanityCheckDataSize(const Array<UInt> & nodes,
                            const SynchronizationTag & tag,
                            bool from_comm_desc) const override;
   void packSanityCheckData(CommunicationBuffer & buffer,
                            const Array<UInt> & nodes,
                            const SynchronizationTag & /*tag*/) const override;
   void unpackSanityCheckData(CommunicationBuffer & buffer,
                              const Array<UInt> & nodes,
                              const SynchronizationTag & tag, UInt proc,
                              UInt rank) const override;
 
   /// function to implement to react on  akantu::NewNodesEvent
   void onNodesAdded(const Array<UInt> &, const NewNodesEvent &) override;
 
   /// function to implement to react on  akantu::RemovedNodesEvent
   void onNodesRemoved(const Array<UInt> &, const Array<UInt> &,
                       const RemovedNodesEvent &) override {}
   /// function to implement to react on  akantu::NewElementsEvent
   void onElementsAdded(const Array<Element> &,
                        const NewElementsEvent &) override {}
   /// function to implement to react on  akantu::RemovedElementsEvent
   void onElementsRemoved(const Array<Element> &,
                          const ElementTypeMapArray<UInt> &,
                          const RemovedElementsEvent &) override {}
   /// function to implement to react on  akantu::ChangedElementsEvent
   void onElementsChanged(const Array<Element> &, const Array<Element> &,
                          const ElementTypeMapArray<UInt> &,
                          const ChangedElementsEvent &) override {}
 
   /* ------------------------------------------------------------------------ */
   NodeSynchronizer & operator=(const NodeSynchronizer & other) {
     copySchemes(other);
     return *this;
   }
 
 public:
   AKANTU_GET_MACRO(Mesh, mesh, Mesh &);
 
 protected:
   Int getRank(const UInt & node) const final;
 
 protected:
   Mesh & mesh;
 
   // std::unordered_map<UInt, Int> node_to_prank;
 };
 
+/* -------------------------------------------------------------------------- */
+template <typename T>
+void NodeSynchronizer::synchronizeData(Array<T> & array) const {
+  SimpleUIntDataAccessor<T> data_accessor(array, _gst_whatever);
+  this->synchronizeOnce(data_accessor, _gst_whatever);
+}
+
 /* -------------------------------------------------------------------------- */
 template <template <class> class Op, typename T>
 void NodeSynchronizer::reduceSynchronize(Array<T> & array) const {
   ReduceDataAccessor<UInt, Op, T> data_accessor(array, _gst_whatever);
   this->slaveReductionOnceImpl(data_accessor, _gst_whatever);
-  this->synchronize(array);
-}
-
-/* -------------------------------------------------------------------------- */
-template <typename T> void NodeSynchronizer::synchronize(Array<T> & array) const {
-  SimpleUIntDataAccessor<T> data_accessor(array, _gst_whatever);
-  this->synchronizeOnce(data_accessor, _gst_whatever);
+  this->synchronizeData(array);
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_NODE_SYNCHRONIZER_HH__ */
diff --git a/src/synchronizer/periodic_node_synchronizer.cc b/src/synchronizer/periodic_node_synchronizer.cc
index 2a8b36137..dda28c1ed 100644
--- a/src/synchronizer/periodic_node_synchronizer.cc
+++ b/src/synchronizer/periodic_node_synchronizer.cc
@@ -1,120 +1,131 @@
 /**
  * @file   periodic_node_synchronizer.cc
  *
  * @author Nicolas Richart
  *
  * @date creation  Tue May 29 2018
  *
  * @brief Implementation of the periodic node synchronizer
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "periodic_node_synchronizer.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 PeriodicNodeSynchronizer::PeriodicNodeSynchronizer(
     Mesh & mesh, const ID & id, MemoryID memory_id,
     const bool register_to_event_manager, EventHandlerPriority event_priority)
     : NodeSynchronizer(mesh, id + ":masters", memory_id,
                        register_to_event_manager, event_priority) {}
 
 /* -------------------------------------------------------------------------- */
 void PeriodicNodeSynchronizer::update() {
+  static int count = 0;
   const auto & masters_to_slaves = this->mesh.getPeriodicMasterSlaves();
   masters_list.resize(0);
   masters_list.reserve(masters_to_slaves.size());
 
   slaves_list.resize(0);
   slaves_list.reserve(masters_to_slaves.size());
 
   reset();
 
   std::set<UInt> masters_to_receive;
-  for(auto && data : masters_to_slaves) {
+  for (auto && data : masters_to_slaves) {
     auto master = std::get<0>(data);
     auto slave = std::get<1>(data);
 
     masters_list.push_back(master);
     slaves_list.push_back(slave);
 
-    if(not (mesh.isMasterNode(master) or mesh.isLocalNode(master))) {
+    if (not(mesh.isMasterNode(master) or mesh.isLocalNode(master))) {
       masters_to_receive.insert(master);
     }
   }
 
-  if(not mesh.isDistributed()) return;
+  if (not mesh.isDistributed())
+    return;
 
   std::map<Int, Array<UInt>> buffers;
-  for(auto node : masters_to_receive) {
+  for (auto node : masters_to_receive) {
     auto && proc = mesh.getNodePrank(node);
     auto && scheme = this->communications.createRecvScheme(proc);
     scheme.push_back(node);
 
     buffers[proc].push_back(mesh.getNodeGlobalId(node));
   }
 
-  auto tag = Tag::genTag(0, 0, Tag::_MODIFY_SCHEME);
+  auto tag = Tag::genTag(0, count, Tag::_MODIFY_SCHEME);
   std::vector<CommunicationRequest> requests;
   for (auto && data : buffers) {
     auto proc = std::get<0>(data);
     auto & buffer = std::get<1>(data);
 
-    requests.push_back(communicator.asyncSend(buffer, proc, tag));
+    requests.push_back(communicator.asyncSend(buffer, proc, tag,
+                                              CommunicationMode::_synchronous));
+    std::cout << "Recv from proc : " << proc << " -> "
+              << this->communications.getScheme(proc, _recv).size()
+              << std::endl;
   }
 
-  communicator.receiveAnyNumber<UInt>(requests, [&](auto && proc, auto && msg) {
-      auto && scheme = this->communications.createSendScheme(proc);
-      for (auto node : msg) {
-        scheme.push_back(mesh.getNodeLocalId(node));
-      }
-    }, tag);
+  communicator.receiveAnyNumber<UInt>(
+      requests,
+      [&](auto && proc, auto && msg) {
+        auto && scheme = this->communications.createSendScheme(proc);
+        for (auto node : msg) {
+          scheme.push_back(mesh.getNodeLocalId(node));
+        }
+        std::cout << "Send to proc : " << proc << " -> " << scheme.size()
+                  << " [" << tag << "]" << std::endl;
+      },
+      tag);
+  ++count;
 }
 
 /* -------------------------------------------------------------------------- */
 void PeriodicNodeSynchronizer::synchronizeOnceImpl(
     DataAccessor<UInt> & data_accessor, const SynchronizationTag & tag) const {
   NodeSynchronizer::synchronizeOnceImpl(data_accessor, tag);
 
   auto size = data_accessor.getNbData(masters_list, tag);
   CommunicationBuffer buffer(size);
 
   data_accessor.packData(buffer, masters_list, tag);
   data_accessor.unpackData(buffer, slaves_list, tag);
 }
 
 /* -------------------------------------------------------------------------- */
 void PeriodicNodeSynchronizer::waitEndSynchronizeImpl(
-    DataAccessor<UInt> & data_accessor,
-    const SynchronizationTag & tag) {
+    DataAccessor<UInt> & data_accessor, const SynchronizationTag & tag) {
   NodeSynchronizer::waitEndSynchronizeImpl(data_accessor, tag);
 
   auto size = data_accessor.getNbData(masters_list, tag);
   CommunicationBuffer buffer(size);
 
   data_accessor.packData(buffer, masters_list, tag);
   data_accessor.unpackData(buffer, slaves_list, tag);
 }
 
 } // namespace akantu
diff --git a/test/test_mesh/test_mesh_periodic.cc b/test/test_mesh/test_mesh_periodic.cc
index 15d0595c2..6de1f3e0f 100644
--- a/test/test_mesh/test_mesh_periodic.cc
+++ b/test/test_mesh/test_mesh_periodic.cc
@@ -1,138 +1,139 @@
 /**
  * @file   test_mesh_periodic.cc
  *
  * @author Nicolas Richart
  *
  * @date creation  Sun Feb 11 2018
  *
  * @brief test makePeriodic
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "data_accessor.hh"
 #include "mesh.hh"
 #include "mesh_accessor.hh"
 //#include "mesh_partition_scotch.hh"
 #include "periodic_node_synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 #include "dumpable_inline_impl.hh"
 //#include "dumper_element_partition.hh"
 #include "dumper_iohelper_paraview.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char ** argv) {
   initialize(argc, argv);
 
-  constexpr UInt dim = 2;
+  constexpr UInt dim = 3;
 
   auto prank = Communicator::getStaticCommunicator().whoAmI();
   // auto psize = Communicator::getStaticCommunicator().getNbProc();
 
   Mesh mesh(dim);
   if (prank == 0) {
-    mesh.read("square_periodic.msh");
+    mesh.read("cube_periodic.msh");
   }
 
   MeshAccessor mesh_accessor(mesh);
   // mesh_accessor.wipePeriodicInfo();
   // mesh.makePeriodic(_z);
 
   // if (prank == 0) {
   //   MeshPartitionScotch partition(mesh, dim);
   //   partition.partitionate(psize);
   // }
 
   UInt offset = 0;
   for (auto && type : mesh.elementTypes()) {
     auto & g_ids = mesh.getDataPointer<UInt>("global_ids", type);
     for (auto && data : enumerate(g_ids)) {
       std::get<1>(data) = offset + std::get<0>(data);
     }
     offset += g_ids.size();
   }
 
   mesh.distribute();
 
-//  mesh.makePeriodic(_x);
-//  mesh.makePeriodic(_y);
+  mesh.makePeriodic(_x);
+  mesh.makePeriodic(_y);
+  mesh.makePeriodic(_z);
 
   auto * dumper = new DumperParaview("periodic", "./paraview");
   mesh.registerExternalDumper(*dumper, "periodic", true);
   mesh.addDumpMesh(mesh);
   if (mesh.isDistributed()) {
     mesh.addDumpFieldExternalToDumper(
         "periodic", "node_type",
         const_cast<const Mesh &>(mesh).getNodesFlags());
   }
   mesh.dump();
 
   Array<Int> periodic(mesh.getNbNodes(), 1, 0.);
   Array<Int> masters(mesh.getNbNodes(), 1, 0.);
   Array<Int> global_ids(mesh.getNbNodes(), 1, 0.);
   UInt prev_node = -1;
   UInt value = 0;
   const auto & periodic_ms = mesh.getPeriodicMasterSlaves();
   for (auto & pair : periodic_ms) {
     if (prev_node != pair.first) {
       ++value;
     }
 
     prev_node = pair.first;
     periodic(pair.first) = value;
     periodic(pair.second) = value;
 
     masters(pair.first) = 1;
     global_ids(pair.first) = mesh.getNodeGlobalId(pair.second);
 
     auto it = periodic_ms.find(pair.second);
     if (it != periodic_ms.end()) {
       AKANTU_EXCEPTION(pair.second << " is slave of " << pair.first
                                    << " and master of " << it->second);
     }
   }
   mesh.addDumpFieldExternalToDumper("periodic", "periodic", periodic);
   mesh.addDumpFieldExternalToDumper("periodic", "masters", masters);
   mesh.addDumpFieldExternalToDumper("periodic", "global_ids", global_ids);
   mesh.addDumpFieldExternalToDumper("periodic", "element_global_ids",
                                     mesh.getData<UInt>("global_ids"));
 
   mesh.dump();
 
   Array<Int> data(mesh.getNbNodes(), 1, 0.);
   mesh.addDumpFieldExternalToDumper("periodic", "data", data);
   for (auto node : arange(mesh.getNbNodes())) {
     if (mesh.isPeriodicMaster(node)) {
       data(node) = 1 * (prank + 1);
       if (mesh.isMasterNode(node) or mesh.isLocalNode(node)) {
         data(node) = 10 * (prank + 1);
       }
     }
   }
 
   mesh.dump();
 
   // SimpleUIntDataAccessor<Int> data_accessor(data, _gst_user_1);
   // mesh.getPeriodicNodeSynchronizer().synchronizeOnce(data_accessor,
   //                                                    _gst_user_1);
   mesh.dump();
 }
diff --git a/test/test_model/test_model_solver/test_model_solver_dynamic.cc b/test/test_model/test_model_solver/test_model_solver_dynamic.cc
index c91e43ff3..a0e7f651b 100644
--- a/test/test_model/test_model_solver/test_model_solver_dynamic.cc
+++ b/test/test_model/test_model_solver/test_model_solver_dynamic.cc
@@ -1,224 +1,226 @@
 /**
  * @file   test_model_solver_dynamic.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Apr 13 2016
  * @date last modification: Tue Feb 20 2018
  *
  * @brief  Test default dof manager
  *
  * @section LICENSE
  *
  * Copyright (©) 2016-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "communicator.hh"
 #include "data_accessor.hh"
 #include "dof_manager.hh"
 #include "dof_manager_default.hh"
 #include "element_synchronizer.hh"
 #include "mesh.hh"
 #include "mesh_accessor.hh"
 #include "model_solver.hh"
 #include "non_linear_solver.hh"
 #include "sparse_matrix.hh"
 #include "synchronizer_registry.hh"
 /* -------------------------------------------------------------------------- */
 #include "dumpable_inline_impl.hh"
 #include "dumper_element_partition.hh"
 #include "dumper_iohelper_paraview.hh"
 /* -------------------------------------------------------------------------- */
 #include "test_model_solver_my_model.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 #ifndef EXPLICIT
 #define EXPLICIT true
 #endif
 
 using namespace akantu;
 
 static void genMesh(Mesh & mesh, UInt nb_nodes);
 
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   initialize(argc, argv);
 
   UInt prank = Communicator::getStaticCommunicator().whoAmI();
   UInt global_nb_nodes = 201;
   UInt max_steps = 400;
   Real time_step = 0.001;
   Mesh mesh(1);
   Real F = -9.81;
   bool _explicit = EXPLICIT;
   const Real pulse_width = 0.2;
   const Real A = 0.01;
 
   if (prank == 0)
     genMesh(mesh, global_nb_nodes);
 
   mesh.distribute();
 
   mesh.makePeriodic(_x);
 
   MyModel model(F, mesh, _explicit);
 
   model.forces.clear();
   model.blocked.clear();
 
   for (auto && n : arange(mesh.getNbNodes())) {
     Real x = mesh.getNodes()(n) - 0.2;
     // Sinus * Gaussian
     Real L = pulse_width;
-    Real k = 0.1 * 2 * M_PI * 3 / L;
-    model.displacement(n) = A * sin(k * x) * exp(-(k * x) * (k * x) / (L * L));
+    Real k = 2 * M_PI / L;
+    //model.displacement(n) = A * sin(k * x) * exp(-(k * x) * (k * x) / (L * L));
+    model.displacement(n) = A * cos(k * x);
+    model.velocity(n) = k * A * sin(k * x);
   }
 
   if (!_explicit) {
     model.getNewSolver("dynamic", _tsst_dynamic, _nls_newton_raphson);
     model.setIntegrationScheme("dynamic", "disp", _ist_trapezoidal_rule_2,
                                IntegrationScheme::_displacement);
   } else {
     model.getNewSolver("dynamic", _tsst_dynamic_lumped, _nls_lumped);
     model.setIntegrationScheme("dynamic", "disp", _ist_central_difference,
                                IntegrationScheme::_acceleration);
   }
 
   model.setTimeStep(time_step);
 
   // #if EXPLICIT == true
   //   std::ofstream output("output_dynamic_explicit.csv");
   // #else
   //   std::ofstream output("output_dynamic_implicit.csv");
   // #endif
 
   if (prank == 0) {
     std::cout << std::scientific;
     std::cout << std::setw(14) << "time"
               << "," << std::setw(14) << "wext"
               << "," << std::setw(14) << "epot"
               << "," << std::setw(14) << "ekin"
               << "," << std::setw(14) << "total"
               << "," << std::setw(14) << "max_disp"
               << "," << std::setw(14) << "min_disp" << std::endl;
   }
   Real wext = 0.;
 
   model.getDOFManager().clearResidual();
   model.assembleResidual();
 
   Real epot = 0; // model.getPotentialEnergy();
   Real ekin = 0; // model.getKineticEnergy();
   Real einit = ekin + epot;
   Real etot = ekin + epot - wext - einit;
 
   Real max_disp = 0., min_disp = 0.;
   for (auto && disp : model.displacement) {
     max_disp = std::max(max_disp, disp);
     min_disp = std::min(min_disp, disp);
   }
 
   if (prank == 0) {
     std::cout << std::setw(14) << 0. << "," << std::setw(14) << wext << ","
               << std::setw(14) << epot << "," << std::setw(14) << ekin << ","
               << std::setw(14) << etot << "," << std::setw(14) << max_disp
               << "," << std::setw(14) << min_disp << std::endl;
   }
 
 #if EXPLICIT == false
   NonLinearSolver & solver =
       model.getDOFManager().getNonLinearSolver("dynamic");
 
   solver.set("max_iterations", 20);
 #endif
 
   auto * dumper = new DumperParaview("dynamic", "./paraview");
   mesh.registerExternalDumper(*dumper, "dynamic", true);
   mesh.addDumpMesh(mesh);
 
   mesh.addDumpFieldExternalToDumper("dynamic", "displacement",
                                     model.displacement);
   mesh.addDumpFieldExternalToDumper("dynamic", "velocity", model.velocity);
   mesh.addDumpFieldExternalToDumper("dynamic", "forces", model.forces);
   mesh.addDumpFieldExternalToDumper("dynamic", "acceleration",
                                     model.acceleration);
 
   mesh.dump();
 
   for (UInt i = 1; i < max_steps + 1; ++i) {
     model.solveStep("dynamic");
     mesh.dump();
 #if EXPLICIT == false
 // int nb_iter = solver.get("nb_iterations");
 // Real error = solver.get("error");
 // bool converged = solver.get("converged");
 // if (prank == 0)
 // std::cerr << error << " " << nb_iter << " -> " << converged << std::endl;
 #endif
 
     epot = model.getPotentialEnergy();
     ekin = model.getKineticEnergy();
     wext += model.getExternalWorkIncrement();
     etot = ekin + epot - wext - einit;
 
     Real max_disp = 0., min_disp = 0.;
     for (auto && disp : model.displacement) {
       max_disp = std::max(max_disp, disp);
       min_disp = std::min(min_disp, disp);
     }
 
     if (prank == 0) {
       std::cout << std::setw(14) << time_step * i << "," << std::setw(14)
                 << wext << "," << std::setw(14) << epot << "," << std::setw(14)
                 << ekin << "," << std::setw(14) << etot << "," << std::setw(14)
                 << max_disp << "," << std::setw(14) << min_disp << std::endl;
     }
 
     // if (std::abs(etot) > 1e-1) {
     //   AKANTU_ERROR("The total energy of the system is not conserved!");
     //}
   }
 
   // output.close();
   finalize();
   return EXIT_SUCCESS;
 }
 
 /* -------------------------------------------------------------------------- */
 void genMesh(Mesh & mesh, UInt nb_nodes) {
   MeshAccessor mesh_accessor(mesh);
   Array<Real> & nodes = mesh_accessor.getNodes();
   Array<UInt> & conn = mesh_accessor.getConnectivity(_segment_2);
 
   nodes.resize(nb_nodes);
 
   for (UInt n = 0; n < nb_nodes; ++n) {
     nodes(n, _x) = n * (1. / (nb_nodes - 1));
   }
 
   conn.resize(nb_nodes - 1);
   for (UInt n = 0; n < nb_nodes - 1; ++n) {
     conn(n, 0) = n;
     conn(n, 1) = n + 1;
   }
 
   mesh_accessor.makeReady();
 }
diff --git a/test/test_model/test_model_solver/test_model_solver_my_model.hh b/test/test_model/test_model_solver/test_model_solver_my_model.hh
index 5c394bf4c..1ab753794 100644
--- a/test/test_model/test_model_solver/test_model_solver_my_model.hh
+++ b/test/test_model/test_model_solver/test_model_solver_my_model.hh
@@ -1,478 +1,474 @@
 /**
  * @file   test_model_solver_my_model.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Apr 13 2016
  * @date last modification: Tue Feb 20 2018
  *
  * @brief  Test default dof manager
  *
  * @section LICENSE
  *
  * Copyright (©) 2016-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_iterators.hh"
 #include "communicator.hh"
 #include "data_accessor.hh"
 #include "dof_manager_default.hh"
 #include "element_synchronizer.hh"
 #include "mesh.hh"
 #include "model_solver.hh"
 #include "periodic_node_synchronizer.hh"
 #include "sparse_matrix.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 #ifndef __AKANTU_TEST_MODEL_SOLVER_MY_MODEL_HH__
 #define __AKANTU_TEST_MODEL_SOLVER_MY_MODEL_HH__
 
 /**
  *   =\o-----o-----o-> F
  *     |           |
  *     |---- L ----|
  */
 class MyModel : public ModelSolver, public DataAccessor<Element> {
 public:
   MyModel(Real F, Mesh & mesh, bool lumped)
       : ModelSolver(mesh, ModelType::_model, "model_solver", 0),
         nb_dofs(mesh.getNbNodes()), nb_elements(mesh.getNbElement()), E(1.),
         A(1.), rho(1.), lumped(lumped), mesh(mesh),
         displacement(nb_dofs, 1, "disp"), velocity(nb_dofs, 1, "velo"),
         acceleration(nb_dofs, 1, "accel"), blocked(nb_dofs, 1, "blocked"),
         forces(nb_dofs, 1, "force_ext"),
         internal_forces(nb_dofs, 1, "force_int"),
         stresses(nb_elements, 1, "stress"), strains(nb_elements, 1, "strain"),
         initial_lengths(nb_elements, 1, "L0") {
 
     this->initDOFManager();
     this->getDOFManager().registerDOFs("disp", displacement, _dst_nodal);
     this->getDOFManager().registerDOFsDerivative("disp", 1, velocity);
     this->getDOFManager().registerDOFsDerivative("disp", 2, acceleration);
     this->getDOFManager().registerBlockedDOFs("disp", blocked);
 
     displacement.set(0.);
     velocity.set(0.);
     acceleration.set(0.);
 
     forces.set(0.);
     blocked.set(false);
 
     UInt global_nb_nodes = mesh.getNbGlobalNodes();
     for (auto && n : arange(nb_dofs)) {
       auto global_id = mesh.getNodeGlobalId(n);
       if (global_id == (global_nb_nodes - 1))
         forces(n, _x) = F;
 
       if (global_id == 0)
         blocked(n, _x) = true;
     }
 
     auto cit = this->mesh.getConnectivity(_segment_2).begin(2);
     auto cend = this->mesh.getConnectivity(_segment_2).end(2);
     auto L_it = this->initial_lengths.begin();
 
     for (; cit != cend; ++cit, ++L_it) {
       const Vector<UInt> & conn = *cit;
       UInt n1 = conn(0);
       UInt n2 = conn(1);
       Real p1 = this->mesh.getNodes()(n1, _x);
       Real p2 = this->mesh.getNodes()(n2, _x);
 
       *L_it = std::abs(p2 - p1);
     }
 
     this->registerDataAccessor(*this);
     this->registerSynchronizer(
         const_cast<ElementSynchronizer &>(this->mesh.getElementSynchronizer()),
         _gst_user_1);
   }
 
   void assembleLumpedMass() {
     Array<Real> & M = this->getDOFManager().getLumpedMatrix("M");
     M.clear();
 
     this->assembleLumpedMass(_not_ghost);
     if (this->mesh.getNbElement(_segment_2, _ghost) > 0)
       this->assembleLumpedMass(_ghost);
 
     is_lumped_mass_assembled = true;
   }
 
   void assembleLumpedMass(const GhostType & ghost_type) {
-    Array<Real> & M = this->getDOFManager().getLumpedMatrix("M");
+    Array<Real> M(nb_dofs, 1, 0.);
 
     Array<Real> m_all_el(this->mesh.getNbElement(_segment_2, ghost_type), 2);
 
     auto m_it = m_all_el.begin(2);
 
     auto cit = this->mesh.getConnectivity(_segment_2, ghost_type).begin(2);
     auto cend = this->mesh.getConnectivity(_segment_2, ghost_type).end(2);
 
     for (; cit != cend; ++cit, ++m_it) {
       const Vector<UInt> & conn = *cit;
       UInt n1 = conn(0);
       UInt n2 = conn(1);
 
       Real p1 = this->mesh.getNodes()(n1, _x);
       Real p2 = this->mesh.getNodes()(n2, _x);
 
       Real L = std::abs(p2 - p1);
 
       Real M_n = rho * A * L / 2;
       (*m_it)(0) = (*m_it)(1) = M_n;
     }
 
     this->getDOFManager().assembleElementalArrayLocalArray(
         m_all_el, M, _segment_2, ghost_type);
 
-
-    if (mesh.isPeriodic()) {
-      mesh.getPeriodicNodeSynchronizer()
-          .reduceSynchronizeWithPBCSlaves<AddOperation>(M);
-    }
+    this->getDOFManager().assembleToLumpedMatrix("disp", M, "M");
   }
 
   void assembleMass() {
     SparseMatrix & M = this->getDOFManager().getMatrix("M");
     M.clear();
 
     Array<Real> m_all_el(this->nb_elements, 4);
     Array<Real>::matrix_iterator m_it = m_all_el.begin(2, 2);
 
     auto cit = this->mesh.getConnectivity(_segment_2).begin(2);
     auto cend = this->mesh.getConnectivity(_segment_2).end(2);
 
     Matrix<Real> m(2, 2);
     m(0, 0) = m(1, 1) = 2;
     m(0, 1) = m(1, 0) = 1;
 
     // under integrated
     // m(0, 0) = m(1, 1) = 3./2.;
     // m(0, 1) = m(1, 0) = 3./2.;
 
     // lumping the mass matrix
     // m(0, 0) += m(0, 1);
     // m(1, 1) += m(1, 0);
     // m(0, 1) = m(1, 0) = 0;
 
     for (; cit != cend; ++cit, ++m_it) {
       const Vector<UInt> & conn = *cit;
       UInt n1 = conn(0);
       UInt n2 = conn(1);
 
       Real p1 = this->mesh.getNodes()(n1, _x);
       Real p2 = this->mesh.getNodes()(n2, _x);
 
       Real L = std::abs(p2 - p1);
 
       Matrix<Real> & m_el = *m_it;
       m_el = m;
       m_el *= rho * A * L / 6.;
     }
     this->getDOFManager().assembleElementalMatricesToMatrix(
         "M", "disp", m_all_el, _segment_2);
 
     is_mass_assembled = true;
   }
 
   MatrixType getMatrixType(const ID &) { return _symmetric; }
 
   void assembleMatrix(const ID & matrix_id) {
     if (matrix_id == "K") {
       if (not is_stiffness_assembled)
         this->assembleStiffness();
     } else if (matrix_id == "M") {
       if (not is_mass_assembled)
         this->assembleMass();
     } else if (matrix_id == "C") {
       // pass, no damping matrix
     } else {
       AKANTU_EXCEPTION("This solver does not know what to do with a matrix "
                        << matrix_id);
     }
   }
 
   void assembleLumpedMatrix(const ID & matrix_id) {
     if (matrix_id == "M") {
       if (not is_lumped_mass_assembled)
         this->assembleLumpedMass();
     } else {
       AKANTU_EXCEPTION("This solver does not know what to do with a matrix "
                        << matrix_id);
     }
   }
 
   void assembleStiffness() {
     SparseMatrix & K = this->getDOFManager().getMatrix("K");
     K.clear();
 
     Matrix<Real> k(2, 2);
     k(0, 0) = k(1, 1) = 1;
     k(0, 1) = k(1, 0) = -1;
 
     Array<Real> k_all_el(this->nb_elements, 4);
 
     auto k_it = k_all_el.begin(2, 2);
     auto cit = this->mesh.getConnectivity(_segment_2).begin(2);
     auto cend = this->mesh.getConnectivity(_segment_2).end(2);
 
     for (; cit != cend; ++cit, ++k_it) {
       const auto & conn = *cit;
       UInt n1 = conn(0);
       UInt n2 = conn(1);
 
       Real p1 = this->mesh.getNodes()(n1, _x);
       Real p2 = this->mesh.getNodes()(n2, _x);
 
       Real L = std::abs(p2 - p1);
 
       auto & k_el = *k_it;
       k_el = k;
       k_el *= E * A / L;
     }
 
     this->getDOFManager().assembleElementalMatricesToMatrix(
         "K", "disp", k_all_el, _segment_2);
 
     is_stiffness_assembled = true;
   }
 
   void assembleResidual() {
     this->getDOFManager().assembleToResidual("disp", forces);
     internal_forces.clear();
 
     this->assembleResidual(_not_ghost);
 
     this->synchronize(_gst_user_1);
 
     this->getDOFManager().assembleToResidual("disp", internal_forces, -1.);
 
     // auto & comm = Communicator::getStaticCommunicator();
     // const auto & dof_manager_default =
     //   dynamic_cast<DOFManagerDefault &>(this->getDOFManager());
     // const auto & residual = dof_manager_default.getResidual();
     // int prank = comm.whoAmI();
     // int psize = comm.getNbProc();
 
     // for (int p = 0; p < psize; ++p) {
     //   if (prank == p) {
     //     UInt local_dof = 0;
     //     for (auto res : residual) {
     //       UInt global_dof =
     //       dof_manager_default.localToGlobalEquationNumber(local_dof);
     //       std::cout << local_dof << " [" << global_dof << " - "
     //                 << dof_manager_default.getDOFType(local_dof) << "]: " <<
     //                 res
     //                 << std::endl;
     //       ++local_dof;
     //     }
     //     std::cout << std::flush;
     //   }
     //   comm.barrier();
     // }
 
     // comm.barrier();
     // if(prank == 0) std::cout << "===========================" << std::endl;
   }
 
   void assembleResidual(const GhostType & ghost_type) {
     Array<Real> forces_internal_el(
         this->mesh.getNbElement(_segment_2, ghost_type), 2);
 
     auto cit = this->mesh.getConnectivity(_segment_2, ghost_type).begin(2);
     auto cend = this->mesh.getConnectivity(_segment_2, ghost_type).end(2);
 
     auto f_it = forces_internal_el.begin(2);
 
     auto strain_it = this->strains.begin();
     auto stress_it = this->stresses.begin();
     auto L_it = this->initial_lengths.begin();
 
     for (; cit != cend; ++cit, ++f_it, ++strain_it, ++stress_it, ++L_it) {
       const auto & conn = *cit;
       UInt n1 = conn(0);
       UInt n2 = conn(1);
 
       Real u1 = this->displacement(n1, _x);
       Real u2 = this->displacement(n2, _x);
 
       *strain_it = (u2 - u1) / *L_it;
       *stress_it = E * *strain_it;
       Real f_n = A * *stress_it;
       Vector<Real> & f = *f_it;
 
       f(0) = -f_n;
       f(1) = f_n;
     }
 
     this->getDOFManager().assembleElementalArrayLocalArray(
         forces_internal_el, internal_forces, _segment_2, ghost_type);
   }
 
   Real getPotentialEnergy() {
     Real res = 0;
 
     if (!lumped) {
       res = this->mulVectMatVect(this->displacement,
                                  this->getDOFManager().getMatrix("K"),
                                  this->displacement);
     } else {
       auto strain_it = this->strains.begin();
       auto stress_it = this->stresses.begin();
       auto strain_end = this->strains.end();
       auto L_it = this->initial_lengths.begin();
 
       for (; strain_it != strain_end; ++strain_it, ++stress_it, ++L_it) {
         res += *strain_it * *stress_it * A * *L_it;
       }
 
       mesh.getCommunicator().allReduce(res, SynchronizerOperation::_sum);
     }
 
     return res / 2.;
   }
 
   Real getKineticEnergy() {
     Real res = 0;
     if (!lumped) {
       res = this->mulVectMatVect(
           this->velocity, this->getDOFManager().getMatrix("M"), this->velocity);
     } else {
       auto & m = this->getDOFManager().getLumpedMatrix("M");
       auto it = velocity.begin();
       auto end = velocity.end();
       auto m_it = m.begin();
 
       for (UInt node = 0; it != end; ++it, ++m_it, ++node) {
         if (mesh.isLocalOrMasterNode(node))
           res += *m_it * *it * *it;
       }
 
       mesh.getCommunicator().allReduce(res, SynchronizerOperation::_sum);
     }
 
     return res / 2.;
   }
 
   Real getExternalWorkIncrement() {
     Real res = 0;
 
     auto it = velocity.begin();
     auto end = velocity.end();
     auto if_it = internal_forces.begin();
     auto ef_it = forces.begin();
     auto b_it = blocked.begin();
 
     for (UInt node = 0; it != end; ++it, ++if_it, ++ef_it, ++b_it, ++node) {
       if (mesh.isLocalOrMasterNode(node))
         res += (*b_it ? -*if_it : *ef_it) * *it;
     }
 
     mesh.getCommunicator().allReduce(res, SynchronizerOperation::_sum);
 
     return res * this->getTimeStep();
   }
 
   Real mulVectMatVect(const Array<Real> & x, const SparseMatrix & A,
                       const Array<Real> & y) {
     Array<Real> Ay(this->nb_dofs, 1, 0.);
     A.matVecMul(y, Ay);
     Real res = 0.;
 
     Array<Real>::const_scalar_iterator it = Ay.begin();
     Array<Real>::const_scalar_iterator end = Ay.end();
     Array<Real>::const_scalar_iterator x_it = x.begin();
 
     for (UInt node = 0; it != end; ++it, ++x_it, ++node) {
       if (mesh.isLocalOrMasterNode(node))
         res += *x_it * *it;
     }
 
     mesh.getCommunicator().allReduce(res, SynchronizerOperation::_sum);
     return res;
   }
 
   void predictor() {}
   void corrector() {}
 
   /* ------------------------------------------------------------------------ */
   UInt getNbData(const Array<Element> & elements,
                  const SynchronizationTag &) const {
     return elements.size() * sizeof(Real);
   }
 
   void packData(CommunicationBuffer & buffer, const Array<Element> & elements,
                 const SynchronizationTag & tag) const {
     if (tag == _gst_user_1) {
       for (const auto & el : elements) {
         buffer << this->stresses(el.element);
       }
     }
   }
 
   void unpackData(CommunicationBuffer & buffer, const Array<Element> & elements,
                   const SynchronizationTag & tag) {
     if (tag == _gst_user_1) {
       auto cit = this->mesh.getConnectivity(_segment_2, _ghost).begin(2);
 
       for (const auto & el : elements) {
         Real stress;
         buffer >> stress;
 
         Real f = A * stress;
 
         Vector<UInt> conn = cit[el.element];
         this->internal_forces(conn(0), _x) += -f;
         this->internal_forces(conn(1), _x) += f;
       }
     }
   }
 
 private:
   UInt nb_dofs;
   UInt nb_elements;
   Real E, A, rho;
 
   bool lumped;
 
   bool is_stiffness_assembled{false};
   bool is_mass_assembled{false};
   bool is_lumped_mass_assembled{false};
 
 public:
   Mesh & mesh;
   Array<Real> displacement;
   Array<Real> velocity;
   Array<Real> acceleration;
   Array<bool> blocked;
   Array<Real> forces;
   Array<Real> internal_forces;
 
   Array<Real> stresses;
   Array<Real> strains;
 
   Array<Real> initial_lengths;
 };
 
 #endif /* __AKANTU_TEST_MODEL_SOLVER_MY_MODEL_HH__ */
 
 } // akantu